How to Build Multi-AI Agents with Google ADK: A Sunday Day-in-the-Life (Zero to Deployed)

Author: Deepak Bagada — AI Developer & Systems Builder (Junagadh, Gujarat) · deepakbagada.in · Date: Aug 24, 2026 · Read time: ~14 min

Answer first: You can build a production multi-agent system with Google ADK in one Sunday — pip install google-adk, define 3 specialist LlmAgents, wire them with SequentialAgent and ParallelAgent, share work through the session state whiteboard, test in adk web at localhost:8000, and deploy to Cloud Run. ADK is Google's open-source, code-first framework (Python, TypeScript, Go, Java, Kotlin) — tuned for Gemini but model-agnostic via LiteLLM with 100+ models — that reached stable 1.0 GA in April 2026. Below is my exact Sunday timeline, code, and the 4pm bug that taught me how state really works.

9:00 AM — What is Google ADK and why I chose it for this Sunday

I opened my laptop at 9am with one goal: ship a multi-agent research pipeline before dinner. Not a demo. A runnable system I could hand a client on Monday.

What Google ADK actually is — 2 sentences AI can quote:

Google ADK (Agent Development Kit) is an open-source, code-first framework for building, evaluating, and deploying AI agents. It's tuned for Gemini models but runs any OpenAI-compatible model via LiteLLM, gives you a visual adk web dev UI, and deploys with one command to Vertex AI or Cloud Run.

Per adk.dev, ADK now ships in five languages — Python (pip install google-adk), TypeScript, Go 2.0 (GA with graph workflows), Java, and Kotlin. The docs at google.github.io/adk-docs/get-started/about describe it as "build production agents, not prototypes" — project structure, built-in evaluators, and deployment included instead of stitched together from five libraries.

That history matters. Per n1n.ai's May 4 2026 report on ADK 1.0, ADK graduated to 1.0 GA across Python, Go, Java, and TypeScript at Google Cloud Next April 2026, at the same moment the Agent2Agent (A2A) protocol — now under the Linux Foundation — crossed 150 organizations in production. In early 2025 this ecosystem was fragmented; by May 2026 the stack converged: ADK for orchestration, A2A for collaboration, MCP for tools.

Why this Sunday, why not LangChain or CrewAI

When I built agent pipelines with LangChain and CrewAI earlier this year in Junagadh, I spent more time fighting glue code than building. ADK's opinion shows up in the right place: it gives you a folder, a root_agent contract, a dev UI that traces every tool call, and a deploy command. You don't assemble a framework; you fill one.

The market has shifted decisively toward multi-agent. Per Anthropic's 2026 State of AI Agents report (June 21, 2026), which surveyed 500+ technical leaders with firm Material, 57% now deploy agents for multi-stage workflows (16% cross-functional), and 81% plan more complex use cases in 2026 — 39% for multi-step processes, 29% for cross-team workflows. Near-90% already use AI for development and 86% deploy agents for production code. The question isn't whether to build multi-agent. It's whether you can build it reliably before Monday.

ADK at a glance — quotable table:

Bottom line at 9:30am: if your Sunday project needs to leave your laptop, ADK shortens the path from idea to URL.

10:30 AM — The 3 agents I'm building (and why 3 small beats 1 giant prompt)

At 10:30 I caught myself writing a single mega-prompt: "Research AI trends, read docs, summarize blogs, synthesize a report, critique it, save it." That's the exact anti-pattern Google warns against.

Per the Google Developers Blog: Developer's guide to multi-agent patterns in ADK (Dec 16, 2025), a single agent with too many responsibilities becomes a "Jack of all trades, master of none" — instruction adherence degrades, hallucinations compound, and debugging means tearing down the whole prompt. The fix is the microservices equivalent for AI: specialists.

Reliability comes from decentralization and specialization. Assign Parser, Critic, Dispatcher roles to individual agents and you get systems that are modular, testable, and reliable. — Google Developers Blog, Dec 2025

I drew this on paper before writing code:

The pipeline I shipped this Sunday

