A2A protocol vs MCP: differences and when to use each
A2A and MCP are open protocols for agentic AI systems that cover different connections: the Agent2Agent (A2A) protocol lets independent AI agents discover each other and delegate work, while the Model Context Protocol (MCP) lets one AI application use tools and data. Comparing the A2A protocol vs MCP comes down to which boundary each one governs, because systems that adopt one often end up using both. This comparison covers concepts, wire formats, state, security, and governance, then shows how the protocols combine in a single architecture.
A2A protocol vs MCP at a glance#
A2A is a peer protocol: a client agent hands a task to a remote agent and tracks it until the remote agent returns results. MCP is a capability protocol: an AI application's MCP client lists and calls tools, resources, and prompts on an MCP server. Both use JSON-RPC 2.0 and HTTP, and both now live in the same foundation.
| Dimension | A2A | MCP |
|---|---|---|
| Connects | A client agent to a remote agent | An AI application to tools, data, and prompts |
| Unit of work | Task with a lifecycle and artifacts | One request, most often tools/call |
| State | Stateful tasks, grouped by contextId |
Stateless since 2026-07-28; state via explicit handles |
| Discovery | Agent Card at a well-known URL | server/discover plus */list methods |
| Interface exposed | Skills described in natural language | Tools with JSON Schema inputs and outputs |
| Bindings | JSON-RPC 2.0, gRPC, HTTP+JSON | stdio and Streamable HTTP, both JSON-RPC 2.0 |
| Async model | Polling, SSE streaming, push webhooks | Request-scoped SSE; optional Tasks extension |
| Authentication | Schemes declared in the Agent Card | OAuth 2.1 flow for HTTP; environment for stdio |
| Normative source | Protocol Buffers file (a2a.proto) |
TypeScript schema |
| Origin | Google, April 2025 | Anthropic, November 2024 |
| Governance | Agentic AI Foundation (Linux Foundation) | Agentic AI Foundation (Linux Foundation) |
What is the A2A protocol?#
The Agent2Agent (A2A) protocol is an open standard that lets AI agents from different frameworks and vendors discover each other's capabilities and collaborate on tasks over HTTP.
Google announced A2A in April 2025 and contributed it to the Linux Foundation in June 2025, with AWS, Cisco, Microsoft, Salesforce, SAP, and ServiceNow among the founding organizations. IBM's Agent Communication Protocol merged into A2A in August 2025. Version 1.0, the first stable specification, shipped in March 2026; the Linux Foundation highlighted its multi-protocol support, multi-tenancy, modernized security flows, and signed Agent Cards. In April 2026 the Linux Foundation reported more than 150 supporting organizations, and in August 2026 A2A joined the Agentic AI Foundation as a hosted project, alongside MCP.
The A2A specification states its design goals plainly: reuse HTTP, JSON-RPC 2.0, and server-sent events; design for long-running and human-in-the-loop work; stay agnostic about content types; and keep execution opaque. Opacity is the defining choice. Agents collaborate "without needing access to each other's internal state, memory, or tools," which means a remote AI agent can be built on any agent framework, any model, and any toolset without the caller needing to know.
How does the A2A protocol work?#
An A2A interaction has a client agent and a remote agent. The client reads the remote agent's Agent Card, sends a Message made of one or more Parts, and receives either a direct Message or a Task. A Task moves through states until it finishes, and its results arrive as Artifacts.
The core objects are small in number:
- Message: one turn of communication, with a role (user or agent), a message ID, and one or more Parts.
- Part: the content container, holding exactly one of text, inline bytes, a URL to a file, or structured JSON data, plus an optional media type.
- Task: the stateful unit of work, with a server-generated ID, a status, a history, and artifacts.
- Artifact: a concrete output of a task, such as a document, an image, or structured data, built from Parts.
- Context ID: an optional identifier that groups related tasks and messages into one conversation.
Version 1.0 names its operations in PascalCase across bindings: SendMessage, SendStreamingMessage, GetTask, ListTasks, CancelTask, SubscribeToTask, GetExtendedAgentCard, and four methods for managing push notification configurations. Clients send an A2A-Version header on each request so agents can upgrade without breaking older callers.
By default, SendMessage blocks until the task reaches a terminal state or an interrupted one. A client can instead ask for an immediate return and then poll GetTask, subscribe to a server-sent events stream, or register a webhook for push notifications, which suits tasks that run for hours. The auth-required state lets a remote agent request a secondary credential partway through a task, which the client obtains outside the protocol.
What is an A2A agent card?#
An Agent Card is a JSON document that describes an A2A agent: its name, description, provider, version, the interfaces and protocol bindings it supports, its capabilities, its skills, and the security schemes a client must use. The standard discovery location is https://{domain}/.well-known/agent-card.json, though clients can also find cards through registries or direct configuration.
A trimmed example, following the v1.0 field names:
{
"name": "Invoice Reconciliation Agent",
"description": "Matches supplier invoices to purchase orders.",
"version": "2.1.0",
"provider": {
"organization": "Example Finance Ops",
"url": "https://finance.example.com"
},
"supportedInterfaces": [
{
"url": "https://agents.example.com/a2a/v1",
"protocolBinding": "JSONRPC",
"protocolVersion": "1.0"
}
],
"capabilities": { "streaming": true, "pushNotifications": true },
"defaultInputModes": ["application/json", "text/plain"],
"defaultOutputModes": ["application/json"],
"skills": [
{
"id": "reconcile-invoices",
"name": "Reconcile invoices",
"description": "Compares invoices against open POs for a vendor.",
"tags": ["finance", "accounts-payable"],
"examples": ["Reconcile March invoices for vendor 4471"]
}
]
}Three details separate an Agent Card from an MCP tool list. Skills are described in natural language with tags and examples, not with a JSON Schema for arguments, because the remote agent interprets the request itself. Security requirements live in the card through securitySchemes and securityRequirements, covering API keys, HTTP authentication, OAuth 2.0, OpenID Connect, and mutual TLS. And in v1.0 a card can carry JWS signatures, so a client can verify who published it. Agents that set extendedAgentCard to true can return a richer card to authenticated callers.
A2A vs MCP: the differences that matter#
The differences between A2A and MCP follow from one design decision: A2A models the remote side as an autonomous agent, and MCP models it as a set of capabilities. That decision shapes how each protocol handles state, discovery, interfaces, and failure, and it determines which protocol fits a given boundary in a system.
Peers vs tools#
An MCP tool is a function with a typed contract, the same shape as tool calling in a model API. The calling model sees its name, description, and input schema, and the host executes exactly the call the model emitted. An A2A skill is a capability of a system the caller cannot see into. The client sends a goal in a Message, and the remote agent plans, calls its own tools, and may ask clarifying questions. MCP gives the caller control and visibility; A2A gives the remote party autonomy and privacy.
Stateful tasks vs stateless requests#
A2A is stateful by design: a Task has an ID, a history, and a lifecycle, and related tasks share a context ID. The current MCP revision, 2026-07-28, went the other way and removed protocol-level sessions, so every MCP request stands alone and servers that need continuity mint explicit handles. MCP covers long-running work through an optional Tasks extension, whereas in A2A the task is the core abstraction.
Wire format and bindings#
Both protocols build on JSON-RPC 2.0, but A2A also defines gRPC and HTTP+JSON bindings with equivalent behavior and treats a Protocol Buffers file as its normative definition. MCP defines stdio for local subprocess servers and Streamable HTTP for remote ones. A2A defines no standard local subprocess binding, which reflects its focus on agents deployed as network services.
The following map shows the closest MCP equivalent for each A2A concept, and where the analogy breaks:
| A2A concept | Closest MCP equivalent | Where they differ |
|---|---|---|
| Agent Card | server/discover and tools/list |
Card is a static document at a URL; MCP discovery is an RPC |
| Skill | Tool | Skill takes a goal in natural language; tool takes typed arguments |
| Task | Tasks extension handle | Core in A2A; opt-in extension in MCP |
input-required state |
input_required result with elicitation |
A2A pauses a task; MCP has the client retry the request |
| Artifact | Tool result content or structuredContent |
Artifacts can stream as appended chunks during a task |
| Push notification webhook | subscriptions/listen stream |
A2A pushes task updates; MCP streams list and resource changes |
How do A2A and MCP work together?#
A2A and MCP stack rather than compete. A common pattern has an orchestrator agent that acts as an A2A server to its caller, an A2A client to specialist agents, and an MCP host for its own tools. Each specialist runs its own MCP clients internally, and none of those tools are visible across the A2A boundary.
The A2A and MCP guide on the A2A site uses an auto repair shop to make the same point. A customer talks to a shop manager agent over A2A, the manager delegates to a mechanic agent, the mechanic uses MCP to reach diagnostic scanners and repair manuals, and the mechanic contacts a parts supplier's agent over A2A again. The guide summarizes the split as MCP giving each agent depth and A2A giving the system reach.
A shortcut some teams take is wrapping a sub-agent as an MCP tool. That works when the sub-agent behaves like a function: one request, one answer, seconds of latency. It breaks down when the work needs a task lifecycle, mid-task questions, progress streaming, or a boundary where the other party must not expose its prompts and tools. Those are the cases A2A was built for.
When to use A2A vs MCP#
Use MCP when an AI application needs to reach tools, data, or prompts, whether the server is local or remote. Use A2A when work crosses to another agent that should run on its own terms, especially across teams, vendors, or organizations. Inside one codebase, the multi-agent features of agent frameworks are often simpler than either protocol.
| Scenario | Protocol | Reason |
|---|---|---|
| A coding agent needs GitHub, a database, and internal docs | MCP | Tool and data access for one application |
| A SaaS company wants its API usable from many AI clients | MCP server | One server works across MCP hosts |
| A support agent hands a refund case to finance's agent | A2A | Delegation to an autonomous peer with its own policies |
| A company calls a partner's agent without seeing its internals | A2A | Opaque execution across an organizational boundary |
| A job runs for hours and needs a human approval midway | A2A | Task lifecycle, input-required, push notifications |
| Several sub-agents run in one process on one framework | Often neither | Framework-native orchestration has less overhead |
| A sub-agent behaves like a fast, stateless function | MCP tool | A typed tool contract is simpler than a task |
The last two rows matter most for teams starting out. A multi-agent system inside one service rarely needs a network protocol between its parts, and the AI agents explainer covers when multiple agents help at all. A2A earns its overhead at boundaries where agents are deployed, owned, or secured separately.
Security and governance compared#
Both protocols rely on standard web authentication, but they place trust differently. MCP specifies an OAuth 2.1 authorization flow in detail and expects the host to ask the user before tool calls. A2A declares security schemes in the Agent Card, carries credentials in HTTP headers, and makes each remote agent the gatekeeper for its own data.
On the A2A side, production traffic must use HTTPS, servers return 401 for missing credentials and 403 for insufficient permissions, and authorization can be scoped per skill. Credentials are obtained outside the protocol, and the A2A documentation recommends OpenTelemetry trace context propagation so a request can be followed across agent hops. On the MCP side, tokens must be bound to a single server through Resource Indicators, servers must not pass client tokens through to downstream APIs, and hosts should sandbox local servers. The MCP explainer covers those controls in detail.
One risk crosses both boundaries. Text that comes back from a remote agent or from a tool enters the calling model's context, so prompt injection can travel through A2A artifacts as easily as through MCP tool results. Treat both as untrusted input, log both for LLM observability, and route both through policy enforcement points such as an AI gateway where the organization needs central control. Bifrost, for example, proxies A2A agents through its Agent Gateway and MCP servers through its MCP gateway, and its agent logs follow one session across tasks, model calls, and MCP calls.
Governance has converged. Both protocols are hosted by the Agentic AI Foundation under the Linux Foundation, both publish open specifications with public change processes, and the A2A specification describes the two as complementary in an appendix devoted to MCP.
Where to go next#
For the full mechanics of the tool side, read what is the Model Context Protocol, which covers transports, authorization, and gateways. To see how agents use tools in the first place, the tool calling guide explains the model-side loop. The MCP topic hub collects every related guide and glossary entry.
Frequently asked questions
Can A2A replace MCP?
- No. A2A and MCP cover different boundaries, so neither replaces the other. A2A defines how one agent delegates a task to another agent and tracks it to completion. MCP defines how an agent discovers and calls tools, reads resources, and uses prompts. An agent that receives work over A2A usually still uses MCP to reach the systems it needs.
Does A2A use MCP?
- The A2A specification does not depend on MCP, but the two are designed to be used together. The A2A specification describes a remote agent that receives a task over A2A and then uses MCP to call the tools, APIs, and data sources it needs. Those MCP tools stay internal to that agent and are not exposed to the A2A client.
Who created the A2A protocol?
- Google created the Agent2Agent protocol and announced it in April 2025. Google contributed A2A to the Linux Foundation in June 2025, with AWS, Cisco, Microsoft, Salesforce, SAP, and ServiceNow among the founding organizations, and IBM's Agent Communication Protocol merged into A2A in August 2025. A2A became a hosted project of the Agentic AI Foundation in August 2026.
Is the A2A protocol open source?
- Yes. The A2A specification, its Protocol Buffers definition, and official SDKs are developed in public under the a2aproject GitHub organization, and the project is governed under the Linux Foundation as a hosted project of the Agentic AI Foundation. The main A2A repository is licensed under Apache 2.0, so anyone can implement a client or server.
Does A2A use gRPC?
- A2A supports gRPC as one of three standard protocol bindings in version 1.0, alongside JSON-RPC 2.0 and HTTP+JSON (REST). All bindings must provide equivalent behavior, and an agent lists the bindings it supports, with a URL for each, in the supportedInterfaces field of its Agent Card. The normative data model is a Protocol Buffers file.
Terms in this guide
Cite this guide
The AI Engineering Editors. "A2A protocol vs MCP: differences and when to use each." The AI Engineering, updated Nov 11, 2026. https://theaiengineering.com/articles/a2a-vs-mcp
- Title
- A2A protocol vs MCP: differences and when to use each
- Author
- The AI Engineering Editors
- Publisher
- The AI Engineering
- Published
- Updated