Developers are drowning in protocol acronyms. MCP. A2A. ACP. AG-UI. UTCP. The Register literally titled a piece "Deciphering the alphabet soup of agentic AI protocols." The confusion is justified --- there are too many names for what turns out to be a surprisingly simple stack.
Here's the short version: MCP connects agents to tools. A2A connects agents to other agents. ACP merged into A2A. That's the stack. Two protocols, two layers, done.
Now here's the long version, with enough detail to actually build on.
Key Takeaways
- MCP (Anthropic) = agent-to-tool. A2A (Google) = agent-to-agent. They solve different problems and are designed to work together.
- ACP (IBM) merged into A2A in September 2025. If you were tracking ACP, follow A2A now.
- MCP has 97M+ monthly SDK downloads and 10,000+ servers. A2A has 150+ enterprise partners. Both are under the Linux Foundation.
- NIST launched an AI Agent Standards Initiative in February 2026 --- compliance frameworks are coming.
- For most developers today, MCP is the protocol that matters immediately. A2A matters when you're building multi-agent systems.
Short Answer
Which protocol should I use? If your agent needs to access tools, databases, or APIs: MCP. If you're building a system where multiple agents delegate work to each other: A2A. If you're building a real multi-agent system with tool access: both. If you were considering ACP: it merged into A2A, follow A2A instead.
MCP: Agent-to-Tool
Creator: Anthropic (November 2024) Governance: Agentic AI Foundation (AAIF) under the Linux Foundation (December 2025), co-founded by Anthropic, OpenAI, and Block Current version: Protocol v2026-03-26
MCP gives AI agents a standard way to connect to external tools and data sources. Before MCP, every AI platform needed custom integrations for every tool. MCP collapses that to one protocol.
How it works: An MCP server exposes tools, resources, and prompts over JSON-RPC 2.0. The AI host (Claude, Cursor, Copilot) connects to the server and discovers what's available. The AI model decides when to call tools. Communication happens over stdio (local) or Streamable HTTP (remote).
Adoption (March 2026):
- 97M+ monthly SDK downloads (Python + TypeScript)
- 10,000+ active MCP servers
- Natively supported by Claude, ChatGPT, Gemini, Microsoft Copilot, GitHub Copilot, Cursor, Windsurf, VS Code, Zed
- Server support from Slack, GitHub, Google, Salesforce, Stripe, Shopify, Notion, Linear, Sentry, Figma, and hundreds more
2026 roadmap priorities: Transport scalability, enterprise readiness (audit trails, SSO), and agent communication patterns. Discovery is increasingly handled by registries like OpenBooklet, where servers are indexed alongside skills and workflows with safety scans and publisher trust signals.
For a deeper dive on MCP, see our post on MCP Explained: The USB-C of AI Agents.
A2A: Agent-to-Agent
Creator: Google (April 2025) Governance: LF AI & Data under the Linux Foundation Current version: v0.3 (July 2025)
A2A lets AI agents discover, communicate with, and delegate tasks to other agents. If MCP gives your agent hands (tools), A2A gives your agent colleagues.
How it works: Each agent publishes an Agent Card --- a JSON document at /.well-known/agent-card.json that describes its identity, capabilities, skills, endpoint, and auth requirements. Think of it as a business card for AI agents. When an agent needs help with something outside its expertise, it discovers a capable agent via its Agent Card and delegates a task.
Key concepts:
| Concept | What It Does |
|---|---|
| Agent Cards | JSON metadata describing agent identity, capabilities, and endpoint |
| Task Lifecycle | Defined states: submitted → working → input-required → completed / failed / canceled |
| Opaque Agents | Agents don't expose internals. They're black boxes that communicate through the protocol |
| Transport | JSON-RPC 2.0 over HTTPS. Supports sync, streaming (SSE), and async push notifications |
| Security | HTTPS with TLS 1.2+, RBAC, OAuth2/Bearer auth |
Adoption: 150+ enterprise partners including Google, Atlassian, Box, Cohere, Intuit, LangChain, MongoDB, PayPal, Salesforce, SAP, ServiceNow, Workday, plus consulting firms (Accenture, Deloitte, McKinsey, PwC).
ACP: The Protocol That Merged
Creator: IBM Research (May 2025), powering the BeeAI platform Status: Merged into A2A (September 2025)
ACP (Agent Communication Protocol) was IBM's answer to agent-to-agent communication. It was REST-first, developer-friendly, and simpler than A2A. Key innovations included:
- Pure REST over HTTP --- no JSON-RPC ceremony, no specialized SDKs needed
- Multimodal messages --- text, images, embeddings in MIME-typed multipart content from day one
- Offline discovery --- agents could embed metadata into distribution packages for scale-to-zero environments
- Capability tokens --- signed, unforgeable objects encoding resource type, operations, and expiry
Why it merged: ACP was technically simpler but A2A had enterprise muscle (Google backing, 150+ partners). Rather than fragment the ecosystem, IBM made the pragmatic call: fold ACP's innovations into A2A and join the Technical Steering Committee. The best of both worlds.
What this means for you: If you were building on ACP, migrate to A2A. The ACP team published migration guidance, and ACP's core innovations (REST patterns, multimodal messaging, offline discovery) are being incorporated into A2A.
The ACP-A2A merger was widely seen as a sign of ecosystem maturity. Consolidation instead of fragmentation. Two years ago, this would have been a standards war. In 2025, it was a merge.
Head-to-Head Comparison
| Dimension | MCP | A2A | ACP (merged into A2A) |
|---|---|---|---|
| Purpose | Agent-to-tool | Agent-to-agent | Agent-to-agent (simpler) |
| Creator | Anthropic | IBM Research | |
| Announced | November 2024 | April 2025 | May 2025 |
| Transport | JSON-RPC over stdio / Streamable HTTP | JSON-RPC over HTTPS, gRPC (v0.3+) | REST over HTTP, SSE |
| Discovery | .well-known metadata (2026 roadmap) |
Agent Cards at /.well-known/agent-card.json |
Auto-indexed manifests |
| Auth | OAuth 2.1 | OAuth2, Bearer, RBAC, TLS 1.2+ | Capability tokens |
| Adoption | 97M+ monthly downloads, 10K+ servers | 150+ enterprise partners | Merged September 2025 |
| Maturity | Production-stable | v0.3 | Wound down |
| Governance | Linux Foundation (AAIF) | Linux Foundation (LF AI & Data) | Folded into A2A |
How They Work Together
These are layers in a stack, not competitors:
[User / UI Layer]
|
[Agent-to-Agent] ← A2A (discovery, delegation, collaboration)
|
[Agent-to-Tool] ← MCP (tool access, data retrieval, API calls)
|
[External Systems] ← Databases, APIs, files, services
Real-world example: A customer service system where:
- A router agent receives a customer billing question
- Via A2A, it discovers a billing agent (the billing agent's Agent Card advertises billing capabilities)
- Via A2A, it delegates the task to the billing agent
- The billing agent uses MCP to query the billing database, fetch the customer's invoice, and process a refund through Stripe's MCP server
- Via A2A, the billing agent returns results to the router agent
- The router agent responds to the customer
A2A handles the delegation. MCP handles the tool access. Each layer does one thing well.
People are calling this "the TCP/IP moment for agentic AI" --- distinct protocol layers that compose into a full communication stack. Whether that comparison holds up remains to be seen, but the layered architecture is real and practical.
The NIST Factor
On February 17, 2026, NIST announced the AI Agent Standards Initiative with three pillars:
- Industry-led protocol standards --- NIST is not creating competing standards. They're incorporating MCP, A2A, OWASP Top 10 for LLMs, and IEEE P2894 into a unified evaluation and certification system.
- Agent security and identity research --- RFIs on agent security (deadline March 2026) and agent identity concepts.
- Cross-departmental regulatory coordination --- Aligning federal agencies on agent governance.
What this means: NIST compliance frameworks will appear in vendor questionnaires and enterprise procurement requirements by 2027. If you're building agent systems for enterprise customers, track this.
Standards bodies move slowly, but when they publish requirements, procurement teams enforce them quickly. The time to build standards-compliant agent systems is now --- not after the requirements are finalized.
What You Should Do
If you're building a single agent with tool access
Use MCP only. Connect your agent to the tools it needs. A2A is not relevant until you have multiple agents that need to collaborate.
If you're building a multi-agent system
Use both MCP and A2A. A2A for agent discovery and task delegation. MCP for each agent's connection to its tools.
If you're evaluating protocols for your organization
MCP is production-stable and universally adopted. A2A is enterprise-ready but earlier in its adoption curve (v0.3). Both are under the Linux Foundation. Both are open standards. Betting on either is safe.
If you were using ACP
Migrate to A2A. The ACP team has joined A2A's governance, and ACP's innovations are being incorporated into A2A's roadmap.
FAQ
Are MCP and A2A competing?
No. MCP is agent-to-tool (vertical). A2A is agent-to-agent (horizontal). Google explicitly positioned A2A as complementary to MCP and announced MCP support alongside A2A's launch.
Do I need A2A if I'm using Claude Code?
Probably not yet. Claude Code uses MCP for tool access and handles multi-step tasks within a single agent. A2A becomes relevant when you're building systems where distinct, independently-deployed agents need to discover and delegate to each other.
Is MCP going to be replaced?
Unlikely. It has 97M+ monthly downloads, support from every major AI lab, and governance under the Linux Foundation. The 2026 roadmap focuses on scaling and enterprise features, not fundamental changes.
What about all the other protocols (AG-UI, UTCP, ANP)?
The "alphabet soup" is real, but the core stack is consolidating around MCP + A2A. Other protocols address narrower problems (AG-UI for agent-to-UI communication, for example). For most developers, MCP and A2A are the two protocols worth learning.
Will enterprise compliance require specific protocols?
NIST's AI Agent Standards Initiative suggests yes, eventually. Compliance frameworks incorporating MCP and A2A are expected by 2027. Building on these open standards now puts you ahead of the curve.
Key Takeaways
- MCP = tools, A2A = agents --- they solve different problems and are designed as complementary layers
- ACP merged into A2A --- the ecosystem is consolidating, not fragmenting
- MCP has won the developer mindshare war --- 97M monthly downloads, universal AI lab support
- A2A has enterprise backing --- 150+ partners, but hands-on developer adoption is earlier stage
- Start with MCP --- it's what you need today. Add A2A when you genuinely need multi-agent collaboration.
Further reading: MCP Explained: The USB-C of AI Agents | The AI Agent Security Crisis Nobody's Talking About