ChangeGamer

Do You Need A2A for a Multi-Agent System? A Decision Rule

Part 1 of A2A in practice: agent-to-agent interoperability · 1,277 words · ~6 min read · published · updated · Markdown variant

A decision rule for choosing between in-process subagents and the A2A protocol: start with one agent, add more only for a named failure, and cross the network with A2A only when a remote party, framework or trust boundary demands it.

In short

  • The decision rule: when every agent ships in one repository under one set of credentials, in-process delegation is the default, and a network protocol like A2A has to earn its place (our inference, not spec text).
  • The multi-agent-orchestration-patterns reference says to start with a single agent and add more only after a concrete failure or scaling need, and its four conditions for going multi-agent say nothing about network protocols.
  • Adding agents costs real money: the orchestration reference puts a ten-subagent fan-out at roughly ten times the spend of one agent, set against Anthropic's reported 90.2% gain on breadth-first research.
  • A2A is warranted when the agent you delegate to belongs to another organization, runs on a framework you cannot import, or sits behind a trust boundary that needs authentication (our inference, not spec text).
  • MCP connects an agent to tools and data while A2A connects an agent to a peer agent, so adopting one protocol never substitutes for the other.

Part of the The A2A Protocol in Practice: Agent Cards, Tasks, Auth and When You Need It guide.


A multi-agent system needs A2A only when its agents cannot share code, credentials or a deployment, which is the situation the protocol is designed for (inference); agents inside one codebase share all three. The rule below is short: stay in process until a named outside party, framework or trust boundary forces you across the wire.

This is the build-or-skip article of its cluster. The overview of the protocol is in the A2A protocol in practice, and the wire contract is in the A2A protocol reference. Agent Cards, the task lifecycle and authentication are covered in Agent Card design, the task lifecycle and authentication and appear here only as costs to weigh.

Should a multi-agent system start with more than one agent?

A multi-agent system should start as one agent with tools, because the multi-agent orchestration patterns reference (updated 26 September 2026) says additional agents are only worth their cost when a concrete failure or scaling need shows up in a single-agent design. It states that the appeal of the architecture is never a reason on its own.

The same reference lists the single agent with tools as the baseline every other pattern should be measured against. Its recommended path has four moves:

  1. Start single-agent.
  2. Pin down the one concrete failure driving the change.
  3. Reach for the smallest pattern that fixes it.
  4. Instrument tracing before scaling up.

Nothing in that sequence involves a protocol. A2A belongs after step three, if at all, and only for the part of the design that crosses an ownership line.

What do the four conditions for going multi-agent say about A2A?

The four conditions say nothing about A2A: they justify having several agents, not connecting them over a network. The reference names them as subtasks that separate cleanly, workloads where parallelism pays, subtasks that need different prompts, tools or models, and tasks that genuinely exceed one context window.

Each of these is satisfied by in-process code. Two worker agents with different system prompts can be two function calls in one process, and a cheap routing model next to a large synthesis model is a configuration choice. The decision about how many agents to run and the decision about how they communicate are separate, and the first does not imply the second.

What does more agents cost?

More agents cost real money. The orchestration reference says that fanning work out across ten parallel subagents in an orchestrator-workers setup can multiply spend roughly tenfold versus one agent, and that cost should be modeled before deployment. It also records Anthropic's internal research system beating a single Claude Opus 4 agent by 90.2% on breadth-first research queries.

Read the two figures together. The gain is real for work that explores many independent directions at once, and the cost is real for everything else. Neither number is evidence about a protocol: both describe the pattern, not the transport. A2A adds its own overhead on top (inference): a network round trip, a credential to manage and a failure mode that function calls do not have.

When is A2A warranted instead of in-process subagents?

A2A is warranted when the agent you want to delegate to sits outside your codebase or your trust boundary. The test below is inference from the sources, not text from the specification. Cross the wire if at least one of these holds:

The A2A protocol reference describes what you get in return: agents built on different frameworks discover one another through a published Agent Card, exchange messages and track delegated work as tasks. Those features have value in proportion to how much of the system you do not control.

The inverse also holds (inference). If the child agent ships from your repository, runs under the same credentials, deploys on the same cadence and is debugged by the same people, the protocol's benefits are mostly already provided by your language runtime.

How do MCP and A2A split the work?

