Skip to content
  1. Home
  2. AI agents
  3. Tools, MCP and agent-to-agent
  4. MCP vs A2A

Build · Tools, MCP and agent-to-agent

MCP vs A2A: which protocol does what?

MCP connects one agent to its tools and data; A2A connects agents to each other. An MCP call is usually a stateless request for a named tool, while an A2A exchange is a task with a lifecycle that another agent, built by another team or vendor, works on and reports back. Tools need MCP; delegating to another agent needs A2A.

In this guide: 83 pages

Key takeaways

  1. Use MCP when the other side is a tool you govern at a gateway. Use A2A when the other side is an agent that keeps its own state and belongs to another team or vendor.
  2. A2A 1.0.0 (12 Mar 2026) renamed every operation, added signed Agent Cards and multi-tenancy, and made a2a.proto the source of truth across JSON-RPC, gRPC and REST bindings. Platforms sit at different versions, so test interoperability.
  3. IBM’s Agent Communication Protocol merged into A2A in August 2025; AGNTCY sits around both; the commerce protocols (AP2, Agentic Commerce Protocol, UCP) are early and overlap.
  4. An agent that trusts another agent inherits its mistakes. Verify signed Agent Cards, pass delegated scoped tokens instead of secrets, and keep a human gate on sensitive actions.
MCP connects an agent to its tools; A2A connects agents to each otherAgent A, your agent with its own identity, sits in the middle. Downward arrows labelled MCP connect it to three tools: a database, a ticketing API and a document store. Sideways arrows labelled A2A connect it to Agent B, built by another team, and Agent C, run by a vendor. Each of those publishes an Agent Card, works a task through states such as working, input required and completed, and reports back without exposing its internals.A2A (horizontal): agent to agentAgent B (another team)publishes an Agent Card,works a task, reports backAgent A (yours)model, instructions,its own identityAgent C (a vendor)signed Agent Card, taskstates, streaming updatesMCP (vertical): agent to its toolsDatabaseread-only, scopedTicketing APIcreate with approvalDocumentssearch and citeTools are usually stateless calls; an agent holds a multi-turn task.MCP connects an agent to its tools; A2A connects agents to each otherAgent A, your agent with its own identity, sits in the middle. Downward arrows labelled MCP connect it to three tools: a database, a ticketing API and a document store. Sideways arrows labelled A2A connect it to Agent B, built by another team, and Agent C, run by a vendor. Each of those publishes an Agent Card, works a task through states such as working, input required and completed, and reports back without exposing its internals.A2A (horizontal): agent to agentAgent B (another team)publishes an Agent Card,works a task, reports backAgent A (yours)model, instructions,its own identityAgent C (a vendor)signed Agent Card, taskstates, streaming updatesMCP (vertical): Agent A to its toolsDatabaseread-only, scopedTicketing APIcreate with approvalDocumentssearch and citeTools are usually stateless calls; an agent holds a multi-turn task.
Your agent reaches tools downward over MCP and other agents sideways over A2A. The other agents publish an Agent Card and work a task through states; they never expose their prompts, memory or tools.

What does A2A do that MCP does not?

A2A gives one agent a way to find another, hand it a task, follow its progress and get the result, without either side seeing the other’s internals. MCP’s core describes tools, and its Tasks extension (beta) covers long-running tool work; it has no notion of a remote agent’s state or of a card that describes an agent.

Discovery runs through an Agent Card, a JSON document at /.well-known/agent-card.json that lists the agent’s supported interfaces and their protocol versions, its capabilities (streaming, push notifications, an extended card), its security schemes, its skills and its provider, with an optional signature. In 1.0 a card may be signed with JSON Web Signature over a canonicalised card, and clients should verify at least one signature before trusting it. Older clients still look for /.well-known/agent.json, and the Copilot Studio documentation still references that path.

Work moves as tasks. A message is one turn with a role; a task is the unit of work with an id and a lifecycle; artifacts are its outputs; a context id groups related tasks. The states are submitted, working, input required, auth required, and the terminal completed, failed, canceled and rejected. The two interrupted states are how a remote agent asks the caller, or a person, for more information or credentials mid-task. Long-running work streams status and artifact events until a terminal state, or the remote agent posts updates to a webhook.

