MCP and A2A solve different problems. MCP (Model Context Protocol) connects one AI agent to the tools and data it needs, such as databases, APIs and files. A2A (Agent2Agent) lets separate agents, often built by different teams or vendors, find each other and hand off tasks. Most enterprise stacks need MCP first. Add A2A only when independent agents must work together.
The rest of this post explains what each protocol is for and where they overlap. It ends with a decision path based on the integration you're building, not on which protocol is being talked about most.
What problem do MCP and A2A each solve?#
MCP saves you from writing a custom connector for every model-to-system pair. A2A lets agents work together when none of them can see inside the others.
MCP. Anthropic open-sourced MCP in November 2024 as a standard for connecting AI assistants to the systems where data lives. The current specification uses JSON-RPC 2.0 messages between three parties:
- Hosts: AI applications
- Clients: connectors inside the host
- Servers: they expose three things: resources (data), prompts (templates) and tools (functions the model can run)
In December 2025, Anthropic donated MCP to the Agentic AI Foundation, which sits under the Linux Foundation. At that point Anthropic reported more than 10,000 active public MCP servers.
A2A. The A2A specification is an open standard for communication between "independent, potentially opaque AI agent systems." Google contributed it, and it is now an Apache-2.0 project under the Linux Foundation. Each A2A server publishes an Agent Card: a JSON document that lists the agent's identity, skills, endpoint and authentication requirements. In April 2026 the Linux Foundation reported more than 150 supporting organizations and a stable 1.0 specification.
How do MCP and A2A differ in what they connect?#
MCP connects an agent to a capability. A2A connects an agent to another agent that does its own reasoning.
| MCP | A2A | |
|---|---|---|
| Connects | Agent ↔ tools, data, prompts | Agent ↔ agent |
| What's on the other side | A server that runs a defined function | An agent whose internal logic you can't see |
| Discovery | Client asks the server what tools it has | Agent Card at /.well-known/agent-card.json |
| Unit of work | A tool call or a resource read | A task, with messages and artifacts |
| Interaction style | Request/response, with a stateless core as of 2026-07-28 | Built for asynchronous, long-running work |
| Transport | JSON-RPC 2.0 | JSON-RPC 2.0 over HTTPS, gRPC or HTTP+JSON in v1.0 |
| Governance | Agentic AI Foundation (Linux Foundation) | Linux Foundation |
In practice, two questions decide most cases. Does the counterpart reason for itself, or run a fixed function? And who owns it: your team or another organization?
Do MCP and A2A compete, or do they work at different layers?#
Mostly they work at different layers. A multi-agent system can use A2A to coordinate agents and MCP inside each agent to reach its tools.
Take a typical request. An orchestrator agent hands a task to a specialist agent over A2A. The specialist calls an MCP server, and that server calls the system of record.
The two protocols do overlap at the edges. You can wrap a sub-agent as an MCP tool. MCP has also added support for longer-running work: in the 2026-07-28 release, Tasks became an extension. So the real question isn't which protocol wins. It's whether the counterpart behaves like a tool or like a separate party.
When should an agent use MCP to reach tools and data?#
Use MCP whenever an agent needs to read data or take an action in a system that exposes defined operations, whether you built that system or a vendor did.
MCP is the right fit when:
- The counterpart is deterministic. Run a query, fetch a document, create a record.
- You want the model to choose between functions based on their descriptions, not follow hard-coded calls.
- Several AI applications need the same connector. Build the server once and connect any compliant host.
- Access depends on the user. Under the MCP authorization spec, a protected MCP server acts as an OAuth 2.1 resource server that accepts access tokens.
Common examples: an agent that reads a support ticket, checks order status in the database, looks up the refund policy and drafts a reply.
The protocol defines how a call is authorized. It doesn't decide what a tool should be allowed to do. That's a design decision. Our AI Agents & Automation practice builds agents that work across client systems with scoped permissions, a full audit trail and a person approving every risky action. Narrow, well-described tools also make agents easier to keep in line, which is why our APIs & Integrations work designs interfaces that both people and AI agents can call.
When does agent-to-agent messaging with A2A make sense?#
A2A makes sense when the other side is an agent you don't own or can't see into, and the work may take longer than a single call.
Look for these signals:
- Different owners or frameworks. Another business unit, a vendor or a partner built the agent, possibly on a different stack.
- Opaque execution. You want the agent's result, not its prompts, tools or data.
- Long-running or multi-step work. The task may need status updates, follow-up input or artifacts that arrive later.
- Runtime discovery. Clients read an Agent Card to learn an agent's skills and auth requirements, instead of hard-coding them.
- Verifiable identity. A2A 1.0 added Signed Agent Cards so you can cryptographically check an agent's identity.
Examples: a procurement agent asking a supplier's quoting agent for a price, or an internal orchestrator handing a review to a compliance agent that another team owns.
A2A is the wrong fit when all your agents live in one codebase, use one framework and have one owner. There, it adds network hops and another surface to authenticate and monitor, with little benefit.
How do you choose between MCP, A2A or both for an enterprise stack?#
Start from each integration, not from the protocol. Decide what sits on the other side of the call, then pick the lightest option that works.
In practice:
- List every integration the first agent needs, and note who owns each one.
- Use MCP for systems and data. For most teams this covers most of the work.
- Keep agents that share a team and runtime in-process. A framework's own orchestration is simpler than a network protocol.
- Use A2A at boundaries: where another team, vendor or partner owns the agent, or where tasks run long. The agent on the far side still uses MCP for its own tools.
- Revisit the choice when ownership changes. An internal agent exposed as an MCP tool today can move to A2A once another organization depends on it.
What should you verify before committing to either protocol?#
Check versions, identity, permissions, audit and release gates on a small working build before you standardize.
- Pin spec versions. MCP 2026-07-28 removed the session handshake and deprecated roots, sampling and logging, so servers built on older versions may need changes. A2A 1.0 moved Agent Card endpoint fields to a new
supportedInterfacesstructure. Confirm that your platforms and SDKs support the versions you plan to run. - Identity and auth. For MCP, check the OAuth 2.1 setup and token scopes. For A2A, check the security schemes each Agent Card declares and whether cards are signed.
- Least privilege per tool. Give read and write separate tools and separate scopes. Put human approval on anything irreversible.
- Audit trail. Log every tool call and every delegated task with the identity behind it, so you can rebuild what an agent did and why.
- Data clearance. Decide which data each agent may see before you connect it, not after.
- Evaluation and release gates. Treat MCP servers and agent integrations as production code, much of it now AI-written. Every change gets tests, security checks and senior review. Our guide to guardrails, approvals and audits for production AI agents covers each control in detail.
Conclusion#
MCP and A2A answer different questions. MCP covers how an agent reaches tools and data. A2A covers how independent agents work together. Most enterprise teams should build MCP servers for their core systems first, keep agents with one owner in-process, and bring in A2A where agents cross team, vendor or company lines. Whichever you choose, permissions, audit trails and release gates matter more than the wire format.
To test this on your own systems, we start with a paid pilot: one pod, one outcome, with success criteria agreed up front. Talk to an engineering lead →
Frequently asked questions
Is A2A a replacement for MCP?
No. A2A handles communication between agents. MCP handles how an agent reaches tools, data and prompts. In a system that uses both, each agent behind an A2A endpoint usually still uses MCP to reach its own systems.
Can we expose an agent as an MCP tool instead of using A2A?
Yes, and it's often simpler when one team owns both agents and calls are short. A2A starts to pay off when the agent belongs to another team, vendor or partner, runs long tasks, or must be discovered and authenticated as a separate party.
Who governs MCP and A2A?
Both are now under the Linux Foundation. Anthropic donated MCP to the Agentic AI Foundation, a directed fund under the Linux Foundation, in December 2025. Google contributed A2A, which is an Apache-2.0 project under the Linux Foundation.
Does MCP handle authentication and permissions for us?
Partly. The MCP authorization spec defines how a protected server accepts OAuth 2.1 access tokens. It doesn't decide which actions a tool should allow. You still need narrow scopes, separate read and write tools, human approval on risky actions, and an audit trail.
Do we need A2A if we only run one agent?
Usually not. A single agent that reads data and takes actions needs MCP, or direct APIs, plus good guardrails. Consider A2A when a second, separately owned agent has to take part in the workflow.
- MCP
- A2A
- AI agents
- agent protocols
- enterprise AI
- integration architecture
Newsletter
Get new articles by email
A short monthly round-up of what we've written on engineering pods, quality and AI. No spam.