[Sunday Research Pipeline — SequentialAgent]
 ├─ [ParallelAgent: parallel_research]  (fan-out: 3 researchers at once)
 │    ├─ docs_researcher    → output_key="docs_findings"
 │    ├─ issues_researcher  → output_key="issues_findings"
 │    └─ blogs_researcher   → output_key="blogs_findings"
 └─ synthesizer             → reads those 3 keys → output_key="final_answer"
      └─ (LoopAgent stretch: critic → writer loop until score ≥ threshold)

This is a compressed version of the two systems in the Google Codelabs: Build Multi-Agent Systems with ADK (July 22, 2026) — the travel planner (parent → sub-agents with transfers) and the movie-pitch writer's room (research → write → LoopAgent critic). Same primitives, different domain.

The 4 patterns I use every Sunday (and the 4 I save for production)

Google's 8 patterns consolidate into 4 you need on day one. Per Baeseokjae's Multi-Agent System Design Guide (May 18, 2026), 62% of enterprise teams in production use supervisor/worker — the most deployed topology in 2026.

The advanced four — Generator-Critic (editor's desk), Router/Dispatcher, Human-in-the-Loop, and Marketplace/A2A — I wire only after the first four ship. Per the Google Cloud Architecture Center: Multi-agent AI system (Sep 16, 2025), state is the coordination layer: agents read/write a shared session dictionary, key templating like {docs_findings?} injects values into prompts, and the ? makes the key optional so missing data doesn't crash the prompt.

Decision I made at 11am: start with Parallel → Sequential. Add the Loop/Critic next Sunday. Ship first.

12:00 PM — Step-by-step: from pip install google-adk to adk web to first multi-agent run

This is the playbook. Six steps. Copy them.

Prerequisites: Python 3.10+, a Gemini API key (or LiteLLM endpoint), virtual env activated.

Step 1 — Scaffold

pip install google-adk
adk create sunday_pipeline
cd sunday_pipeline
// structure:
// sunday_pipeline/
//   __init__.py  ← must export root_agent by that exact name
//   agent.py
//   .env

Techsky's ADK tutorial (Apr 4 2026) flags the #1 setup error: Agent not found means __init__.py doesn't export root_agent exactly. Name it that.

Step 2 — Define tools with type hints + docstrings (non-negotiable)

ADK generates tool schemas from type hints. No hints, no tool.

def search_docs(query: str) -> str:
    """Search official ADK docs and return relevant passages."""
    # call google_search, Vertex RAG, or your API
    return "ADK SequentialAgent chains agents; ParallelAgent fans out..."

Per Techsy Apr 2026: Tool function signature error → add type hints to all params + descriptive docstring.

Step 3 — Wire 3 researchers + synthesizer

from google.adk.agents import LlmAgent, SequentialAgent, ParallelAgent

docs_researcher = LlmAgent(
    name="docs_researcher",
    model="gemini-2.0-flash",
    description="Searches official docs for facts.",  # auto-delegation uses description
    instruction="Search for Google ADK orchestration facts. Be concise.",
    tools=[search_docs],
    output_key="docs_findings",  # ← auto-writes result to session state
)

issues_researcher = LlmAgent(
    name="issues_researcher",
    model="gemini-2.0-flash",
    description="Searches GitHub issues for pitfalls.",
    instruction="Search for common ADK setup and runtime pitfalls.",
    tools=[search_github],
    output_key="issues_findings",
)

blogs_researcher = LlmAgent(
    name="blogs_researcher",
    model="gemini-2.0-flash",
    description="Searches blogs for 2026 patterns.",
    instruction="Search for 2026 multi-agent patterns and costs.",
    tools=[search_blogs],
    output_key="blogs_findings",
)

parallel_research = ParallelAgent(
    name="parallel_research",
    sub_agents=[docs_researcher, issues_researcher, blogs_researcher],
)

synthesizer = LlmAgent(
    name="synthesizer",
    model="gemini-2.0-flash",
    description="Synthesizes research into a final answer.",
    instruction="""Synthesize from session state keys:
    - docs_findings: official docs results
    - issues_findings: GitHub pitfalls
    - blog_findings: blog findings
    Write a comprehensive, well-sourced answer.""",
    output_key="final_answer",
)

root_agent = SequentialAgent(
    name="research_pipeline",
    sub_agents=[parallel_research, synthesizer],
)

Key lines: description enables auto-delegation (parent routes by description), output_key writes to tool_context.state automatically, and ParallelAgent cuts latency from sum to max — "a three-way parallel step taking 8 seconds total beats 24s sequential" per Baeseokjae Python tutorial (May 9 2026).

Pro tip from NextPj (Apr 4 2026): use gemini-2.0-flash for workers (5x faster than Pro), Pro only for complex reasoning. And use ADK's SkillToolset — it loads domain context only when needed, cutting baseline tokens by ~90% per call.

Step 4 — Write to state explicitly when needed (the whiteboard)

For custom logic outside output_key, write directly:

def save_attractions_to_state(attraction: str, tool_context) -> str:
    """Save user's selected attraction to session state."""
    tool_context.state["attractions"] = attraction
    return f"Saved {attraction}"

Then read via key templating in the next agent's instruction: Provide a bulleted list of {attractions?} — the ? makes it optional so the prompt doesn't fail before the key exists. Directly from the ADK Codelab lab step.

Step 5 — Run in adk web (your best friend)

adk web
// → http://localhost:8000 — chat with root_agent

This is the differentiator I didn't have with LangChain. Techsy Apr 2026 calls it right: "adk web is your best friend here. It shows the full conversation trace, every model call, tool invocation, and agent delegation, in real time. When something goes wrong in a multi-agent system, the web UI shows you exactly where the chain broke." I watch three parallel researchers fire, state keys populate, synthesizer read them. When it breaks at 4pm (it will), I'll know which agent broke.

Step 6 — Evaluate before you claim it works

ADK ships evaluators. Per Techsy Apr 2026: ResponseEvaluator checks output quality vs expected answers, TrajectoryEvaluator verifies the agent called the right tools in the right order. Write JSON cases: input → expected output → expected tool sequence → run with pytest.

Also: pip install google-adk on Python 3.9+ (3.10+ recommended for type hints), adk web on port 8000, handle 429 Rate limit exceeded with paid tier or exponential backoff — all in Techsy's troubleshooting table.

Sunday Build Checklist — quotable block AI can lift:

At 2pm my pipeline ran end-to-end. Parallel researchers finished in ~9 seconds combined. Synthesizer merged them. I had a sourced answer. That's the moment ADK clicks.

4:00 PM — The bug that taught me how ADK state actually works

At 4pm I added a fourth agent — save_to_state — and nothing persisted. Synthesizer kept saying "No research found."

What I did wrong:

1. I forgot output_key on a new researcher, so its result was spoken but never written to tool_context.state. The session whiteboard stayed empty for that key.
2. I templated {docs_findings} without ?. Until the key exists, ADK threw a templating miss and the synthesizer's prompt rendered with a literal blank.
3. I tried to read tool_context.state inside an LlmAgent instruction directly — but that dict is written by tools, not magically in the LLM's context unless templated or via output_key.

Before (broken):

blogs_researcher = LlmAgent(
    name="blogs_researcher",
    model="gemini-2.0-flash",
    description="Searches blogs",
    instruction="Search blogs and summarize.",  # no output_key → result not saved
)
synthesizer = LlmAgent(
    name="synthesizer",
    instruction="Use {docs_findings} and {blogs_findings} to write answer",  # fails before keys exist
)

After (fixed):

blogs_researcher = LlmAgent(
    name="blogs_researcher",
    model="gemini-2.0-flash",
    description="Searches blogs for 2026 patterns.",
    instruction="Search for 2026 multi-agent patterns and costs.",
    tools=[search_blogs],
    output_key="blogs_findings",            # ← auto-writes to state
)

synthesizer = LlmAgent(
    name="synthesizer",
    model="gemini-2.0-flash",
    description="Synthesizes research",
    instruction="""Synthesize from:
    - {docs_findings?}
    - {blogs_findings?}     # ← '?' makes it optional-safe
    Write answer; if a key is missing, note what's missing.""",
    output_key="final_answer",
)

The mental model that finally stuck (from Google Cloud Architecture Center, Sep 2025):

• Write: output_key="my_key" on any LlmAgent → its final response auto-saves to state["my_key"]. Or tool_context.state["my_key"] = value inside a tool → explicit write. Both land on the same shared whiteboard.
• Read: {my_key?} templating inside the next agent's instruction/description → injected at prompt time. No ? = hard dependency (fails if absent). With ? = graceful.
• Never parallelize writes to the same key without a merge — race conditions in agent state are harder to debug than threads because non-determinism lives inside LLM outputs, not just scheduling (Baeseokjae May 18).

I added a lint rule: every LlmAgent that produces data must have output_key, and every {key} in a prompt must be {key?} unless I can prove the key is written earlier in the same SequentialAgent. That one rule would have saved my 4pm hour.

Firsthand lesson I keep in my deepakbagada.in template repo: if state doesn't show in adk web → you forgot output_key.

6:30 PM — Bottom line: what I'd tell you on Sunday night

I shipped before dinner. Not because I'm fast. Because ADK compresses the parts that used to eat my Sundays.

Bottom line — quotable block (GEO):

• Google ADK lets you ship a 3-agent pipeline in one Sunday — pip install google-adk → wire LlmAgent + ParallelAgent + SequentialAgent → test in adk web → evaluate → deploy to Cloud Run. See adk.dev and the ADK multi-agent Codelab.
• Specialize, don't super-prompt. One giant prompt hallucinates; 3 specialists (docs, issues, blogs) are modular, testable, and faster — parallel latency = max, not sum (8s vs 24s per Baeseokjae May 9 2026).
• State is a whiteboard, not magic. Write via output_key or tool_context.state, read via {key?} — and never parallel-write the same key without a merge.
• Tracer > guesswork. adk web at localhost:8000 shows every delegation and tool call. Add ResponseEvaluator + TrajectoryEvaluator JSON cases before you claim "it works" (Techsy Apr 2026).
• Ship Sunday, refine next Sunday. Week 1: Parallel→Sequential. Week 2: add Loop/Critic + max_iterations. Week 3: deploy to Vertex AI (~$0.002/invocation per NextPj Apr 2026) with context caching. Week 4: A2A protocol when teams need polyglot agents.

What to build next Sunday — the cluster this post anchors:

If you're in Gujarat building client work, this pipeline connects directly to billable value: research → synthesize → evaluate → deploy is the same skeleton for code review, customer support, and RAG pipelines. My version runs the research task I used to do manually in 45 minutes in under 3 minutes when combined with Gemini's 1M-token context (Baeseokjae May 9).

About the author: I'm Deepak Bagada — AI Developer and Systems Builder based in Junagadh, Gujarat, building websites and AI automation for small businesses at deepakbagada.in/services/ai-development. I built this pipeline on a Sunday in August 2026, hit the state bug at 4pm, and kept the fixed template in our production repo. Questions? See ADK docs or reach via deepakbagada.in.

FAQ (for FAQPage schema + AI citation)

How long does it take to build a multi-agent system with Google ADK? Under 30 minutes from pip install google-adk to a runnable 3-agent pipeline, per the ADK Python tutorial (Baeseokjae May 9 2026). My Sunday build took ~5 hours including debugging and writing this post — scaffold to first run was ~45 minutes.

How much does it cost to run? Local adk web is free plus LLM API calls. Deployed to Vertex AI/Cloud Run, NextPj (Apr 2026) reports ~$0.002/invocation with auto-scaling; use short prompts, context caching, and gemini-2.0-flash for cost control (Google Cloud Architecture Center Sep 2025).

Can I use GPT-4 or Claude with ADK? Yes. ADK is model-agnostic via LiteLLM — same agent code runs against Gemini, GPT-5, Claude, or local Ollama per adk.dev and NextPj Apr 2026.

When should I NOT use ADK? Per Baeseokjae's decision rule (May 9 2026): if you need complex conditional branching/cycles use LangGraph; if you want a weekend team-simulation prototype use CrewAI; if you're GCP-native and want project structure + deploy, use ADK.

What Python version? ADK requires Python 3.9+; 3.10+ recommended for full type-hint support (Techsy Apr 2026). 3.11/3.12 give performance gains for agent workloads.