MCP connects an AI application to tools and data. A2A connects one agent to another so it can hand over a task. Most multi-agent systems need both, at different layers.
Google introduced the Agent2Agent protocol in April 2025; Anthropic had introduced the Model Context Protocol in November 2024. Both now sit under the Linux Foundation. This guide explains what each protocol carries, how a request flows through both, how they secure calls, and how to decide which one a connection needs.
Updated · 12 sources
In A2A vs MCP, the difference is who sits on the other end. MCP, the Model Context Protocol, connects an AI agent or assistant to tools, resources and prompts that a server exposes. A2A, the Agent2Agent protocol, connects one agent to another agent — which may plan, take hours and ask questions — through tasks with a tracked lifecycle. The A2A project describes them as complementary: A2A between agents, MCP inside each one.
Both can run as JSON over HTTP, and both describe what the other side can do. They differ in what that other side is: a function that does one thing when called, or a peer that takes on a goal.
A host connects to servers, discovers tools, resources and prompts, and the model calls tools as it works.
A client agent reads another agent’s Agent Card, sends it a message, and follows the task it creates until it finishes.
A2A treats the remote agent as a black box with a published description. The client never sees its prompts, tools or memory — only what it agrees to do and what comes back.
Fetch the Agent Card, usually at /.well-known/agent-card.json: skills, capabilities, sign-in methods.
Get credentials for a scheme the card declares and send them on every request.
Send a message of text, file or data parts; the agent answers directly or opens a task.
Poll, stream status over server-sent events, or receive push notifications at a webhook.
The task ends completed, failed, canceled or rejected; results arrive as artifacts.
{
"name": "Parts Supplier Agent",
"description":
"Quotes and orders parts",
"version": "2.1.0",
"supportedInterfaces": [{
"url":
"https://parts.example.com/a2a",
"protocolBinding": "JSONRPC",
"protocolVersion": "1.0"
}],
"capabilities": {
"streaming": true,
"pushNotifications": true
},
"defaultInputModes": ["text/plain"],
"defaultOutputModes": ["text/plain"],
"skills": [{
"id": "quote-part",
"name": "Quote a part",
"description":
"Price and lead time",
"tags": ["parts", "quotes"]
}],
"securitySchemes": { "...": "..." }
}Built for long work. Task states include input-required and auth-required, so a remote agent can stop and ask for what it needs rather than fail.
The A2A project explains the split with a car repair shop. Agents speak A2A to each other; each agent uses MCP to work its own equipment.
The rule of thumb. If the thing on the other end follows instructions, it is a tool: use MCP. If it decides how to reach a goal you gave it, it is an agent: use A2A. In the A2A project’s words, A2A connects the agents to each other, and MCP connects each agent to its own tools.
Each protocol began at a single company and moved to neutral governance within about a year. A third, IBM’s Agent Communication Protocol, merged into A2A.
Decide per connection rather than per system. Ask what is on the other end and who owns it.
What is on the other end of the call?
Both protocols carry identity in standard HTTP authentication rather than inventing their own. The new risk in both is the same: text from the other side can try to steer your model.
Botminds speaks MCP in both directions. Outside assistants and agents reach Botminds through its hosted MCP server, and Botminds agents reach other systems through outside MCP servers — each call under the same checks.
Go further. The design: MCP for the enterprise. How Botminds agents work together inside the platform: agent mesh. Signing in: MCP authentication.
In A2A vs MCP, MCP connects an AI agent to tools, resources and prompts on a server; A2A connects an agent to another agent, handing it a task that can run long, ask questions and return artifacts. They work at different layers and are often used together.
No. Google introduced A2A as complementary to MCP, and the A2A project still describes it that way: A2A between agents, MCP between an agent and its tools.
IBM’s Agent Communication Protocol merged into A2A in August 2025 under the Linux Foundation, and its team moved to contributing to A2A. The announcement promised migration paths for ACP users.
Neither; they answer different questions. If the other side is a tool or data source, use MCP. If it is an agent you delegate a goal to — especially one owned by another team or company — use A2A.
Both sit under the Linux Foundation. Google contributed A2A in June 2025; Anthropic donated MCP to the Agentic AI Foundation, a Linux Foundation fund co-founded with Block and OpenAI, in December 2025.
Identity is handled at the HTTP layer, not inside A2A messages. An Agent Card declares the schemes it accepts — API keys, HTTP authentication, OAuth 2.0, OpenID Connect or mutual TLS — and the client sends credentials on every request.
A JSON document an A2A server publishes, usually at /.well-known/agent-card.json, describing the agent’s identity, skills, capabilities such as streaming, and the authentication it requires. Version 1.0 added signed cards.
Often not. A single platform can coordinate its own agents directly. A2A earns its place when agents run on different stacks or belong to different organisations and must cooperate without exposing their internals.
Bring one process and its documents. We’ll show you the agents, the controls and the record, running on your data.