The 1.0 operations are SendMessage, SendStreamingMessage, GetTask, ListTasks (new, with cursor pagination), CancelTask, SubscribeToTask, push-notification configuration and GetExtendedAgentCard; the 0.3 names were message/send, tasks/get and so on. Three bindings (JSON-RPC, gRPC and HTTP with JSON) share one model defined in a2a.proto, errors use google.rpc.Status, and clients send an A2A-Version header. Production must use TLS, credentials travel in headers on every request, OAuth implicit and password flows were removed in 1.0, and a tenant field lets one endpoint serve many tenants. Agents stay opaque: they collaborate on declared capabilities and never share memory, prompts or tools.

When should you use MCP, A2A or neither?

Use MCP when the thing on the other side is a tool operation you govern at a gateway. A2A is for the case where the other side is an agent that holds state across turns and belongs to someone else. Neither is needed when a direct API call or a workflow step does the job.

Seven situations and the mechanism that fits each.

SituationChoiceWhy
An agent needs to read or write a company systemMCP, or a direct API callA stateless call, allow-listed and logged at the gateway
Several agents and IDEs share the same toolsMCPOne server, many clients, with the private registry as the allow list
Another team’s agent does part of the work and keeps its own stateA2ATask lifecycle, streaming, interrupted states for input and credentials
A vendor’s agent (ServiceNow, Salesforce, SAP) must take a task from yoursA2AThe vendor publishes an Agent Card; you verify its signature
Two agents on the same framework in the same teamFramework-native sub-agents, or the Activity Protocol for Microsoft 365 Agents SDK agentsA2A would add latency and a second model’s judgment for no gain
A fixed sequence of steps with no judgment neededA workflow (Logic Apps, Step Functions, Power Automate)Deterministic, cheaper and easier to audit
Payments or purchases by an agentAP2 as an A2A extension, or a commerce protocol, with careAP2 signs mandates; the commerce protocols are early and still changing

Microsoft’s guidance for Copilot Studio draws the same lines: A2A for agents built on external frameworks, MCP for tools, and the Activity Protocol for agents built on the Microsoft 365 Agents SDK. The A2A project’s guide puts it as MCP being vertical, deepening a single agent, and A2A horizontal, connecting agents across a boundary.

What are the risks of agent-to-agent calls?

The main risk is implicit trust between agents. Palo Alto Networks Unit 42 showed on 31 Oct 2025 that a malicious remote agent could use a live A2A session to inject hidden multi-turn instructions, leak a client agent’s system prompt, tools and history, and trigger an unauthorized stock purchase, in a proof of concept built on Google’s ADK.

Unit 42 was explicit that the research revealed no vulnerability in the protocol itself; the problem is an agent that treats another agent’s output as instructions. Its mitigations are out-of-band human approval for sensitive actions, context grounding that ends a drifting session, signed Agent Cards and real-time visibility of agent activity. Four further risks follow from the spec. Signing is optional, so an unverified card could belong to an impostor. In-band credential exchange can pass credentials along a chain of agents, so use delegated, scoped tokens (Foundry’s on-behalf-of auth, AgentCore Identity) instead of sharing secrets. Versions are fragmented: 1.0 renamed every operation and state, while Foundry runs 1.0 with 0.3 in preview, the AWS tutorial pins the 0.3 SDK, and the Copilot Studio documentation shows 0.3-style payloads. Managed platforms have gaps, such as Foundry-to-Foundry A2A being text only, with no streaming and tasks kept for 60 days.

Accountability also moves. Copilot Studio’s documentation puts responsibility for data flows, quality, permissions, observability and human oversight on the maker who connects an outside agent, and the Linux Foundation named authentication and audit trails as the next frontier after 1.0. Adoption numbers need the same care: the foundation’s April 2026 release counted 150 or more supporting organisations and named industries without naming a production customer. A supporter count and a deployment count are different numbers.

Which other agent protocols exist, and which merged?

A2A absorbed one rival and sits beside several neighbours. IBM’s Agent Communication Protocol merged into A2A and its repository was archived on 27 Aug 2025, so treat that ACP as historical; AGNTCY, the commerce protocols and the W3C community work each solve a different problem.

Agent protocols and their status as the project pages showed on 2 Nov 2026.

