Multi-Agent Systems & A2A
When one agent's context, tools, or focus aren't enough, the instinct is to split the work across several specialized agents. Sometimes this is exactly right; often it is a costly mistake that multiplies tokens, latency, and failure modes while adding little. This chapter covers the topologies that work, the protocol that lets agents from different vendors interoperate, and — just as important — when not to go multi-agent.
12.1 Topologies of collaboration
Multi-agent designs differ in how control and information flow between agents. The dominant pattern is orchestrator–worker: a lead agent decomposes a task and delegates subtasks to specialized workers, then synthesizes their results — a direct application of the fan-out/fan-in primitive from Chapter 4. Hierarchical designs nest this across several layers for complex domains. Blackboard (shared-state) designs let agents collaborate by reading and writing a common workspace rather than messaging directly. Sequential pipelines pass work agent-to-agent in stages.
12.2 The discipline of not going multi-agent
Each additional agent consumes its own context and token budget, adds a coordination and failure surface, and makes the system harder to evaluate and debug. Published experience (including Anthropic's own multi-agent research) is consistent: multi-agent systems can dramatically outperform single agents on complex, parallelizable, breadth-first tasks — and they burn many times the tokens to do it. They are a poor fit for tightly coupled tasks where subagents need each other's intermediate results, or for anything a well-engineered single agent with good tools and context already handles.
Reaching for a crowd of agents to solve a problem one good agent could handle multiplies cost (Ch. 2's N× multiplier), latency, and non-determinism for no benefit. Start with the simplest thing that works: a single agent with well-designed tools. Add agents only when the task is genuinely parallel or demands separated contexts/permissions — and measure that the gain justifies the spend.
Every agent you add should earn its tokens. Multi-agent is justified when work is parallelizable, when subtasks need isolated context windows or distinct trust boundaries, or when specialization measurably improves quality — not because the architecture looks sophisticated.
12.3 Agent-to-Agent interoperability (A2A)
MCP (Ch. 8) connects an agent to tools; it does not standardize how two agents — possibly built by different teams or vendors, each opaque to the other — collaborate. The A2A protocol (originated at Google, now under the Linux Foundation) fills that gap. Each agent publishes an Agent Card advertising its identity, skills, and endpoint; other agents discover it and exchange tasks and results over a defined HTTP-based protocol, supporting long-running tasks and streaming. The mental model: MCP is how an agent uses a tool; A2A is how an agent delegates to a peer. A mature platform speaks both — MCP downward to capabilities, A2A outward to other agents.
| MCP | A2A | |
|---|---|---|
| Connects | Agent ↔ tools/data/resources | Agent ↔ agent (peer collaboration) |
| Counterparty | A capability server you invoke | Another autonomous agent, possibly third-party |
| Discovery | Server capability listing | Agent Card (skills, endpoint, auth) |
| Interaction | Call tool, read resource | Send task, stream updates, return result |
| Analogy | Using a tool | Delegating to a colleague |