Building Multi-Agent Systems: The Agentic AI Engineer Track

Name: Building Multi-Agent Systems: The Agentic AI Engineer Track
Rating: 5.0 (2 reviews)

Build and Deploy Multi-Agent AI Systems with Google ADK, Gemini, Docker and Cloud Run — From Architecture to Production

New

Created byGeorge Alonge

Last updated 4/2026

English

What you'll learn

Architect enterprise-grade Multi-Agent AI systems using Google's Agent Development Kit (ADK).
Master the Core ADK Primitives, including Code Execution, Artifact Management, and Long-Term Memory.
Build "WealthPilot" - a stateful multi-agent AI financial advisor that can analyze stocks, executes Python code and generates PDF reports.
Deploy production-ready AI agents to Google Cloud Run and Vertex AI Agent Engine.
Orchestrate Sequential, Parallel, and Loop agent workflows to solve complex multi-step ReAct problems.
Write custom agent tools to give your AI agents the ability to interact with external APIs and live data.

Course content

4 sections • 19 lectures • 3h 39m total length

Welcome & What We Will Build3:09
Welcome to the course! In this opening lecture, we use a vivid food truck vs. high-end restaurant kitchen analogy to explain why single monolithic LLMs fail at complex enterprise tasks, and how multi-agent systems solve this by dividing labor among specialized AI agents. You'll get a first look at what we'll be building throughout the course: WealthPilot — an AI Financial Advisor that analyzes stocks, builds portfolios, and generates PDF reports using Google ADK.
The Problem with Monolithic LLMs4:40
Why do single-prompt AI chatbots break down? This lecture dives into the technical reasons: computational attention limits, context window overload, the "lost in the middle" syndrome, and hallucination. We then introduce Google ADK's single-parent rule architecture and how it enforces a strict chain of command. You'll learn about shared session state (the "order ticket" between agents) and LLM-driven delegation, where parent agents go dormant after handing off tasks to conserve GPU resources.
What is ADK?8:58
A deep dive into what Google's Agent Development Kit actually is. We break down the three pillars: model agnostic (use Gemini, Claude, GPT, or Llama), deployment agnostic (deploy anywhere — Google Cloud, local, or custom infrastructure), and interoperable (supports MCP protocol, A2A protocol, third-party tools). We review ADK's core features including flexible orchestration, multi-agent architecture, rich tool ecosystem, and built-in evaluation. Includes a live demo running the ADK Kitchen Brigade agent using both adk run (CLI) and adk web (visual interface).
Setting Up Your Local Development Environment (python)4:49
Time for our "mise en place" — setting up our development kitchen before we start cooking. This lecture walks through the complete Python setup for ADK development: installing Python 3.12+, the UV package manager (the modern replacement for pip), Node.js for the ADK web interface, and creating your first agent using adk create. We walk through the course repository's prerequisite guide step by step.
Setting Up Your Local Development Environment (go, java, typescript)1:58
Not using Python? No problem. ADK now supports Go, Java, and TypeScript. This short lecture covers the setup requirements for each: Go 1.24+ with go get, Java 17+ with Maven, and TypeScript with Node.js 24+ and npm 11.8+. Follow the prerequisite guides in the course repository for your language of choice.

Introduction to ADK Core Components13:04
Overview of the entire ADK primitive system. We cover the three foundational components (Runner, Agents, Session) plus Tools, Callbacks, Memory, Artifacts, Code Execution, Models, and Events. Then we introduce the WealthPilot project architecture: a multi-agent system with a Root Agent, Stock Analyst, Portfolio Advisor, and Report Generator. Includes a full live demo of the finished WealthPilot application analyzing Apple stock.
ADK Agents19:27
Deep dive into ADK agents — the brain of your AI system. We cover the two categories: deterministic agents (Sequential, Parallel, Loop) that follow predefined workflows, and non-deterministic agents (LLM Agent) where the model self-decides execution order. Hands-on implementation of the WealthPilot root agent, stock analyst agent, and portfolio advisor agent.
ADK Tools9:33
Tools are the hands of your agents. Learn how to extend agent functionality using custom functions and ADK's built-in integrations. We augment WealthPilot with tools to fetch stock information, get company data, and calculate portfolio metrics using the yFinance API.
ADK Callbacks15:28
Callbacks are lifecycle hooks that let you control execution at key points in your agent system. Using an airport security checkpoint analogy, we explore before/after LLM call hooks, agent lifecycle hooks, and tool execution hooks. We implement callbacks in WealthPilot for logging, input validation, and behavior modification.
ADK Sessions, State and Memory27:04
The most comprehensive lecture on data management in ADK. Session is the conversation thread, State is the notepad you scribble on during it (key-value storage valid only for the current session), and Memory is the long-term cabinet where you store notes across sessions. We cover InMemorySessionService for development and DatabaseSessionService for production, plus implementing cross-session recall in WealthPilot.
ADK Code Execution12:12
Code execution allows your agents to generate and run actual computations in secure sandboxes, rather than just producing text. Think of it as giving your agent a scratch pad for math and logic. We implement code execution in WealthPilot for compound interest calculations and portfolio projections.
ADK Artifacts15:27
Artifacts let your agents create, save, and version binary files — CSVs, images, PDFs, and more. We implement artifact management in WealthPilot to generate downloadable PDF portfolio reports, stored locally during development and ready for cloud storage in production.
ADK Planning4:19
For complex requests that need pre-planning before execution. ADK provides a base planner supporting two approaches: the built-in planner (configure a thinking budget for models that support thinking) and a custom plan-then-execute pattern for models without native thinking support. We configure planning in WealthPilot using the ReAct pattern for multi-step reasoning.
ADK Parallel and Loop Agents11:05
Optimize your multi-agent system with parallel execution and iterative loops. We implement ParallelAgent to analyze multiple stocks simultaneously (instead of sequentially), and LoopAgent as a risk tolerance checker that iterates until the portfolio matches user preferences.
ADK Runner10:49
The Runner is the execution engine — the stage manager of your agent theater. This lecture goes deep into how the Runner orchestrates agent execution, manages LLM calls, handles tool invocations, processes events, and coordinates the entire multi-agent flow. We examine the Runner's role in WealthPilot's end-to-end request lifecycle.