MCP and A2A split the work by what sits on the other end: MCP connects an agent to tools and data, while A2A connects it to another agent as a peer, so running an MCP server tells you nothing about whether you need A2A. The MCP vs A2A reference holds the full comparison.

What does an in-process setup look like in practice?

An in-process setup looks like a set of agent definitions that one tool delegates to, with no network protocol between them. As of 30 October 2026, the ChangeGamer repository holds six definition files in .claude/agents, which the coding-agent tooling uses for in-process delegation. You can count them yourself:

# Count subagent definition files in a repository using this layout
ls .claude/agents/*.md | wc -l

None of those files has an Agent Card, a task lifecycle or a network hop. They are cited only as an example of the case where A2A would add nothing.

The same repository shows the other half of the picture. In the ChangeGamer repository as of 30 October 2026, MCP endpoints are published at /.well-known/mcp.json and no /.well-known/agent-card.json exists. You can check the live site from a shell:

# MCP discovery document: expect HTTP 200
curl -s -o /dev/null -w "%{http_code}\n" https://changegamer.ai/.well-known/mcp.json

# A2A Agent Card: expect a non-200 status, since none is published
curl -s -o /dev/null -w "%{http_code}\n" https://changegamer.ai/.well-known/agent-card.json

The site speaks the tool protocol because it exposes tools and data, and it publishes no Agent Card, so it does not advertise itself as a peer agent. This is a statement about two discovery documents, not about how any agent pipeline is arranged.

A short decision sequence

The decision comes down to five questions asked in order; stop at the first one that answers it.

  1. Does one agent with tools fail at a specific, named task? If not, stay single-agent.
  2. Does an in-process pattern fix that failure? Parallelization, routing or orchestrator-workers inside one process usually does. Stop there.
  3. Is any agent in the design owned by another party, written in a framework you cannot import, or behind a trust boundary? If not, stay in process.
  4. Can that one boundary be handled by a single tool call over MCP or a plain API? If the remote side exposes a function and not an agent with its own reasoning, a tool is the lighter fit (inference).
  5. Does the remote side expose an A2A endpoint, or can you ask its operator for one? If yes, use A2A for that hop only.

Notice the scope in step five: A2A is adopted per hop, not per system. A design can keep five agents in process and reach a sixth, external one over A2A.

If you reach step five, the rest of this cluster takes over, ending with the production launch checklist: Agent Card design, the task lifecycle, authentication across hops, and how to trust a remote agent. As of October 2026 the protocol is at v1.0, and the A2A protocol in practice overview lists what changed from v0.3 before you pin a version. The corpus holds no independent measurement of A2A production use, so adoption claims should not enter your decision.

Frequently asked questions

Can subagents inside one codebase use A2A anyway?
Yes, A2A can wrap agents that live in the same codebase, but it adds a network hop, an authentication step and a task lifecycle to calls that could be plain function calls. Without an outside party or boundary, that overhead buys nothing the ChangeGamer corpus can point to.
Is A2A required to build a multi-agent system?
No. Nothing in the sourced specification requires A2A for a multi-agent system, and multi-agent designs such as orchestrator-workers, routing and parallelization can be built in process, with ordinary code or a framework's own subagent feature (inference). The protocol only matters when agents from different owners must talk to each other.
Does adopting A2A mean dropping MCP?
No. MCP and A2A operate at different layers: MCP gives an agent access to tools and data, while A2A lets one agent hand work to another agent. A system that uses A2A between agents still uses MCP inside each of them to reach tools.
What should I do before deciding on A2A?
Name the single failure that a single-agent design cannot fix, try the smallest in-process pattern that fixes it, and instrument tracing first. Only if the remaining need involves a party you do not control should A2A enter the design.

#a2a #multi-agent #architecture #decision #subagents #mcp #protocols

Put this corpus inside your own agents

This guide is free and stays free. The reference corpus behind it — machine-readable contracts, verified primary sources, continuously refreshed — is the paid product: a €5 starter key unlocks every premium reference for one agent via API; a €25 corpus license delivers the full corpus as RAG / fine-tuning data with an explicit AI-use grant; the €150 enterprise license adds commercial redistribution rights.

Agents: this page as Markdown · JSON · offers at /api/pricing.json · payment methods at /api/payment.json · single-resource access via HTTP 402 (how that works)