A year ago, if you asked "MCP or A2A?" you'd start a fight. Developers picked sides. Conference talks debated it. Hacker News threads ran hundreds of comments. Anthropic's Model Context Protocol had first-mover advantage and developer mindshare. Google's Agent-to-Agent protocol had enterprise backing and a broader vision. Each had a competitor trying to solve the same problem differently.
That debate is over. The answer isn't one protocol. It's a stack.
Here's where things landed, why it matters, and what you should actually build on today.
The Numbers Don't Lie
In April 2026, A2A hit its one-year anniversary. The milestone numbers tell a clear story:
- 150+ supporting organizations — triple the launch count, including Adobe, Microsoft, SAP, ServiceNow, Salesforce, and PayPal
- 22,000+ GitHub stars on the core A2A repository
- Production-ready SDKs in five languages: Python, JavaScript, Java, Go, and .NET
- Native cloud integration across Azure AI Foundry, Amazon Bedrock, and Google Vertex AI
- v1.0 specification shipped with signed Agent Cards, enterprise multi-tenancy, and formal streaming support
MCP, meanwhile, crossed 200 server implementations. Anthropic's Claude Agent SDK has the deepest MCP integration of any framework. The protocol is the de facto standard for connecting agents to tools and data sources.
And IBM's ACP — the third protocol nobody asked for but that had enterprise traction — quietly merged into A2A under the Linux Foundation in late 2025. The consolidation happened fast and with minimal drama. Three protocols became two, and the two don't compete — they complement.
Why the Stack Metaphor Works
Think of it like the HTTP/TCP/IP stack, because that's exactly what it is:
MCP is the tool layer. It connects an agent to resources — databases, APIs, file systems, internal services. When your agent needs to query Postgres, read a Slack channel, or search your codebase, it goes through an MCP server. The protocol handles capability discovery, authentication, and structured input/output. It's narrow, well-scoped, and solves one problem extremely well: giving agents access to the world outside their context window.
A2A is the agent layer. It handles communication between agents. When your research agent finishes gathering data and needs to hand off to a code generation agent, which then needs to send results to a review agent — that orchestration happens over A2A. It handles task delegation, capability negotiation, status updates, and result streaming across organizational boundaries.
These aren't competing for the same job. They're layers in a stack. Your agent uses MCP to access tools, and A2A to talk to other agents. The "MCP or A2A" debate was like arguing "TCP or IP?" — the answer is both, at different layers, because they solve different problems.
The Governance Story That Matters
Here's something most commentary misses: neither protocol is owned by its creator anymore.
In December 2025, Anthropic, Block, and OpenAI co-founded the Agentic AI Foundation under the Linux Foundation umbrella. Google contributed A2A to the same foundation. Anthropic contributed MCP. Both now live under multi-vendor governance with defined specification processes.
This is a big deal for enterprise adoption. A protocol owned by Google is a procurement risk. A protocol governed by the Linux Foundation with Anthropic, OpenAI, Google, Microsoft, and SAP on the steering committee is infrastructure. The same calculation that made Linux safe for enterprise — no single vendor can unilaterally change it — applies here.
The governance structure also explains why ACP merged into A2A rather than continuing independently. Three competing agent communication protocols under three different governance structures would have fragmented the market for years. Consolidation under one foundation with one agent-to-agent protocol and one tool-to-agent protocol gives enterprises exactly two things to evaluate instead of a fragmented landscape of five.
What v1.0 Actually Changed
The A2A v1.0 spec wasn't just a version bump. It addressed the specific blockers keeping enterprises in evaluation mode:
Signed Agent Cards
Every A2A-compliant agent publishes an Agent Card — a JSON metadata document describing its capabilities, endpoints, and authentication requirements. In v1.0, these gained cryptographic signing. Before this, there was no reliable way to verify agent identity before delegating tasks across organizational boundaries. After this, trust establishment happens before interaction begins, not after a credential exchange that could be spoofed.
If you're building multi-agent systems that cross team or company boundaries, this alone is worth the upgrade.
Enterprise Multi-Tenancy
Prior versions assumed a relatively flat agent topology. One agent, one environment. V1.0 formalized multi-tenancy support — the minimum viable feature for any organization running agents across multiple business units, each with different data access policies and compliance requirements.
Streaming Task Updates
Long-running agent tasks no longer require polling. V1.0 introduced server-sent events for real-time status updates, which matters when you're orchestrating agent chains that take minutes or hours to complete. Your orchestrator knows where every agent is in its task without hammering endpoints with status checks.
The Framework Gap That Remains
Here's where things aren't perfect. Native framework support for A2A remains uneven.
LangGraph — the most widely deployed open-source agent orchestration layer — still lacks a first-class A2A implementation. You can bridge it with adapters, but it's not native. CrewAI has gone all-in on both A2A and MCP, making it the easiest framework for multi-agent work across boundaries. Google's ADK ships with A2A support out of the box, naturally. Claude Agent SDK has the deepest MCP integration but no A2A. OpenAI's Agents SDK supports MCP but has been slow on A2A adoption.
The practical implication: if you're building multi-agent systems today, your framework choice still constrains your protocol options. CrewAI gives you both protocols with minimal friction. LangGraph locks you into adapter-based A2A. Provider-native SDKs give you deep integration with their creator's protocol and shallow support for the other.
This gap will close. The economic incentives are too strong — framework maintainers lose users when they don't support the standard protocols. But as of May 2026, it's still something you need to factor into architecture decisions.
What I'd Build On Today
If you're starting a new agent project this month, here's the pragmatic stack:
- MCP for all tool access. Don't build custom integrations. Wrap every external service in an MCP server. The 200+ existing server implementations cover most databases, APIs, and SaaS tools you'd need. If one doesn't exist, the spec is simple enough to implement in an afternoon.
- A2A for inter-agent communication. If your agents need to talk to each other — especially across services or organizational boundaries — use A2A v1.0. The signed Agent Cards and multi-tenancy support make it production-ready.
- CrewAI or LangGraph for orchestration. CrewAI if you need both protocols working out of the box. LangGraph if you're building complex stateful workflows and can tolerate adapter-based A2A for now.
- Provider-native SDKs for single-agent depth. If you're building a single coding agent that doesn't need to coordinate with others, the Claude Agent SDK or OpenAI Agents SDK give you deeper integration with their respective models. Just know you're trading multi-agent flexibility for single-agent capability.
Why This Matters for Harness Engineering
If you've read my earlier post on harness engineering, you know the thesis: the bottleneck in software development has moved from writing code to designing the environment in which code gets written. The protocol stack is a core piece of that environment.
When every agent in your system speaks MCP for tools and A2A for inter-agent communication, you've standardized the communication layer. That means your harness can focus on what's unique to your domain — constraints, context curation, verification — instead of reinventing how agents discover tools or hand off tasks.
The standardization also makes the Hashimoto principle more powerful. When an agent fails because it couldn't access the right tool, the fix goes into the MCP layer. When it fails because it misunderstood another agent's output, the fix goes into the A2A interaction contract. The protocol boundaries give you natural seams for debugging and improvement.
The agent protocol stack is one of the core topics covered in Harness Engineering: The Complete Guide to Agent-First Software Development — along with context engineering, multi-agent orchestration, and the practical architecture patterns that make agent-first development work at production scale.