Deploying ADK Agents Locally, OnPrem13:54
Now that WealthPilot is built, it's time to deploy. This lecture covers the three local deployment options: ADK Web (dev UI + API server for prototyping), ADK Run (terminal REPL for quick testing), and the ADK API Server (headless REST API for production-grade local deployment). We configure the FastAPI-based API server for WealthPilot.
Deploying ADK Agents on GCP (cloudrun, agent engine)18:52
Take WealthPilot to production on Google Cloud Platform. We cover two deployment targets: Cloud Run (containerized serverless deployment) and Vertex AI Agent Engine (Google's managed agent runtime). Includes GCP project setup, enabling required APIs, configuring service accounts, and deploying the full multi-agent system to the cloud.

Requirements

Basic understanding of programming (functions, classes, dictionaries, and variable scoping).
A code editor (like VS Code) and basic familiarity with using a computer terminal/command prompt.
No prior AI engineering, machine learning, or complex math experience is required—we will teach you the framework from the ground up.

Description

Are you tired of "toy" AI tutorials that just build simple, stateless chatbots? Are you ready to architect real, autonomous, enterprise-grade multi-agent systems?

Welcome to the definitive masterclass on the Google Agent Development Kit (ADK).

Most developers stop at basic Gemini API calls, never learning how to give their AI long-term memory, custom tools, or secure code execution environments. This keeps them locked out of the high-paying AI Engineering market.

In this course, we skip the fluff and dive straight into professional architecture.

You will systematically master the 11 Core ADK Primitives. You won't just learn how to write the code; you will learn why the framework routes tasks the way it does, decoupling your agent's brain (models) from its memory (Session storage) for infinite cloud scalability.

What We Will Build

We learn by building. Throughout the course, you will engineer WealthPilot, an autonomous AI financial firm. You will build a Root Agent that delegates complex tasks to a specialized team:

► Stock Analyst — Uses custom tools to fetch live stock prices.

► Portfolio Manager — Uses the Code Execution sandbox to dynamically write and run Python scripts for compound interest calculations.

► Report Generator — Uses Artifact Management to save physical PDF reports to your hard drive.

The Cloud Deployment

In the final section, we will containerize your multi-agent system using Docker, run it locally, and deploy it natively to Google Cloud Run and Vertex AI Agent Engine for production-ready scale.

By the end of this course, you will have:

A fully working multi-agent AI financial system (WealthPilot)
Mastery of all 11 ADK primitives and when to use each one
A Dockerized deployment running on Google Cloud Run, and Agent Engine
The architecture skills to design your own multi-agent systems for any domain
An understanding of agent observability and how to implement it with Google ADK.

This course is for you if:

You're a developer who wants to break into AI Engineering
You've built basic chatbots but want to architect production multi-agent systems
You want to understand the why behind agent orchestration, not just copy-paste code

If you are a developer ready to move beyond prompt engineering and master true Multi-Agent Orchestration, enroll today and let's start building.

Who this course is for:

Developers looking to transition into high-paying AI Engineering and LLM orchestration roles.
Backend engineers wanting to move beyond simple chatbots and learn how to manage long-term agent memory and state.
Tech leads and software architects evaluating Google ADK for scalable, enterprise-grade cloud applications.
Anyone tired of "toy" AI tutorials who wants to build real, autonomous multi-agent systems.

Building Multi-Agent Systems: The Agentic AI Engineer Track

What you'll learn

Explore related topics

Course content

Introduction5 lectures • 24min

ADK Core Components10 lectures • 2hr 18min

Deploying ADK Agents2 lectures • 33min

Extras: Agent Observability with Google ADK2 lectures • 25min

Requirements

Description

Who this course is for: