Build AI Agents: From Local to Production Cloud

Inside the event

*If you face any issues with payment on Eventbrite, you can use this Luma link to purchase your ticket instead: https://luma.com/packt-h2h9

Building an AI agent that works in a demo is easy. Building one that survives production is a different problem.

Most agent tutorials lock you into one vendor and one hosted model from the first line of code. That works until you need to switch providers, control costs, satisfy a security requirement, or run the same logic in your own environment.

This workshop takes the opposite approach.

You will start by building and running a working agent locally, using open models and no cloud dependencies at all. Then you will take that same architecture and move it into a production cloud environment adding secure tool access through MCP, enterprise identity and IAM, and finally a coordinated multi-agent system with dynamic discovery.

By the end, you will have built a functional multi-agent network from scratch, and you will leave with a complete, deployable codebase and the infrastructure scripts to run the whole system in your own environment.

Why Attend?

If you are building with agents today, you have probably noticed that the gap between a working prototype and something you would actually deploy is large.

This workshop closes that gap. You will learn how to:

Write vendor-neutral agent logic that runs locally or in the cloud without a rewrite

Start with open models on your own machine, then move to cloud infrastructure only when you need it

Connect agents to enterprise context and external APIs using the Model Context Protocol (MCP)

Manage service accounts, IAM, and secure tool execution properly

Coordinate multiple agents that delegate, decompose tasks, and route work to each other

Deploy the whole system to a serverless platform

Add observability, cost tracking, and guardrails so it stays reliable in production

The focus is not just how agents work. The focus is how to build agents you can actually run, secure, and operate.

What You Will Build

You will build a coordinated multi-agent system, starting from a single local agent and ending with a network of agents running in the cloud.

Along the way, your system will be able to:

Run entirely on your own machine using open models, with no cloud account required

Move to a cloud environment without rewriting the core agent logic

Call secure, authenticated tools through MCP

Delegate work across an Orchestrator → Worker → Reviewer pattern

Discover and route tasks to peer agents based on their capabilities

Run reliably on a serverless platform with tracing, cost tracking, and error recovery

What You Will Learn

By the end of the workshop, you will understand how to:

Define agent anatomy: system instructions, memory, and agent "skills"

Apply the Portability Principle to keep agent logic vendor-neutral, using ADK with the LiteLLM connector, LMStudio, and open models such as Gemma

Migrate a local agent into a cloud environment cleanly

Connect agents to enterprise context and APIs through standard MCP interfaces

Handle identity and security: service accounts, IAM, dynamic scope elevation, and secure tool execution

Design Agent-to-Agent (A2A) patterns for delegation, task decomposition, and state management

Use discovery services so agents can dynamically register, locate, and route tasks

Deploy to a serverless cloud platform and observe agent loops, tool calls, latency, and cost

Add guardrails and error recovery: handling failed tool calls, graceful degradation, and loop prevention

Hands-On Labs

The workshop is built around four practical labs.

Lab 1 : Bootstrap a local agent

Set up ADK to run locally with the LiteLLM connector, LMStudio, and an open model. Build a functioning agent and test it on your own machine, with no cloud dependencies.

Lab 2 : Move to the cloud with secure MCP tools

Migrate your portable agent into a cloud environment and equip it with secure, authenticated, MCP-enabled tools — wired up with proper service accounts and IAM.

Lab 3 : Build a coordinated multi-agent network

Build an Orchestrator → Worker → Reviewer system where agents delegate tasks, share state, and communicate end to end. Extended lab time is set aside so everyone gets their agents talking to each other.

Lab 4 : Deploy to production with observability

Run your multi-agent system on a serverless platform, add tracing for agent loops and tool calls, track latency and cost, and put guardrails in place for graceful failure recovery.

Who Should Attend?

This workshop is designed for software engineers, platform and infrastructure engineers, backend developers, and ML/AI practitioners who want to move from agent prototypes to systems they can actually deploy and operate.

It is especially useful if you have already built an agent or two and now want to understand portability, security, multi-agent coordination, and production deployment.

You should be comfortable with:

Intermediate Python : classes, async programming, and API requests

Basic cloud infrastructure concepts : service accounts, IAM, and serverless compute

LLMs and basic prompting : no advanced AI/ML math required

What You Will Take Away

After completing the workshop, you will have:

A complete, deployable codebase for a working multi-agent system

The infrastructure scripts to run the whole system in your own environment

A vendor-neutral architecture you can adapt to your own models and cloud

Practical patterns for MCP tool integration, identity, and secure execution

Production-ready habits for observability, cost tracking, and guardrails

You will leave not with a demo you watched, but with a system you built and everything you need to run it again on your own.

Good to Know

Format: Interactive, hands-on coding and live demos Duration: 4 hours Location: Online