Build AI Agents: From Local to Production Cloud
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