{
  "slug": "do-you-need-a2a",
  "title": "Do You Need A2A for a Multi-Agent System? A Decision Rule",
  "description": "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.",
  "kind": "sub",
  "order": 1,
  "target_query": "do i need a2a for a multi-agent system",
  "secondary_queries": [],
  "tags": [
    "a2a",
    "multi-agent",
    "architecture",
    "decision",
    "subagents",
    "mcp",
    "protocols"
  ],
  "published": "2026-10-30",
  "updated": "2026-10-30",
  "words": 1277,
  "estimated_tokens": 1698,
  "premium": false,
  "rights": {
    "access": "free",
    "note": "Editorial guides are always free and never part of the licensed corpus.",
    "license": "https://changegamer.ai/license.xml",
    "pricing": "https://changegamer.ai/api/pricing.json",
    "payment": "https://changegamer.ai/api/payment.json"
  },
  "license": "https://changegamer.ai/license.xml",
  "citation": "ChangeGamer (2026-10-30). Do You Need A2A for a Multi-Agent System? A Decision Rule. ChangeGamer. https://changegamer.ai/articles/do-you-need-a2a (updated 2026-10-30).",
  "bibtex": "@misc{changegamer_do_you_need_a2a, title = {Do You Need A2A for a Multi-Agent System? A Decision Rule}, publisher = {ChangeGamer}, year = {2026}, url = {https://changegamer.ai/articles/do-you-need-a2a}, note = {Updated 2026-10-30}}",
  "canonical": "https://changegamer.ai/articles/do-you-need-a2a",
  "markdown": "https://changegamer.ai/articles/do-you-need-a2a.md",
  "takeaways": [
    "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."
  ],
  "outline": [
    {
      "depth": 2,
      "text": "Should a multi-agent system start with more than one agent?",
      "anchor": "should-a-multi-agent-system-start-with-more-than-one-agent",
      "url": "https://changegamer.ai/articles/do-you-need-a2a#should-a-multi-agent-system-start-with-more-than-one-agent"
    },
    {
      "depth": 2,
      "text": "What do the four conditions for going multi-agent say about A2A?",
      "anchor": "what-do-the-four-conditions-for-going-multi-agent-say-about-a2a",
      "url": "https://changegamer.ai/articles/do-you-need-a2a#what-do-the-four-conditions-for-going-multi-agent-say-about-a2a"
    },
    {
      "depth": 3,
      "text": "What does more agents cost?",
      "anchor": "what-does-more-agents-cost",
      "url": "https://changegamer.ai/articles/do-you-need-a2a#what-does-more-agents-cost"
    },
    {
      "depth": 2,
      "text": "When is A2A warranted instead of in-process subagents?",
      "anchor": "when-is-a2a-warranted-instead-of-in-process-subagents",
      "url": "https://changegamer.ai/articles/do-you-need-a2a#when-is-a2a-warranted-instead-of-in-process-subagents"
    },
    {
      "depth": 2,
      "text": "How do MCP and A2A split the work?",
      "anchor": "how-do-mcp-and-a2a-split-the-work",
      "url": "https://changegamer.ai/articles/do-you-need-a2a#how-do-mcp-and-a2a-split-the-work"
    },
    {
      "depth": 2,
      "text": "What does an in-process setup look like in practice?",
      "anchor": "what-does-an-in-process-setup-look-like-in-practice",
      "url": "https://changegamer.ai/articles/do-you-need-a2a#what-does-an-in-process-setup-look-like-in-practice"
    },
    {
      "depth": 2,
      "text": "A short decision sequence",
      "anchor": "a-short-decision-sequence",
      "url": "https://changegamer.ai/articles/do-you-need-a2a#a-short-decision-sequence"
    }
  ],
  "faq": [
    {
      "question": "Can subagents inside one codebase use A2A anyway?",
      "answer": "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."
    },
    {
      "question": "Is A2A required to build a multi-agent system?",
      "answer": "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."
    },
    {
      "question": "Does adopting A2A mean dropping MCP?",
      "answer": "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."
    },
    {
      "question": "What should I do before deciding on A2A?",
      "answer": "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."
    }
  ],
  "body": "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.\n\nThis is the build-or-skip article of its cluster. The overview of the protocol is in [the A2A protocol in practice](/articles/a2a-protocol-in-practice), and the wire contract is in the [A2A protocol reference](/resources/a2a-protocol). Agent Cards, the task lifecycle and authentication are covered in [Agent Card design](/articles/a2a-agent-card-design), the [task lifecycle](/articles/a2a-task-lifecycle) and [authentication](/articles/a2a-authentication-schemes) and appear here only as costs to weigh.\n\n## Should a multi-agent system start with more than one agent?\n\nA multi-agent system should start as one agent with tools, because the [multi-agent orchestration patterns](/resources/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.\n\nThe same reference lists the single agent with tools as the baseline every other pattern should be measured against. Its recommended path has four moves:\n\n1. Start single-agent.\n2. Pin down the one concrete failure driving the change.\n3. Reach for the smallest pattern that fixes it.\n4. Instrument tracing before scaling up.\n\nNothing 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.\n\n## What do the four conditions for going multi-agent say about A2A?\n\nThe 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.\n\nEach 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.\n\n### What does more agents cost?\n\nMore 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.\n\nRead 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.\n\n## When is A2A warranted instead of in-process subagents?\n\nA2A 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:\n\n- **Another party owns the agent.** A different team, company or vendor runs it, so you cannot import it and can only call it.\n- **A different framework or language runs it.** You need a shared contract, not a shared library.\n- **A trust boundary separates the two.** Policy requires the callee to authenticate the caller, with its own credentials and audit trail.\n- **The work outlives a call.** You need a protocol-level lifecycle for long-running, interruptible or cancellable tasks, not a blocking function.\n\nThe [A2A protocol reference](/resources/a2a-protocol) 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.\n\nThe 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.\n\n## How do MCP and A2A split the work?\n\nMCP 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](/resources/mcp-vs-a2a) holds the full comparison.\n\n## What does an in-process setup look like in practice?\n\nAn 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:\n\n```bash\n# Count subagent definition files in a repository using this layout\nls .claude/agents/*.md | wc -l\n```\n\nNone 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.\n\nThe 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:\n\n```bash\n# MCP discovery document: expect HTTP 200\ncurl -s -o /dev/null -w \"%{http_code}\\n\" https://changegamer.ai/.well-known/mcp.json\n\n# A2A Agent Card: expect a non-200 status, since none is published\ncurl -s -o /dev/null -w \"%{http_code}\\n\" https://changegamer.ai/.well-known/agent-card.json\n```\n\nThe 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.\n\n## A short decision sequence\n\nThe decision comes down to five questions asked in order; stop at the first one that answers it.\n\n1. **Does one agent with tools fail at a specific, named task?** If not, stay single-agent.\n2. **Does an in-process pattern fix that failure?** Parallelization, routing or orchestrator-workers inside one process usually does. Stop there.\n3. **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.\n4. **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).\n5. **Does the remote side expose an A2A endpoint, or can you ask its operator for one?** If yes, use A2A for that hop only.\n\nNotice 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.\n\nIf you reach step five, the rest of this cluster takes over, ending with the [production launch checklist](/articles/a2a-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](/articles/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.",
  "cluster": {
    "id": "a2a-in-practice",
    "title": "A2A in practice: agent-to-agent interoperability",
    "description": "How to build, secure and run agent-to-agent delegation with the A2A protocol — when A2A beats in-process subagents, Agent Cards, task lifecycle, bindings, authentication, credential propagation across hops, discovery and trust, v0.3 to v1.0 migration, framework support and failure handling — not MCP tool serving (mcp-in-practice) and not single-agent identity (agent-identity-and-authentication-for-ai-agents).",
    "status": "complete",
    "pillar": {
      "slug": "a2a-protocol-in-practice",
      "title": "The A2A Protocol in Practice: Agent Cards, Tasks, Auth and When You Need It",
      "description": "A practical guide to the A2A (Agent2Agent) protocol: what it standardizes, when it beats in-process subagents, how Agent Cards, task states, bindings and authentication work, how credentials cross agent hops, and how to launch it.",
      "kind": "pillar",
      "order": 0,
      "html": "https://changegamer.ai/articles/a2a-protocol-in-practice",
      "markdown": "https://changegamer.ai/articles/a2a-protocol-in-practice.md",
      "json": "https://changegamer.ai/api/articles/a2a-protocol-in-practice.json"
    },
    "articles": [
      {
        "slug": "do-you-need-a2a",
        "title": "Do You Need A2A for a Multi-Agent System? A Decision Rule",
        "description": "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.",
        "kind": "sub",
        "order": 1,
        "html": "https://changegamer.ai/articles/do-you-need-a2a",
        "markdown": "https://changegamer.ai/articles/do-you-need-a2a.md",
        "json": "https://changegamer.ai/api/articles/do-you-need-a2a.json"
      },
      {
        "slug": "a2a-agent-card-design",
        "title": "Designing an Agent Card: What Goes in the Public Card and What Waits",
        "description": "How to design an A2A Agent Card: the field groups, the well-known path, optional signing, and a rule for splitting what the public card advertises from what an authenticated client fetches in the extended card.",
        "kind": "sub",
        "order": 2,
        "html": "https://changegamer.ai/articles/a2a-agent-card-design",
        "markdown": "https://changegamer.ai/articles/a2a-agent-card-design.md",
        "json": "https://changegamer.ai/api/articles/a2a-agent-card-design.json"
      },
      {
        "slug": "a2a-task-lifecycle",
        "title": "A2A Task States and Operations: What Each State Means for an Orchestrator",
        "description": "The eight A2A task states, the eleven operations that act on tasks, the difference between interrupted and terminal states, and an inference-labelled handler matrix for an orchestrator.",
        "kind": "sub",
        "order": 3,
        "html": "https://changegamer.ai/articles/a2a-task-lifecycle",
        "markdown": "https://changegamer.ai/articles/a2a-task-lifecycle.md",
        "json": "https://changegamer.ai/api/articles/a2a-task-lifecycle.json"
      },
      {
        "slug": "a2a-bindings-json-rpc-grpc-rest",
        "title": "A2A JSON-RPC vs gRPC vs REST: What Differs Between the Three Bindings",
        "description": "The three A2A protocol bindings (JSON-RPC, gRPC, HTTP+JSON/REST): what the specification keeps identical, what differs on the wire, and an inference-labelled guide to picking one.",
        "kind": "sub",
        "order": 4,
        "html": "https://changegamer.ai/articles/a2a-bindings-json-rpc-grpc-rest",
        "markdown": "https://changegamer.ai/articles/a2a-bindings-json-rpc-grpc-rest.md",
        "json": "https://changegamer.ai/api/articles/a2a-bindings-json-rpc-grpc-rest.json"
      },
      {
        "slug": "a2a-authentication-schemes",
        "title": "A2A Authentication Schemes: Which to Declare in Your Agent Card",
        "description": "The five security scheme families an A2A Agent Card can declare (API key, HTTP auth, OAuth 2.0, OpenID Connect, mutual TLS), an inference-labelled rule for choosing one, and how a client handles auth-required tasks.",
        "kind": "sub",
        "order": 5,
        "html": "https://changegamer.ai/articles/a2a-authentication-schemes",
        "markdown": "https://changegamer.ai/articles/a2a-authentication-schemes.md",
        "json": "https://changegamer.ai/api/articles/a2a-authentication-schemes.json"
      },
      {
        "slug": "credential-propagation-across-agent-hops",
        "title": "Credential Propagation Across Agent Hops: Exchange, Audience and Depth",
        "description": "How to carry authority through a chain of delegating agents: why forwarding a token fails, per-hop RFC 8693 exchange with act and may_act, RFC 8707 audience binding, a worked sequence and a failure walk-through.",
        "kind": "sub",
        "order": 6,
        "html": "https://changegamer.ai/articles/credential-propagation-across-agent-hops",
        "markdown": "https://changegamer.ai/articles/credential-propagation-across-agent-hops.md",
        "json": "https://changegamer.ai/api/articles/credential-propagation-across-agent-hops.json"
      },
      {
        "slug": "trusting-a-remote-agent",
        "title": "How to Verify a Remote A2A Agent Before Delegating",
        "description": "What a signed Agent Card proves and does not, how domain, key and ERC-8004 identity differ, where Web Bot Auth fits, and why card text and returned artifacts are untrusted input, ending in an ordered checklist.",
        "kind": "sub",
        "order": 7,
        "html": "https://changegamer.ai/articles/trusting-a-remote-agent",
        "markdown": "https://changegamer.ai/articles/trusting-a-remote-agent.md",
        "json": "https://changegamer.ai/api/articles/trusting-a-remote-agent.json"
      },
      {
        "slug": "a2a-agent-discovery-without-a-registry",
        "title": "How Do Agents Discover A2A Agents Without a Standard Registry?",
        "description": "The three discovery strategies in the A2A documentation, why the spec prescribes no registry API, what vendor registries fill the gap, and how to choose between a well-known URI, a registry and direct configuration.",
        "kind": "sub",
        "order": 8,
        "html": "https://changegamer.ai/articles/a2a-agent-discovery-without-a-registry",
        "markdown": "https://changegamer.ai/articles/a2a-agent-discovery-without-a-registry.md",
        "json": "https://changegamer.ai/api/articles/a2a-agent-discovery-without-a-registry.json"
      },
      {
        "slug": "a2a-v0-3-to-v1-0-migration",
        "title": "Migrate A2A v0.3 to v1.0: An Ordered Checklist for Clients and Servers",
        "description": "An ordered checklist for moving an A2A client or server from v0.3 to v1.0: the A2A-Version header rule, method names, Part shape, a runnable grep check, and symptom-to-cause pointers.",
        "kind": "sub",
        "order": 9,
        "html": "https://changegamer.ai/articles/a2a-v0-3-to-v1-0-migration",
        "markdown": "https://changegamer.ai/articles/a2a-v0-3-to-v1-0-migration.md",
        "json": "https://changegamer.ai/api/articles/a2a-v0-3-to-v1-0-migration.json"
      },
      {
        "slug": "agent-frameworks-with-a2a-support",
        "title": "Does Your Agent Framework Really Support A2A? How to Read the Claim and What to Test",
        "description": "Which agent frameworks list A2A support, what native, add-on, platform-gated and unrecorded mean, a short test checklist to run before you rely on it, and how that differs from the protocol's own SDKs.",
        "kind": "sub",
        "order": 10,
        "html": "https://changegamer.ai/articles/agent-frameworks-with-a2a-support",
        "markdown": "https://changegamer.ai/articles/agent-frameworks-with-a2a-support.md",
        "json": "https://changegamer.ai/api/articles/agent-frameworks-with-a2a-support.json"
      },
      {
        "slug": "failure-handling-across-agent-boundaries",
        "title": "Failed or Rejected Remote A2A Task: Retry, Degrade or Surface?",
        "description": "How to decide what happens after a remote A2A task ends badly: the side-effects test that splits failed into retry or surface, why rejected is not a retry case, why input-required is not a failure, and a structured result for the caller.",
        "kind": "sub",
        "order": 11,
        "html": "https://changegamer.ai/articles/failure-handling-across-agent-boundaries",
        "markdown": "https://changegamer.ai/articles/failure-handling-across-agent-boundaries.md",
        "json": "https://changegamer.ai/api/articles/failure-handling-across-agent-boundaries.json"
      },
      {
        "slug": "a2a-production-launch-checklist",
        "title": "A2A Production Launch Checklist: Gates to Pass Before You Ship",
        "description": "A go/no-go checklist for launching A2A agent-to-agent delegation, one line per gate, each pointing to the article that owns the detail: need, card, states, binding, auth, trust, versioning, failure.",
        "kind": "sub",
        "order": 12,
        "html": "https://changegamer.ai/articles/a2a-production-launch-checklist",
        "markdown": "https://changegamer.ai/articles/a2a-production-launch-checklist.md",
        "json": "https://changegamer.ai/api/articles/a2a-production-launch-checklist.json"
      }
    ]
  },
  "navigation": {
    "pillar": {
      "slug": "a2a-protocol-in-practice",
      "title": "The A2A Protocol in Practice: Agent Cards, Tasks, Auth and When You Need It",
      "description": "A practical guide to the A2A (Agent2Agent) protocol: what it standardizes, when it beats in-process subagents, how Agent Cards, task states, bindings and authentication work, how credentials cross agent hops, and how to launch it.",
      "kind": "pillar",
      "order": 0,
      "html": "https://changegamer.ai/articles/a2a-protocol-in-practice",
      "markdown": "https://changegamer.ai/articles/a2a-protocol-in-practice.md",
      "json": "https://changegamer.ai/api/articles/a2a-protocol-in-practice.json"
    },
    "previous": null,
    "next": {
      "slug": "a2a-agent-card-design",
      "title": "Designing an Agent Card: What Goes in the Public Card and What Waits",
      "description": "How to design an A2A Agent Card: the field groups, the well-known path, optional signing, and a rule for splitting what the public card advertises from what an authenticated client fetches in the extended card.",
      "kind": "sub",
      "order": 2,
      "html": "https://changegamer.ai/articles/a2a-agent-card-design",
      "markdown": "https://changegamer.ai/articles/a2a-agent-card-design.md",
      "json": "https://changegamer.ai/api/articles/a2a-agent-card-design.json"
    }
  },
  "resources": [
    {
      "slug": "multi-agent-orchestration-patterns",
      "html": "https://changegamer.ai/resources/multi-agent-orchestration-patterns",
      "markdown": "https://changegamer.ai/resources/multi-agent-orchestration-patterns.md",
      "json": "https://changegamer.ai/api/resources/multi-agent-orchestration-patterns.json"
    },
    {
      "slug": "mcp-vs-a2a",
      "html": "https://changegamer.ai/resources/mcp-vs-a2a",
      "markdown": "https://changegamer.ai/resources/mcp-vs-a2a.md",
      "json": "https://changegamer.ai/api/resources/mcp-vs-a2a.json"
    },
    {
      "slug": "a2a-protocol",
      "html": "https://changegamer.ai/resources/a2a-protocol",
      "markdown": "https://changegamer.ai/resources/a2a-protocol.md",
      "json": "https://changegamer.ai/api/resources/a2a-protocol.json"
    }
  ]
}