If you’ve been reading about AI agents lately, you’ve hit two acronyms that sound like they do the same thing: MCP and A2A. Both are open standards. Both are about agents. Both are backed by the same big companies. So which is which?
The short answer: they connect different things.
The one-line version
- MCP connects an agent to its tools — your files, a database, GitHub, Slack, your calendar.
- A2A connects an agent to other agents — so they can find each other and split up work.
If MCP is how one worker reaches their toolbox, A2A is how two workers talk to each other and divide the job.
MCP — the tool protocol
MCP (Model Context Protocol) is an open standard from Anthropic that lets an AI agent plug into external services. It’s like a USB port for AI: connect a server and the agent gains a new ability — read a Notion page, query a database, check a Sentry error.
In Claude Code you add one with a single command:
claude mcp add --transport http notion https://mcp.notion.com/mcpFrom then on, Claude can use that tool directly instead of you copy-pasting data back and forth. MCP is about one agent reaching outward to the things it needs to do its job.
It’s the more established of the two — by 2026 it had crossed tens of millions of monthly downloads and was adopted by every major AI provider.
A2A — the agent-to-agent protocol
A2A (Agent-to-Agent) is an open standard, originally from Google, for letting separate agents communicate. Think of it as HTTP for agents: a common language so an agent built by one company can discover, message, and delegate to an agent built by another.
The pieces are simple:
- Agent Card — a machine-readable description each agent publishes: what it can do, what inputs it takes, how to authenticate. This is how agents find each other.
- Tasks — units of work handed from one agent to another, with a defined lifecycle (submitted → working → input-required → completed / failed).
A2A is about agents reaching sideways to each other — coordinating, not just using tools.
Side by side
| MCP | A2A | |
|---|---|---|
| Connects | An agent → its tools & data | An agent → other agents |
| Analogy | A USB port for AI | HTTP for agents |
| Question it answers | ”How does Claude use my database?" | "How do two agents split a job?” |
| Origin | Anthropic (2024) | Google (2025) |
| You meet it as | claude mcp add ... | Agent Cards, delegated tasks |
| In Claude Code | Core, everyday | Mostly behind the scenes |
How they work together
They’re not rivals — they’re two layers of the same stack. In a real multi-agent system:
- Each agent uses MCP to reach its own tools and data.
- The agents use A2A to find one another and hand off tasks.
Picture a research assistant agent that needs financial data. It uses A2A to discover a specialist finance agent and delegate the lookup; that finance agent then uses MCP to query the actual database. One protocol for reaching tools, one for reaching agents.
In late 2025 the Linux Foundation created the Agentic AI Foundation as the shared home for both — co-founded by Anthropic, Google, OpenAI, Microsoft, AWS and others. The signal is clear: the industry expects you to use both, not pick one.
Which one do you need?
If you’re using Claude Code today, you need MCP. It’s how you give Claude access to your tools, and it’s a few commands to set up. When Claude spins up subagents or an Agent Team, it coordinates them internally — you don’t wire that up yourself.
A2A matters when you’re building systems, especially ones that stitch together agents from different vendors. If that’s not you yet, it’s enough to know the word and what it’s for — it’s the standard that turns “one clever agent” into “a marketplace of agents that can call each other.”
For most people, the practical takeaway is small and useful: MCP is the one you’ll actually configure; A2A is the one making “teams of agents” possible underneath.