Google ADK's eight multi-agent patterns in 2026 reduce to four you use every Sunday — Sequential Pipeline, Parallel Fan-Out, Loop/Critic and Hierarchical Coordinator — plus four for production scale. From Junagadh I rebuilt one giant prompt into five specialists: Parallel research cut 24 seconds sequential to 8 seconds, state whiteboard via output_key and {key?} made it reliable, and a Loop critic lifted quality from 6 to 9. Here is each pattern's code, when to use it, and the bug that taught me state.
Per the Google Developers Blog December 16 2025 "Developer's guide to multi-agent patterns in ADK," a single agent with too many responsibilities becomes a "Jack of all trades, master of none" — instruction adherence degrades and hallucinations compound. Reliability comes from decentralization and specialization. I run AI Development & Autonomous Agents from Junagadh where that lesson is billable — a client research task that took 45 minutes manually now runs in under three minutes via ADK when patterns are correct. The blog lists eight patterns; InfoQ January 5 2026 syndicated them with pseudocode, and the July 22 2026 Codelabs lab turned them into runnable agents.
The Four You Need on Day One
1. Sequential Pipeline — The Assembly Line
researcher → synthesizer → file_writer // SequentialAgent(sub_agents=[r,s,f])
Linear, deterministic, easiest to debug because you always know where data came from. Use when steps must happen in order and each feeds the next. In ADK: SequentialAgent(sub_agents=[docs_researcher, synthesizer]) where each LlmAgent sets output_key="docs_findings" to write to session state. My Sunday pipeline uses Parallel inside Sequential — researchers in Parallel, then synthesizer sequentially. For Business Workflow Automation pipelines, sequential is the default skeleton for invoice ingestion → validation → posting.
2. Parallel Fan-Out/Gather — The Octopus
[ParallelAgent] docs, issues, blogs → synthesizer gathers
Run independent subtasks simultaneously, gather in one agent. Baeseokjae May 9 2026 measured a three-way parallel step at 8 seconds total versus 24 seconds sequential on the same model. ADK requires each Parallel sub-agent writes to a unique key to avoid race conditions — they share tool_context.state but in separate threads. I wire:
parallel_research = ParallelAgent(sub_agents=[docs_researcher, issues_researcher, blogs_researcher])
root = SequentialAgent(sub_agents=[parallel_research, synthesizer])
Latency math alone justifies this pattern for Gujarat SMEs where API budget is tight. See featured projects for how we parallelize GST checks.
3. Loop/Critic — The Editor's Desk
One agent generates, one critiques, loop until threshold. Use when output quality must be gated. ADK: LoopAgent with max_iterations and exit_loop tool. My writer's room from the Codelabs lab loops researcher → screenwriter → critic until critic score ≥8. In production we log every loop exit reason to prevent infinite refinement — the harness brake at 40 round-trips matters.
4. Hierarchical/Coordinator — The Concierge
Parent delegates by description. Coordinator receives request and dispatches to a specialized agent. ADK's AutoFlow uses descriptions to transfer execution. Example: ReportWriter parent with sub_agents=[research_assistant, writer] where AgentTool(research_assistant) hides the team behind one tool. This is how a customer support bot routes technical vs billing queries without custom router code. For teams exploring get in touch automation, hierarchical is the pattern that scales to org structures.
The Four You Save for Production
Generator-Critic (Iterative Refinement). Generalization of loop where critic and refiner work together to iteratively improve output. Use for drafts that need polish, not just pass/fail.
Router/Dispatcher Variants. When Coordinator chooses among many children based on intent. Keep deterministic — LLM-driven routing without schema costs tokens per decision, as LangGraph vs CrewAI benchmarks show.
Human-in-the-Loop. Approval tool pauses execution for irreversible actions — financial transactions, prod deploys, sensitive data actions. Composite pattern example: Coordinator routes technical issue → Parallel searches docs/history → Generator/Critic ensures tone → HITL before send. We enforce this for any tool with invoices:write scope.
Composite / Marketplace/A2A. Rarely one pattern alone. A robust support system combines Coordinator → Parallel → Generator-Critic. A2A marketplace pattern lets a Python ADK agent call a Go compliance agent via RemoteA2aAgent over Agent Card and JSON-RPC 2.0, as the June 22 2026 Google Developers Blog contract compliance pipeline demonstrated. That cross-language team survived a simulated Go crash by routing to manual review — the fail-safe pattern essential for production.
State Is a Whiteboard, Not Magic — The 4pm Bug
At 4pm I added a blogs researcher without output_key and templated {docs_findings} without ?. Synthesizer said "No research found." Fix:
# Before (broken): no output_key, hard dependency
blogs_researcher = LlmAgent(name="blogs_researcher", instruction="Search blogs")
synthesizer = LlmAgent(instruction="Use {docs_findings} and {blogs_findings}")
# After (fixed): write to state, optional read
blogs_researcher = LlmAgent(..., output_key="blogs_findings")
synthesizer = LlmAgent(instruction="Synthesize from {docs_findings?} and {blogs_findings?}")
Mental model from Google Cloud Architecture Center September 2025: Write via output_key="my_key" or tool_context.state["my_key"]=value; read via {my_key?} with ? making it optional. Never parallel-write the same key without a merge. Every LlmAgent that produces data must have output_key. That lint rule saved my Sunday.
For the full Sunday build timeline — pip install google-adk to adk web to eval — see my automation journal hub. The six-step checklist runs in adk web at localhost:8000 before any deploy. In Junagadh summers we keep one 1.5-ton split AC per rack so the 4090 workstation for local eval stays at 25C — thermals matter for sustained Parallel runs and state tracing during long HITL sessions.
Bottom Line: In 2026 ADK ships with eight patterns but you live on four — Sequential for order, Parallel for speed (8s vs 24s), Loop/Critic for quality, Hierarchical for routing — wired via
output_keyand{key?}on a shared state whiteboard, composed when use cases demand audit and resilience.
Frequently Asked Questions
What are the eight Google ADK multi-agent patterns?
Sequential Pipeline, Coordinator/Dispatcher, Parallel Fan-Out/Gather, Hierarchical Decomposition, Generator and Critic, Iterative Refinement, Human-in-the-Loop, and Composite patterns per Google Developers Blog Dec 16 2025. In practice consolidate to four daily drivers — Sequential, Parallel, Loop/Critic, Hierarchical — plus four production composites including A2A marketplace.
How does ADK handle state between agents?
All agents share tool_context.state dict in a Session. Write via output_key="my_key" on any LlmAgent or tool_context.state["my_key"]=value in a tool; read via {my_key?} key templating in the next agent's instruction. The ? makes it optional so missing keys do not crash the prompt. Parallel agents must write to unique keys to avoid races.
When should I use Parallel versus Sequential in ADK?
Use Sequential when steps depend on prior output (research → synthesize → save). Use Parallel when subtasks are independent and can gather later — three researchers in parallel cut latency from sum to max (8s vs 24s per Baeseokjae May 9 2026). Never parallel-write the same key without a merge step.
How does Deepak implement these patterns for Gujarat clients?
From Junagadh I start every client pipeline as Parallel→Sequential — three specialist researchers with output_key, one synthesizer with {key?} — traced in adk web. Next Sunday I add Loop/Critic with max_iterations and exit_loop, then Hierarchical Coordinator and HITL for irreversible actions, all logged via OTel. Get in touch for the template repo.