MCP vs A2A: Tools, Tasks and Agent Cards Compared
MCP vs A2A, from the specs: what each protocol connects, Agent Cards vs server cards, tasks in both, versioning on the wire, governance, and when to use both.
Cet article est en anglais.
TL;DR. MCP vs A2A comes down to what each protocol connects. The Model Context Protocol (current revision 2026-07-28) connects one AI application to a server that offers tools, resources and prompts. The Agent2Agent protocol (version 1.0) connects one agent to another agent, which runs a task on its behalf without showing how it works inside. The A2A project and the Linux Foundation describe the two as complementary, and since August 2026 both are hosted by the Agentic AI Foundation. If you are building an agent, you will probably use A2A to talk to other agents and MCP to give each agent its tools, and the MCP servers it can use are what mcp.tc lists.
What is MCP, and what is A2A?
MCP is a protocol between an AI application and a server that provides it with tools, resources and prompts; A2A is a protocol between two agents, where one asks the other to carry out a task. The MCP architecture page describes "a client-host-server architecture where each host can run multiple client instances" and says "Each client is created by the host and communicates with exactly one server." The A2A repository describes A2A as "an open protocol enabling communication and interoperability between opaque agentic applications."
The word "opaque" carries most of the difference. The A2A docs say "Agents collaborate without exposing their internal logic, memory, or proprietary tools" (What is A2A). In MCP the host sees the full conversation and every tool result; the servers behind it do not. One of MCP's stated design principles is that servers "should not be able to read the whole conversation, nor 'see into' other servers". So both protocols draw a privacy boundary, in different places. MCP draws it between the host and each server. A2A draws it between two agents, each of which can have its own MCP servers behind it.
The A2A project's own summary, from its A2A and MCP page: "MCP is vertical. It deepens a single agent." and "A2A is horizontal. It connects agents across that boundary." The same page: "A2A connects the agents to each other; MCP connects each agent to its own tools."
MCP vs A2A at a glance
The table below compares the two protocols on the points that matter when you set one up, using the 2026-07-28 MCP revision and the A2A 1.0 specification as of 15 November 2026. Each row is expanded in the sections that follow.
| MCP (2026-07-28) | A2A (1.0) | |
|---|---|---|
| Connects | a host's client to exactly one server | a client agent to a remote agent |
| Unit of work | a tools/call request and its result | a Task created by SendMessage |
| Discovery document | server card at <streamable-http-url>/server-card (optional extension, Beta) | Agent Card at /.well-known/agent-card.json (servers MUST publish one) |
| Live discovery | server/discover (servers MUST implement it) | GetExtendedAgentCard when the card declares extendedAgentCard |
| Wire format | JSON-RPC 2.0 over Streamable HTTP or stdio | JSON-RPC 2.0, gRPC or HTTP+JSON/REST; a2a.proto is the normative data model |
| Version signaling | _meta["io.modelcontextprotocol/protocolVersion"] on every request | A2A-Version HTTP header; versions identified by Major.Minor |
| Long-running work | Tasks extension io.modelcontextprotocol/tasks (Beta, headed to core) | tasks are the core unit, with eight states |
| Server-to-client push | subscriptions/listen stream | SSE via SendStreamingMessage; push notifications as HTTP POST webhooks |
| Governance | Agentic AI Foundation (hosted by the Linux Foundation) | Agentic AI Foundation hosted project since August 2026 |
What does each protocol put on the wire?
MCP sends JSON-RPC 2.0 requests such as tools/list and tools/call, each carrying its protocol version in _meta; A2A sends operations such as SendMessage and GetTask, with the protocol version in an A2A-Version header. The MCP tools page says tools are "model-controlled": the model decides when to call them, and the client is told there "SHOULD always be a human in the loop with the ability to deny tool invocations." A tool definition has a name, a description, an inputSchema (JSON Schema), and optionally title, icons, outputSchema and annotations. A call looks like this (the required _meta fields are omitted on the spec page for brevity):
{
"jsonrpc": "2.0",
"id": 2,
"method": "tools/call",
"params": {
"name": "get_weather",
"arguments": { "location": "New York" }
}
}The result carries resultType: "complete" and a content array. Since the 2026-07-28 revision there is no initialize handshake and no session header; the changelog says "Every request now carries its protocol version and client capabilities in _meta", and tools/list results carry ttlMs and cacheScope so a client knows how long it may cache them. Our stateless migration guide walks through those changes for server authors.
A2A's specification defines the data model in Protocol Buffers and offers three bindings: JSON-RPC, gRPC and HTTP+JSON/REST. A Message is "one unit of communication between client and server" and is made of Part objects, each holding text, raw bytes, a URL or structured data. The client agent sends a SendMessage; the remote agent answers with a Message or a Task. Version 1.0 renamed the JSON-RPC operations, so message/send became SendMessage and tasks/get became GetTask (What's new in v1.0). The same release removed the kind discriminator from Part and made a2a.proto "the universal, normative source of truth". The full operation list is SendMessage, SendStreamingMessage, GetTask, ListTasks, CancelTask, SubscribeToTask, GetExtendedAgentCard, plus create, get, list and delete operations for push notification configs.
A plain reading: an MCP tool call is a function call with a schema. An A2A message is a request to a colleague, who may answer, ask a question back, or tell you it will take a while.
Agent Cards vs server cards: how discovery works
An A2A Agent Card is a required JSON document at /.well-known/agent-card.json that lists an agent's skills; an MCP server card is an optional JSON document, recommended at <streamable-http-url>/server-card, that lists where to connect and deliberately omits the server's tools. The A2A spec says "A2A Servers MUST make an Agent Card available." The card's required fields are name, description, version, supportedInterfaces (an ordered list, "The first entry is preferred", each with a url and the A2A protocolVersion it speaks), skills and capabilities (streaming, pushNotifications, extensions, extendedAgentCard). securitySchemes and provider are optional. The agent discovery page lists three ways a client finds a card: the well-known URI, a curated registry (the page says the current A2A specification does not prescribe a standard API for curated registries), or direct configuration. It also says "The A2A specification strongly recommends the use of out-of-band dynamic credentials rather than embedding static secrets within the Agent Card." Version 1.0 added "Agent Card signature verification using JWS and JSON Canonicalization".
MCP's equivalent is the server card from SEP-2127, which reached Final status; the extensions overview lists the Server Cards extension at Beta. A card describes a remote server's identity (name, version, description, and optional title, icons, repository, websiteUrl), its transport endpoints and the protocol versions it supports. An AI Catalog at /.well-known/ai-catalog.json can link to several cards on one domain. The SEP is explicit that cards leave out tools, resources and prompts: "MCP servers are inherently dynamic: the primitives a server exposes can vary by authenticated user, session, configuration, feature flags, deployment state, and more." Clients learn the tools from a live tools/list, and if a card and server/discover disagree, "clients SHOULD prefer the live server/discover values." We covered the file formats in MCP server cards and discovery.
That is the sharpest structural difference between the two documents. An Agent Card advertises what the agent can do (skills) before you talk to it. A server card tells you where the server is and which protocol versions it speaks; what it can do is answered by the server itself, per request, and may depend on who is asking.
mcp.tc builds each listing from public data: a live MCP handshake and the tool list the server shows without sign-in, plus the server card, the official MCP Registry and the package registries where they exist. A listing page shows the tools mcp.tc read, whether the server asks for sign-in, and setup steps for each client.
Tasks: where the two protocols now overlap
Both protocols model long-running work as a task with an identifier, a polled status, and a state that pauses for input, which is new on the MCP side as of 2026-07-28. In A2A, the spec says "Task is the core unit of action for A2A." Its states are SUBMITTED, WORKING, COMPLETED, FAILED, CANCELED, INPUT_REQUIRED, REJECTED and AUTH_REQUIRED; COMPLETED, FAILED, CANCELED and REJECTED are terminal, and INPUT_REQUIRED and AUTH_REQUIRED are "interrupted" states. Streaming requires capabilities.streaming in the Agent Card and delivers task, message, statusUpdate or artifactUpdate events over SSE. Push notifications require capabilities.pushNotifications and are HTTP POST requests "to client-registered endpoints when task state changes."
In MCP, the 2026-07-28 changelog moved "experimental tasks out of the core protocol and into an official extension (io.modelcontextprotocol/tasks)". The Tasks extension page describes the flow: a client declares the extension in its per-request capabilities, and when a request will take long, the server returns a CreateTaskResult (resultType: "task") with a taskId, a TTL and a pollIntervalMs. The client polls tasks/get, answers input_required through tasks/update, and may send tasks/cancel, where "Cancellation is cooperative". The states are working, input_required, completed, failed and cancelled, with the last three terminal. Servers that support subscriptions/listen can push notifications/tasks instead of being polled. The extension is at stage "Beta, to Core", and the page notes "Host support varies by client."
The MCP roadmap, last updated 2026-08-22, lists "Agentic Messaging Primitives" as its first priority area, including "Channels and subscriptions for push delivery, including webhooks" and continued work on Tasks "toward eventual inclusion of the extension in the core protocol." So the two task models are converging in shape. The difference that remains is what a task wraps: in A2A a task is the whole exchange with a remote agent, while in MCP a task is a handle for a single tools/call that would otherwise have returned synchronously.
When do you use MCP, A2A or both?
Use MCP when an application needs to call something with a defined interface, use A2A when it needs to hand work to another agent that keeps its own reasoning and tools private, and use both when the remote agent itself relies on tools. The A2A docs say it plainly: "Use both together. A2A handles inter-agent collaboration and MCP handles tool integration." The same page distinguishes "A2A is about agents partnering on tasks; MCP is more about agents using capabilities", and notes an A2A server "can expose some skills as MCP-compatible resources". The spec's appendix on MCP describes the combined case: an A2A server agent may use MCP to reach tools, APIs or data sources while it fulfils a task that an A2A client agent requested.
A few concrete rules of thumb that follow from the specifications:
- Your code calls an API, a database or a file system: that is a tool with a schema, so MCP.
- Your agent needs another team's agent to do something and that team will not expose its internals: A2A.
- Your agent is an A2A server and does its own work with tools: it is also an MCP host, with one MCP client per server behind it.
- Several agents need the same tool: give each its own MCP connection. The MCP architecture page keeps clients 1:1 with servers and leaves cross-server coordination to the host.
Identity is the open edge for unattended agents. The MCP roadmap's third priority area, "Agent Identity and Enterprise-Ready Security", covers DPoP and "Agent identity and delegation" so that an agent can reach an MCP server "through their own identity or a user-delegated identity." Today, the roadmap says, "MCP authorization assumes a person with a browser at consent time"; our MCP authorization guide shows that flow. For an agent that runs without a person present, servers that work without sign-in are the simplest to wire up. On 15 November 2026, 403 of the 1,182 remote servers listed on mcp.tc list their tools without sign-in, and the directory has a filter for them.
Who governs MCP and A2A?
Both protocols are now projects of the Agentic AI Foundation, which the Linux Foundation hosts. The Linux Foundation announced the Agent2Agent Protocol project on June 23, 2025, describing A2A as "an open protocol created by Google for secure agent-to-agent communication and collaboration" with "more than 100" supporting companies. A follow-up press release on April 9, 2026 put the count at "more than 150 organizations", called version 1.0 the first stable specification, and described A2A as "complementary to the Model Context Protocol (MCP)."
On 2026-08-17 the AAIF blog wrote that A2A "is joining the Agentic AI Foundation (AAIF) as a hosted project", alongside AGENTS.md, goose, MCP and agentgateway, each covering a different layer of what it calls the open agentic stack. The A2A project's own announcements followed on August 27, 2026, saying A2A had "officially been accepted as a Growth Stage project at the Agentic AI Foundation (AAIF)", and on October 1, 2026 introduced an official A2A command-line client. The A2A specification is licensed under Apache 2.0.
On the MCP side, the specification advances through SEPs and Working Groups, and the extensions overview describes a three-stage lifecycle (Experimental, Beta, Stable) with the rule that "Extensions are always disabled by default and require explicit opt-in from the developer, at every stage." The roadmap names an Agents Interest Group among the groups reviewing how Tasks and other primitives compose.
What you can do next on mcp.tc
An agent that speaks A2A still needs MCP servers behind it, and mcp.tc is a free directory of 1,514 public MCP servers on 15 November 2026 (1,182 remote, 332 local). Search the directory by category or filter to servers that need no sign-in. Every listing shows the tools mcp.tc read, whether sign-in is needed, and setup steps for Claude Code, claude.ai, Claude Desktop, ChatGPT, Cursor, VS Code, Devin Desktop, Codex, Gemini CLI and a generic JSON config, each pointing at the server's own URL or package.
If your agent already speaks MCP, it can search the directory itself: mcp.tc's own MCP server at https://mcp.tc/mcp is read-only, needs no sign-in, and offers search_servers, get_server and list_categories. From a terminal, npx mcp-tc (Node.js 20 or later) searches the directory and adds a server to a client with the vendor's own URL or package; see the mcp-tc CLI page.
Autonomous agents cannot review a tool list the way a person skimming a prompt would, so it helps to know when a server's tools change. Every 3 hours mcp.tc reads the tool list of each listed server whose tools it can read without signing in (533 listings on 15 November 2026) and records added or removed tools, changed descriptions and schemas, and new versions on the listing's History tab; the newest changes across the directory are at mcp.tc/changes. Sign in and press Follow on a listing to get those changes by email. The change history docs explain the two-reads rule and what the checks cannot see: tools shown only after sign-in, and local servers without a manifest. And if the MCP server behind your agent is public and not listed yet, suggest it.
FAQ
Is A2A a replacement for MCP?
No. The two protocols connect different things. MCP connects an AI application to a server that offers tools, resources and prompts; A2A connects one agent to another agent that runs a task on its behalf. The A2A project's own documentation says "Use both together. A2A handles inter-agent collaboration and MCP handles tool integration", and the Linux Foundation's April 2026 release calls A2A "complementary to the Model Context Protocol (MCP)." Since August 2026 both are hosted by the Agentic AI Foundation.
Can an MCP server also be an A2A agent?
The same service can speak both protocols on different endpoints, but the roles differ. An MCP server answers tools/list and tools/call with schema-defined functions. An A2A server publishes an Agent Card at /.well-known/agent-card.json, accepts SendMessage, and manages tasks that may ask for more input. The A2A docs note an A2A server "can expose some skills as MCP-compatible resources", and describe A2A as agents "partnering" on tasks while MCP is agents "using" capabilities.
Does MCP have tasks like A2A?
Yes, as an extension. The 2026-07-28 MCP revision moved tasks into the io.modelcontextprotocol/tasks extension, currently at Beta and headed for the core specification. A server returns a CreateTaskResult with a taskId, the client polls tasks/get, answers input_required with tasks/update, and can send tasks/cancel. A2A has tasks in its core, with eight states including INPUT_REQUIRED and AUTH_REQUIRED, and adds streaming over SSE and webhook push notifications.
What is the difference between an Agent Card and an MCP server card?
An A2A Agent Card is required, lives at /.well-known/agent-card.json, and lists the agent's skills, supportedInterfaces, capabilities and security schemes, so a client knows what the agent can do before contacting it. An MCP server card is optional, recommended at <streamable-http-url>/server-card, and lists identity, endpoints and supported protocol versions only. It intentionally omits tools, because a server's tools can depend on who is signed in; clients fetch them live with tools/list.
How does an agent find MCP servers without a person choosing them?
An agent that speaks MCP can search a directory through MCP itself. mcp.tc runs a read-only MCP server at https://mcp.tc/mcp with search_servers, get_server and list_categories, no sign-in required, and an MCP-registry-compatible API at https://mcp.tc/v0.1/servers. Each result points at the server's own URL or package, so the agent connects straight to the server. On 15 November 2026 the directory held 1,514 listings, 403 of them remote servers that list tools without sign-in.
Who maintains MCP and A2A?
Both are projects of the Agentic AI Foundation, which the Linux Foundation hosts. Google created A2A and donated it to the Linux Foundation, which launched the A2A project on June 23, 2025; A2A became an AAIF hosted project in August 2026 and is licensed under Apache 2.0. MCP's specification is developed through SEPs, Working Groups and Interest Groups, with a published roadmap (last updated 2026-08-22) and a three-stage lifecycle for extensions.
Sources
- github.com/a2aproject/A2A
- modelcontextprotocol.io/specification/2026-07-28/changelog
- modelcontextprotocol.io/specification/2026-07-28/architecture
- modelcontextprotocol.io/specification/2026-07-28/server/tools
- modelcontextprotocol.io/specification/2026-07-28/server/discover
- modelcontextprotocol.io/extensions/tasks/overview
- modelcontextprotocol.io/extensions/overview
- modelcontextprotocol.io/seps/2127-mcp-server-cards
- modelcontextprotocol.io/development/roadmap
- www.linuxfoundation.org/press/linux-foundation-launches-the-agent2agent-protocol-project-to-enable-secure-intelligent-communication-between-ai-agents
- www.linuxfoundation.org/press/a2a-protocol-surpasses-150-organizations-lands-in-major-cloud-platforms-and-sees-enterprise-production-use-in-first-year