The official narrative about agent interoperability protocols goes like this: MCP handles tool calling, A2A handles agent-to-agent communication, AGNTCY handles enterprise orchestration. Three layers, three lanes, everybody wins. This story has been repeated at every joint announcement since 2025.
It is also wrong.
If you have shipped a multi-agent system into production, you already know: these three protocols are not dividing a pie. They are fighting over the same control point. Whoever defines the standard way an agent calls another endpoint owns the entry point to next-generation infrastructure.
My thesis: the “layered coexistence” framing is a transitional fiction. Agent interoperability protocols will converge, and the convergence point is not technical elegance. It is who scales first.
What Each Protocol Actually Is (Not What the Docs Say)
Line up the official descriptions of MCP, A2A, and AGNTCY and you would think they exist on different planets. Crack open the actual semantics and deployment patterns, and the boundaries blur fast.
MCP (Model Context Protocol) shipped from Anthropic in November 2024. The surface pitch: “a standard interface for models to connect to tools and data sources.” The real architecture is LSP (Language Server Protocol) adapted for LLMs. A universal client-server protocol over JSON-RPC where tool providers expose servers and model platforms act as clients.
The killer feature is not technical sophistication. It is that Anthropic gave up commercial control from day one. Open source, complete documentation, SDKs for Python/TypeScript/Go/Rust, and a community that built thousands of servers within three months. By late 2025, OpenAI, Google, and Microsoft all announced MCP compatibility. Not because they wanted to. Because developers refused to write the same GitHub integration five times for five platforms.
A2A (Agent2Agent) landed at Google Cloud Next in April 2025, positioned as “a communication protocol between agents.” It runs on HTTP + JSON-RPC + SSE, introduces Agent Cards for capability declaration, and uses a Task primitive for async state management. Google donated it to the Linux Foundation with 50+ company signatories.
The awkward truth about A2A: the problem it solves is not particularly pressing in 2026 production workloads. The vast majority of production agent systems are hierarchical (“one orchestrator calling a bunch of tools and sub-agents”), not mesh-shaped (“multiple peer agents negotiating with each other”). The hierarchical pattern works fine with MCP plus a sub-agent server layer. No Task state machine required.
AGNTCY is Cisco’s brainchild, co-founded with LangChain, Galileo, Glean, Outshift, and a dozen others in March 2025. Its ambition is the largest: identity (Agent ID), discovery (Agent Directory), messaging (SLIM), observability, trust evaluation. Full stack governance for agents.
AGNTCY’s problem is the inverse of A2A’s. It tries to invent “DNS + BGP + IAM” for the agent era in a single shot. Meanwhile, most developers in 2026 are still solving basics like “how do I stop my MCP server from getting owned by prompt injection.” The AGNTCY design docs read like the OSI seven-layer model circa 1993: rigorous, comprehensive, and mostly disconnected from how things actually get deployed.
The Real Battlefield: Control Points
Plot these three protocols on a map and you see an uncomfortable fact: their boundaries are all expanding outward. The overlap zones are growing.
MCP 1.0 had three primitives: tools, resources, prompts. By late 2025, it added sampling (letting servers request model calls from clients) and elicitation (letting servers ask users for input). The 2026 Q1 draft introduced an agent primitive, meaning MCP can now directly express “one agent delegates a task to another agent.” This overlaps about 90% with A2A’s Task semantics.
A2A is eating in the other direction. Version 0.3 (November 2025) introduced Skills, which are essentially MCP tools with caller-side semantics bolted on. Google’s internal Vertex AI implementation wraps A2A around MCP. On the surface, agents talk to agents. Underneath, MCP moves the data.
AGNTCY swallows both. Its SLIM messaging layer supports A2A payload formats by default. Its directory service describes capabilities using MCP schema. In other words, AGNTCY’s moat is not a protocol. It is “I make other people’s protocols compliant.”
Under these conditions, “layered coexistence” is marketing. The real battle is over three control points:
- Who defines the capability declaration format (MCP’s tool schema vs. A2A’s Agent Card vs. AGNTCY’s OASF)
- Who defines identity and authorization semantics (MCP’s OAuth resource indicators vs. A2A’s enterprise auth vs. AGNTCY’s Agent ID)
- Who captures the marketplace entry point (Claude/ChatGPT connector stores, Vertex Agent Garden, AGNTCY Directory)
Control any one of these three and you turn the other two protocols into a “compatibility layer” inside your ecosystem.
Two Pain Points From Production Teams in 2026
Abstract protocol wars are irrelevant to people building real systems. These two complaints are the ones I hear most frequently from production teams, and they expose the true failure modes of agent interoperability.
Pain point 1: MCP server governance is out of control. A mid-size SaaS company deployed 230+ internal MCP servers early this year, covering Jira, Salesforce, internal data warehouses, and CI/CD pipelines. Six months later, a security audit found 18 servers with no parameter whitelisting, 3 servers running with default admin permissions, and 1 server where a developer had copy-pasted example code with a production database URI sitting in the metadata. MCP as a protocol says nothing about governance. It specifies how to call, not who may call or how to audit what happened after. Companies are forced to build their own layer: API gateway, policy engine, audit log, all custom. This is exactly where AGNTCY wants to insert itself, but AGNTCY’s approach is too heavy. Most companies end up adding a lightweight proxy (LiteLLM or Pomerium-style) in front of MCP and calling it done.
Pain point 2: Cross-vendor agent collaboration has no accountability model. A financial services client runs Claude (compliance analysis) and Gemini (data visualization) agents side by side. The requirement is simple: compliance agent finishes its analysis, hands results to the visualization agent for chart generation. A2A was designed for exactly this. In practice: the compliance agent fails, A2A’s task state sticks on “working,” the visualization agent has no signal on whether to retry or abort. Audit logs split across Anthropic and Google systems with no end-to-end trace. OAuth tokens passed between agents have no defined legitimate audience under A2A. This is not a protocol problem. It is an accountability problem. A2A assumes collaborating parties share a common trust root, but cross-vendor scenarios have no such thing. The client’s solution: wrap both agents in a custom orchestrator, expose only MCP externally, bypass A2A entirely.
Both pain points lead to the same conclusion: protocols solve the surface-level question of “can we connect?” The hard question is “who is responsible after we connect?” MCP thrives precisely because it only tackles the surface. A2A aims deeper but cannot enforce anything. AGNTCY wants to own governance end-to-end, but enterprises will not hand their entire agent stack to an open-source project that is not yet two years old.
Counterargument: “Cloud Vendors Will Just Win Anyway”
A common rebuttal: “This protocol debate is noise. AWS, Azure, and GCP will each set their own standards. Developers will use whatever protocol their cloud provides. Open-source protocols get marginalized.”
That logic held in the cloud-native era. It does not hold in the agent era, for three reasons.
First, the cost structure shifted. Cloud-native success was about “running stuff,” so whoever had cheaper IaaS or more managed services won. Agent-era success is about “connecting stuff.” A single agent needs 50 tools, 20 data sources, 5 other agents. Developers now hate per-platform integration work more than anything. MCP ate every platform in 12 months not because the protocol is brilliant, but because developers voted with their feet: no one is rewriting N integrations for a 0.5% GCP discount.
Second, cloud vendors already surrendered the protocol layer. Google donating A2A to the Linux Foundation was not generosity. It was capitulation. The Vertex AI team knew: if A2A stays proprietary, nobody adopts it. Microsoft announced native MCP support in Copilot Studio at Build 2025. AWS Bedrock followed in Q4 2025. When all three clouds refuse to go proprietary on protocols, the protocol war is no longer a cloud-vendor fight.
Third, the control point moved up. Even if cloud vendors lose the protocol layer, they can still win at the agent platform layer. But that is a different war. At the protocol layer, the winner is whichever open-source project achieves critical mass first, because developers will only accept one interface.
Open-source protocols cannot be marginalized by cloud vendors. The logic runs the other direction.
FAQ
Should I pick MCP, A2A, or AGNTCY for a new agent project in 2026?
Default to MCP. Unless you are explicitly building peer-to-peer agent negotiation (multi-agent auctions, multi-agent bargaining), skip A2A. Most of what A2A promises, you can accomplish with MCP plus a sub-agent pattern. Consider AGNTCY only if your company is already deep in the Cisco/Outshift ecosystem.
MCP has known security issues. Why is everyone still using it?
Because the alternatives are worse. MCP at least has OAuth 2.1 with resource indicators (added to the spec in June 2025) and official prompt injection mitigation guidance. A2A’s security model is essentially blank in cross-vendor scenarios. AGNTCY’s security framework remains in draft. MCP is not the most secure option. It is the most patched option, because it has taken the most hits.
Could Anthropic close-source MCP and seize control?
Technically impossible at this point. The spec lives on GitHub under MIT license. OpenAI, Microsoft, and Google all maintain their own forks and extensions. Anthropic’s current role resembles W3C governance: influence through reputation, not control. If Anthropic attempted privatization, the community would fork an “OpenMCP” the same day.
Does A2A have a future?
Yes, but not as a general agent communication protocol. A2A’s best survival path is its Agent Card design: a standardized capability declaration format. If the A2A team can separate Agent Card into its own standard and align it with MCP tool schema, it could persist as “robots.txt for agents.”
Will AGNTCY fail?
It will not fail outright. But it will not become what its founders envision. The most probable outcome: AGNTCY becomes a “packaging brand” for enterprise compliance. It gives procurement teams a checkbox and CISOs a signable report, while developers continue building on MCP underneath. That is not failure. That is the most dignified survival mode for a B2B infrastructure project.
Where This Ends
Agent interoperability will not be decided at the technical layer. It will be decided at the ecosystem scale layer. MCP won round one by doing the most important thing right: abandoning commercial ambition at the protocol level and focusing purely on scale. A2A arrived too late with too narrow a focus. AGNTCY arrived on time but overloaded with weight.
What happens in the next 18 months: MCP continues absorbing agent-to-agent semantics upward. A2A’s Agent Card either gets folded into MCP or spins off as an independent micro-standard. AGNTCY repositions itself as an “agent governance framework” rather than a protocol.
If you are making a technology choice today, ignore anyone telling you “layered coexistence.” That was 2025 marketing. In 2026, agent interoperability has one de facto winner: MCP. The other two will either be absorbed or survive as shadows of their original ambition.
Stay updated with our latest AI insights
