Build AI Agents: From Local to Production Cloud

*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