ProtocolWhoWhat it coversStatus
A2ALinux Foundation project; in the Agentic AI Foundation since 27 Aug 2026Agent-to-agent tasks, Agent Cards, three bindings1.0.0 on 12 Mar 2026, 1.0.1 on 28 May 2026; steering committee with AWS, Cisco, Google, IBM Research, Microsoft, Salesforce, SAP and ServiceNow
MCPAgentic AI Foundation since 9 Dec 2025Agent-to-tool calls, resources, promptsSpecification 2026-07-28
IBM Agent Communication Protocol (ACP)IBM, BeeAIREST-based agent messagingMerged into A2A; repository archived 27 Aug 2025
AGNTCYCisco-originated; Linux Foundation since 29 Jul 2025Discovery (OASF), identity, SLIM messaging and observability around A2A and MCPActive; absent from the Agentic AI Foundation project list of 22 Oct 2026
Agent Payments Protocol (AP2)Google, 16 Sep 2025Signed intent, cart and payment mandates; usable as an A2A extension60 or more collaborators named; early
Agentic Commerce ProtocolOpenAI and StripeCheckout from a chat; a name collision with IBM’s ACPBeta; versions through 17 Apr 2026; OpenAI changed its in-chat checkout plans in March 2026 (secondary reporting)
Universal Commerce Protocol (UCP)Google, 2026 (launch date from secondary reporting)Purchases in AI Mode and the Gemini app; REST and MCP transportsLive for some verticals, others on a waitlist
Agent Network Protocol (ANP)W3C AI Agent Protocol Community GroupOpen-internet agent networking with decentralised identityCommunity group draft; not a W3C standard; no named enterprise adopters found

Two different protocols share the ACP acronym, so when a vendor says ACP, ask which one.

How do Microsoft, AWS and Google implement it?

A2A on each cloud, with statuses as the vendor pages showed on 2 Nov 2026.

Capability, Microsoft, AWS, Google

CapabilityMicrosoftAWSGoogle
A2A supportFoundry a2a tool on A2A 1.0 (GA), a2a_preview on 0.3, and Foundry agents exposed as A2A endpoints; Copilot Studio A2A GA April 2026 with none, API key or OAuth 2.0 auth, reaching on-premises agents through custom-connector infrastructureAgentCore Runtime hosts A2A servers (announced 11 Nov 2025): container on port 9000, card at /.well-known/agent-card.json, SigV4 or OAuth inbound; Gateway passes A2A traffic throughADK agents consume a remote A2A agent as a sub-agent or expose themselves; Agent Registry GA 18 Jun 2026 with A2A v1; Gemini Enterprise imports A2A agents from the registry (Agent Gateway required)
Version in the documented path1.0 in Foundry; the Copilot Studio sample still shows message/send and /.well-known/agent.jsonThe tutorial pins a2a-sdk 0.3; 1.0 support unverified on 2 Nov 2026A2A v1 in Agent Registry
Limits worth knowingFoundry-to-Foundry: JSON-RPC only, text only, no streaming, tasks and contexts kept 60 daysJSON-RPC passed through unmodified; AWS Marketplace lists A2A servers for Runtime (19 Nov 2025)Import into Gemini Enterprise carries no stated GA or preview label
Delegated auth between agentsAgentOnBehalfOfUser on the Foundry A2A tool (preview)AgentCore Identity workload identity with token exchangeOAuth with PKCE option on imported agents; Agent Identity API in preview

OpenAI’s API documentation showed no A2A support on 2 Nov 2026; OpenAI Agents SDK agents can be hosted on AgentCore Runtime as A2A servers.

Frequently asked questions

Does A2A replace MCP?

No. They are complementary: MCP connects an agent to tools, A2A connects agents to each other, and one agent commonly uses both. A2A’s own documentation describes MCP as vertical and A2A as horizontal, and since 27 Aug 2026 both are projects of the Agentic AI Foundation.

Is A2A 1.0 compatible with 0.3?

Not directly. 1.0 renamed every operation (SendMessage for message/send, GetTask for tasks/get), prefixed the task states, unified the Part type and changed card fields. Some SDKs add a compatibility layer, the Java SDK among them, and clients send an A2A-Version header, so check the version on both ends before a production link.

Do we need A2A to connect Copilot Studio agents to Foundry agents?

