The Protocol Wars: MCP vs A2A vs Responses API

There's a war happening beneath the surface of every AI agent demo you've seen this year. It's not about which model is smartest or which chatbot gives the best answers. It's about plumbing. Specifically, it's about who gets to define how AI agents connect to the world — and to each other. Three standards have emerged. Anthropic's Model Context Protocol (MCP). Google's Agent2Agent Protocol (A2A). And OpenAI's Responses API. Each solves a different piece of the agent puzzle. Each has a different philosophy. And the outcome of this fight will determine who controls the infrastructure layer of AI for the next decade. If that sounds dramatic, good. It should. The companies that defined HTTP, REST, and OAuth didn't just build protocols. They built power. The same thing is happening now, except the stakes are higher and the timeline is compressed. ## MCP: The One That's Actually Winning Let's start with the protocol that's got the most momentum, even if it doesn't have the flashiest corporate backers. Anthropic released the Model Context Protocol in November 2024 as an open standard for connecting AI models to external data sources and tools. The concept is deceptively simple: give every AI system a universal way to read files, query databases, execute functions, and pull context from wherever it lives. Before MCP, if you wanted Claude to access your Postgres database and also your GitHub repos and also your Google Drive, you'd need three separate custom integrations. MCP replaces all of that with one protocol. The architecture borrows heavily from the Language Server Protocol (LSP), the standard that lets code editors talk to language-specific tooling. If you've ever used VS Code's autocomplete features, you've benefited from LSP. MCP applies the same idea to AI: one client, many servers, all speaking the same language over JSON-RPC 2.0. Here's what matters about MCP's trajectory: it's already been adopted by the competition. OpenAI officially integrated MCP support across its products in March 2025. Google DeepMind followed in April 2025. By December 2025, Anthropic had donated MCP to the Agentic AI Foundation under the Linux Foundation, co-founded with Block and OpenAI. That's not a protocol war. That's a protocol victory. The numbers back this up. SDKs now exist in TypeScript, Python, Java, Kotlin, C#, Go, PHP, Perl, Ruby, Rust, and Swift. Every major IDE — Cursor, Windsurf, Replit, VS Code — supports MCP servers. Sourcegraph, Cloudflare, and dozens of enterprise tools have built MCP integrations. When your competitors adopt your standard and help you govern it, you've won the layer. But MCP has a clear limitation: it only handles the connection between an agent and its tools. It says nothing about how agents talk to each other. That's where Google comes in. ## A2A: The Enterprise Play Google launched the Agent2Agent Protocol in April 2025 with a coalition that reads like a who's-who of enterprise software: Salesforce, SAP, ServiceNow, Atlassian, Box, Intuit, PayPal, Workday, and UKG. Plus every major consulting firm — Accenture, Deloitte, McKinsey, PwC, KPMG. Over 50 partners at launch. A2A solves a fundamentally different problem than MCP. Where MCP connects an agent to data and tools, A2A connects agents to other agents. The use case is enterprise orchestration: your HR agent needs to coordinate with your IT procurement agent, which needs to talk to your finance approval agent. These might be built by different vendors, running on different frameworks. A2A gives them a shared language. The protocol works through a client-remote model. A "client" agent formulates tasks and sends them to a "remote" agent for execution. Remote agents advertise their capabilities through "Agent Cards" — JSON-format descriptions that let other agents know what they can do. Tasks have a lifecycle: they can be completed immediately or run for hours, with status updates flowing back and forth. Google designed A2A around five principles: embrace natural agentic interaction (not just tool calls), build on existing standards (HTTP, SSE, JSON-RPC), be secure by default, support long-running tasks, and be modality-agnostic (text, audio, video). It's a well-thought-out spec, and Google's internal experience scaling multi-agent systems shows in the design. But here's the thing about A2A: it's explicitly complementary to MCP, not competitive. Google said so at launch. MCP provides tools and context to agents. A2A handles agent-to-agent communication. They're different layers of the same stack. ## The Responses API: OpenAI's Platform Play OpenAI's entry into this fight looks different because it's not really a protocol in the same sense. It's a product API that happens to define how agents get built on OpenAI's platform. The Responses API, launched in early 2025 alongside the OpenAI Agents SDK, replaced the older Assistants API. It bundles web search, file search, code interpretation, and computer use as built-in tools. The Agents SDK provides orchestration primitives: prompt chaining, routing, parallel execution, and handoffs between agents. OpenAI's approach is less "open standard" and more "platform with an opinion." They're not trying to define a universal protocol. They're trying to make it so easy to build agents on OpenAI's infrastructure that developers don't need a universal protocol. It's the Apple strategy applied to AI: control the whole stack, make the experience great, and let the open standards people fight over the stuff outside your walls. ## Who Wins? Wrong Question. Here's my take: asking which protocol "wins" misunderstands what's happening. These three aren't competing on the same layer. **MCP has already won the tool-connection layer.** When your competitors adopt your protocol and help govern it under the Linux Foundation, the war is over. **A2A will win the agent-coordination layer if enterprise adoption materializes.** The design is sound, the partners are real, and the problem space is genuine. I'd give it a 60% chance of becoming the de facto standard for multi-agent enterprise workflows. **The Responses API will win on OpenAI's platform.** Full stop. But it won't become a cross-platform standard because it isn't designed to be one. The real picture emerging is a three-layer stack: MCP for tools, A2A for agent coordination, vendor APIs for platform logic. This mirrors what happened with the web — HTTP handled transport, HTML handled presentation, JavaScript handled logic. No single standard "won" the web. The stack won. ## The Real Battleground The protocol war that matters isn't MCP vs. A2A vs. Responses API. It's open vs. closed. MCP and A2A are open standards with multi-stakeholder governance. The Responses API is a proprietary product controlled by a single company. In the short term, proprietary wins because it moves faster. In the medium term, open standards win because enterprises don't want to be locked into a single vendor's API decisions. We're watching the infrastructure of the AI economy get built in real time. MCP is the USB-C of AI — a universal connector that everyone's agreed to use. A2A is the Bluetooth — useful when it works but still maturing. The Responses API is Lightning — great if you're in the ecosystem, irrelevant if you're not. The interesting question isn't who wins the protocol war. It's what gets built on top of the protocols once the war is over. That's where the real money — and the real power — will be.