# From Skills to Systems: 5 Multi-Agent Orchestration Patterns in ADK 2.0
**作者**: Google Cloud Tech
**日期**: 2026-04-23T17:28:36.000Z
**来源**: [https://x.com/GoogleCloudTech/status/2047367046070161674](https://x.com/GoogleCloudTech/status/2047367046070161674)
---
A few weeks ago, our article on 5 Agent Skill design patterns went viral. The patterns (Tool Wrapper, Generator, Reviewer, Inversion, Pipeline) gave developers a structural vocabulary for designing agent skills. But a single skill, no matter how well-designed, only solves part of the problem.
The harder question is: how do you orchestrate multiple skills across multiple agents in a production system? How do you ensure that Agent A's output is the right format for Agent B's input? How do you enforce that certain steps always happen in a certain order while still allowing AI flexibility within each step? How do you coordinate agents written in different languages by different teams?
At Google Cloud Next 26, we launched Agent Development Kit (ADK) 2.0 that answers these questions with three core additions: graph-based workflows, collaborative agents, and a formalized Skills framework. Here are five orchestration patterns that will take you to the next level of agent architecture.
By @addyosmani and @Saboo_Shubham_
## Pattern 1: The Hybrid Graph
The most common production failure in agent systems is an orchestration failure. The agent reasons correctly about each individual step but executes them in the wrong order, skips a mandatory step, or takes a path that no human reviewer anticipated.
This happens because most agent architectures encode workflow logic inside system prompts. The LLM follows the instructions faithfully for the first few turns. By turn seven, it starts taking shortcuts. By turn twelve, it's skipping steps entirely. This is a fundamental limitation of using natural language instructions to define procedural workflows. LLMs are optimizers. They're trained to produce helpful outputs efficiently. When the model looks at a five-step workflow, it often decides it can produce a more helpful response by combining steps or reordering them.
ADK 2.0's graph-based workflows solve this structurally. You define agent logic as a directed graph where nodes are actions and edges are transitions with conditional logic. The critical innovation is that you can mix deterministic nodes (hard-coded business rules) with AI-driven nodes (LLM reasoning) in the same graph.
Here's a concrete example: a loan application processing agent. Some steps must be deterministic (regulatory compliance checks, credit score thresholds, documentation requirements). Other steps benefit from AI flexibility (assessing document quality, summarizing financial profiles, generating recommendations).
The key difference from prompt-based orchestration: the mandatory structure is enforced by the framework. The LLM has flexibility within each node but cannot skip nodes or reorder the graph. The deterministic nodes are unit-testable with standard testing frameworks. The AI-driven nodes can be evaluated separately using Agent Simulation. And the graph structure itself is inspectable, so a compliance officer can review the workflow and verify that every required step is included and properly ordered without reading any LLM prompts.
## Pattern 2: The Coordinator-Specialist
The "God agent" is the most common anti-pattern in production agent systems. One agent tries to do everything: customer support, data analysis, document generation, API integration. Its system prompt is thousands of tokens long, its tool set is enormous, and its behavior is unpredictable because the LLM is constantly deciding between dozens of possible actions.
The problem gets worse as you add capabilities. Around the fifth major addition, the system becomes unreliable. The agent uses the wrong tool for the task. It applies the customer support tone when doing data analysis. It follows financial compliance rules when answering a simple question about project timelines. The instructions compete for the model's attention, and the model starts making tradeoffs you didn't anticipate.
ADK 2.0's collaborative agents provide native support for the coordinator-specialist pattern. A coordinator agent handles task routing and workflow management. Specialist agents handle domain-specific work with focused context and tools.
The transfer protocol defines how context flows between agents during handoffs. 𝚃𝚛𝚊𝚗𝚜𝚏𝚎𝚛𝙿𝚛𝚘𝚝𝚘𝚌𝚘𝚕.𝙲𝙾𝙽𝚃𝙴𝚇𝚃𝚄𝙰𝙻 means the coordinator includes relevant context from the previous specialist's output when transferring to the next specialist. The document writer does not need to re-query the database - it receives the data analyst's output as context.
Each specialist has its own identity (via Agent Identity), its own tool permissions (governed by Agent Gateway), and its own memory context. The data analyst cannot access CRM data. The customer expert cannot run SQL queries. The blast radius of any single agent's malfunction is contained to its domain.
This pattern also simplifies testing and iteration. When the data analyst's output quality degrades, you evaluate and fix that one specialist. You don’t need to retrain or re-prompt a monolithic agent. When you add a new capability (say, a competitive intelligence specialist), you register it with the coordinator and it is available immediately.
## Pattern 3: Skill Composition
In our previous article, we covered five skill design patterns: Tool Wrapper, Generator, Reviewer, Inversion, and Pipeline. ADK 2.0 formalizes these with a declarative Skills framework that makes skills first-class citizens in multi-agent workflows.
The key addition is 𝚂𝚔𝚒𝚕𝚕𝚃𝚘𝚘𝚕𝚜𝚎𝚝, which lets agents load and use skills as tools. An agent does not need to know the internal implementation of a skill. It knows the skill's name, its description, and its interface. This enables composition - chaining skills together across agents in ways the original skill authors did not anticipate.
Here’s how this works in practice. Imagine you have three existing skills built by three different teams:
A coordinator agent can compose these skills into a workflow that none of them was individually designed for:
Thanks to progressive disclosure, the agent only loads a skill's full context when it actually invokes that skill. If a user asks a simple question that does not require trend analysis, the trend-analyzer skill's instructions, references, and assets are never loaded into the context window. This keeps context token usage efficient even when an agent has access to dozens of skills.
This is the same insight that made npm, pip, and Maven successful: small, focused, composable packages with clear interfaces are more valuable than large, monolithic libraries. Individual teams build skills for their domain (data engineering builds extraction skills, analytics builds analysis skills, communications builds formatting skills). A coordinator agent assembled by the platform team can compose these into workflows that cross organizational boundaries without any of those teams needing to coordinate directly.
## Pattern 4: The Cross-Language Pipeline
ADK is now available in four different languages: Python, TypeScript, Go, and Java. Each SDK has native support for the A2A (Agent-to-Agent) protocol. This means an agent written in Python can seamlessly delegate to an agent written in Go, which can delegate to an agent written in Java.
This matters in organizations where different teams use different languages. The ML team writes Python. The platform team writes Go. The enterprise integration team writes Java. The frontend team writes TypeScript. Previously, building a multi-agent workflow across these teams required custom API integrations, protocol negotiation, and data format translation. A2A standardizes all of that.
Here's what a cross-language pipeline looks like in practice:
Each agent publishes its capabilities via an Agent Card at /.𝚠𝚎𝚕𝚕-𝚔𝚗𝚘𝚠𝚗/𝚊𝚐𝚎𝚗𝚝-𝚌𝚊𝚛𝚍.𝚓𝚜𝚘𝚗. Other agents discover these capabilities automatically. The A2A protocol handles task management, status updates, and result streaming. From each agent's perspective, delegating to a remote agent in a different language feels like calling a local function.
Each SDK also brings language-specific strengths to the pipeline. ADK Go 1.0 added OpenTelemetry integration for distributed tracing across multi-agent pipelines, self-healing logic via plugins, and YAML-based agent definitions that let you manage agents declaratively (the same way you manage Kubernetes manifests or Terraform resources). The Java SDK adds event compaction for managing long conversation histories and ToolConfirmation for human-approval workflows that are critical for enterprise governance.
## Pattern 5: The Sandboxed Executor
The final pattern addresses a common requirement: agents that need to execute code as part of their workflow. A data analysis agent needs to run pandas operations. A code review agent needs to execute tests. A document processing agent needs to run transformation scripts.
Running arbitrary code inside an agent is a security risk if the execution environment isn't isolated. ADK 2.0 provides secure workspaces: hardened, sandboxed environments where agents can run bash commands, manage files, and execute code, all isolated from your core systems.
Here’s the code implementation in Python:
The sandbox boundary is the critical security property. The agent can run arbitrary Python code within its workspace, but that code cannot access the host filesystem, cannot make network connections to unapproved domains, and cannot escalate privileges. If the agent's code execution goes haywire - an infinite loop, excessive memory allocation, an attempt to access restricted resources - the sandbox enforces hard limits.
This pattern is particularly powerful combined with the Pipeline skill pattern from our previous article. A documentation pipeline skill that needs to parse source code, generate docstrings, and assemble a final document can execute each step in the sandbox, using actual code execution rather than LLM reasoning for the parsing step. The result is more reliable - parsing Python ASTs with actual Python is more accurate than asking an LLM to reason about code structure.
## Choosing the right orchestration pattern
These patterns compose, just like the skill patterns from our previous article:
- A Hybrid Graph can use Coordinator-Specialist at individual nodes - the graph defines the overall workflow, and specialist agents handle domain-specific nodes
- A Coordinator-Specialist setup can use Skill Composition within each specialist - each specialist loads only the skills relevant to its domain
- A Cross-Language Pipeline can use Sandboxed Executors at any stage - the Python agent runs ML models in a sandbox, the Go agent runs compliance checks with sandboxed test data
- Any pattern can incorporate the five skill patterns (Tool Wrapper, Generator, Reviewer, Inversion, Pipeline) from our previous article at the individual skill level
## Getting Started
ADK 2.0 is available now. Install with pip install google-adk --pre (Python 3.11+). Your existing ADK 1.x agents are backward compatible, though advanced implementations may need migration testing.
The ADK samples repository (github.com/google/adk-samples) includes 30+ sample agents across Python, TypeScript, Go, and Java, covering patterns from simple tool wrappers to complex multi-agent workflows.
Documentation: adk.dev
GitHub Repos: ADK Python | ADK Java | ADK Go | ADK TypeScript
## 🚢 From Agent Skills to Systems: Google for Startups AI Agents Challenge
Move beyond the demos by joining our 6-week global challenge for startups to build, optimize, or refactor autonomous agents on the Gemini Enterprise Agent Platform.
You'll get $500 in cloud credits, full platform access, and a shot at the $90,000 prize pool. Put these ADK 2.0 orchestration patterns into practice and build production-ready agent systems.
Sign up today to start building!
## 相关链接
- [Google Cloud Tech](https://x.com/GoogleCloudTech)
- [@GoogleCloudTech](https://x.com/GoogleCloudTech)
- [55K](https://x.com/GoogleCloudTech/status/2047367046070161674/analytics)
- [5 Agent Skill design patterns](https://x.com/GoogleCloudTech/status/2033953579824758855?s=20)
- [@addyosmani](https://x.com/@addyosmani)
- [@Saboo_Shubham_](https://x.com/@Saboo_Shubham_)
- [github.com/google/adk-samples](https://github.com/google/adk-samples)
- [adk.dev](https://adk.dev/)
- [ADK Python](https://github.com/google/adk-python)
- [ADK Java](https://github.com/google/adk-java)
- [ADK Go](https://github.com/google/adk-go)
- [ADK TypeScript](https://github.com/google/adk-js)
- [Sign up today to start building](https://devpost.team/hackathon_guest_invites/4fb181b4-2722-415d-a442-285a57dcaba5?utm_source=twitter&utm_medium=social&utm_campaign=google-for-startups-ai-agents-challenge&utm_content=twitter-post)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [1:28 AM · Apr 24, 2026](https://x.com/GoogleCloudTech/status/2047367046070161674)
- [55K Views](https://x.com/GoogleCloudTech/status/2047367046070161674/analytics)
- [View quotes](https://x.com/GoogleCloudTech/status/2047367046070161674/quotes)
---
*导出时间: 2026/4/24 23:10:59*