Not as a rule. Foundry agents can call each other over A2A (text only, no streaming), but Microsoft’s guidance reserves A2A for agents built on external frameworks, MCP for tools, and the Activity Protocol for agents built on the Microsoft 365 Agents SDK, and Copilot Studio connects to other agents through its own agent connections. A2A earns its place when the other agent belongs to a vendor or runs outside the Microsoft stack.

What is an Agent Card?

A self-describing JSON manifest an agent serves at /.well-known/agent-card.json: name, description, version, supported interfaces, capabilities, security schemes, skills and provider, optionally signed with JSON Web Signature. A card describes one agent; a registry such as AWS Agent Registry or Google Agent Registry stores and validates many cards and adds approval.

Who runs A2A?

Google announced it on 9 Apr 2025 and moved it to the Linux Foundation on 23 Jun 2025. Since 27 Aug 2026 it is a growth-stage project of the Agentic AI Foundation, next to MCP. The technical steering committee lists AWS, Cisco, Google, IBM Research, Microsoft, Salesforce, SAP and ServiceNow, with SDKs in Python, Go, Java, JavaScript, .NET and Rust.

More in Tools, MCP and agent-to-agent

What is MCP?Read MCP securityRead
MCP gateways and registriescoming
Tool calling and actionscoming

Sources

Each source was read on 2 November 2026. The date shown is the date on the page, or the page’s ms.date for Microsoft Learn; an undated page shows the date it was read.

  1. A2A protocol specification, version 1.0.0 A2A project, 12 March 2026
  2. What’s new in A2A v1.0 A2A project, 12 March 2026
  3. A2A and MCP A2A project, undated page, read 2 November 2026
  4. A2A releases (v1.0.0, v1.0.1) A2A project on GitHub, undated page, read 2 November 2026
  5. A new chapter for A2A: joining the Agentic AI Foundation A2A project, 27 August 2026
  6. Announcing the Agent2Agent protocol (A2A) Google Developers Blog, 9 April 2025
  7. Linux Foundation launches the Agent2Agent Protocol Project Linux Foundation, 23 June 2025
  8. Agent2Agent protocol is getting an upgrade (v0.3) Google Cloud blog, 31 July 2025
  9. A2A protocol surpasses 150 organizations in its first year Linux Foundation, 9 April 2026
  10. IBM Agent Communication Protocol repository (archived) IBM on GitHub, undated page, read 2 November 2026
  11. Linux Foundation welcomes the AGNTCY project Linux Foundation, 29 July 2025
  12. Announcing the Agent Payments Protocol (AP2) Google Cloud blog, 16 September 2025
  13. Agentic Commerce Protocol repository OpenAI and Stripe on GitHub, undated page, read 2 November 2026
  14. OpenAI shifts checkout plans in its agentic commerce strategy Digital Commerce 360, 6 March 2026. Secondary reporting; OpenAI’s own post was not fetched.
  15. Universal Commerce Protocol Google for Developers, undated page, read 2 November 2026
  16. AI Agent Protocol Community Group W3C, undated page, read 2 November 2026
  17. Agent-to-agent tool in Foundry Agent Service Microsoft Learn, 28 October 2026
  18. Connect agents to other agents using the A2A protocol (Copilot Studio) Microsoft Learn, 26 August 2026
  19. What’s new in Copilot Studio Microsoft Learn, 22 October 2026
  20. Introducing agent-to-agent protocol support in Amazon Bedrock AgentCore Runtime AWS Machine Learning Blog, 11 November 2025
  21. Agent-to-agent protocol support in AgentCore Runtime AWS documentation, undated page, read 2 November 2026
  22. A2A servers for AgentCore Runtime in AWS Marketplace AWS What’s New, 19 November 2025
  23. Gemini Enterprise Agent Platform release notes Google Cloud, 28 October 2026
  24. Import and govern agents from Agent Registry (Gemini Enterprise) Google Cloud, undated page, read 2 November 2026
  25. Agent session smuggling in Agent2Agent systems Palo Alto Networks Unit 42, 31 October 2025
  26. A2A Java SDK 1.0.0.CR1 released Quarkus blog, undated page, read 2 November 2026

Planning an AI program?

Talk to the team that builds it and runs it after launch.

  • Built to SOC 2, HIPAA and GDPR standards
  • EU AI Act-aligned delivery
  • Microsoft Solutions Partner