I spent three weeks trying to fix a latency problem that didn't exist. Our multi-agent customer support system was slow unacceptably slow, with p99 latencies hitting 14 seconds by the third hop. I blamed the models. I blamed the prompts. I blamed the framework, the network, the token counts.
Then a colleague looked at the architecture diagram, pointed at a box, and asked the question that ended the investigation: "Why is your billing agent calling your refund agent like it's a tool?"
I'd built a system where one agent needed to hand off a task to another agent that had its own reasoning, its own tools, and its own authority to act. But I'd wired it up as a tool call—a synchronous, request-response operation where the "tool" was actually an autonomous system. The billing agent was waiting for the refund agent the way you'd wait for a database query, while the refund agent was trying to reason, ask clarifying questions, and decide whether the request was even valid.
I had confused the vertical with the horizontal. And I was paying for it in every single interaction.
The confusion is understandable. Both MCP and A2A arrived in the same eighteen-month window, both carry the word "protocol," and both promise interoperability for AI agents. Most teams still treat them as competing standards, or worse, as interchangeable.
They are neither. They sit at different layers of the stack, and a serious agent deployment runs both.
MCP is vertical. It standardizes how a single agent reaches down into the world: calling tools, reading data, invoking APIs. The agent stays in charge, and the things it touches are passive. An MCP server that wraps kubectl does not think, negotiate, or push back. It exposes capabilities and waits. MCP optimizes for fast, structured, request-and-response tool calls.
A2A is horizontal. It standardizes how one agent asks another agent to do work on its behalf. The far side is not a passive tool but an autonomous system with its own model, its own tools, and its own judgment. It can accept the task, ask a clarifying question, run for six hours, or refuse. A2A optimizes for long-running, stateful negotiation between systems that do not trust each other and do not share memory.
When you treat an agent like a tool, you inherit every assumption of tool-calling. You assume the call will complete quickly. You assume the response will be a structured value. You assume the callee has no state, no goals, and no authority to say no.
My billing agent would call the refund agent and wait. The refund agent would try to reason through the request, discover it needed account status, and either fail or return a partial result. The billing agent would either hang, retry, or proceed with bad data. The trace showed a tool call that took 14 seconds. It should have been an A2A task delegation where the billing agent hands off work and moves on, and the refund agent gets back to it when it's done.
The architecture was wrong, and no amount of prompt tuning could fix a structural mismatch.
MCP solves a genuinely important problem: before it, connecting five agents to ten tools meant up to fifty bespoke integrations, each one a maintenance liability. MCP collapses that into one interface. By mid-2025, the community had built thousands of active MCP servers, and OpenAI, Microsoft, and Google DeepMind all adopted the protocol. MCP passed roughly 97 million monthly SDK downloads, with public registries indexing close to twenty thousand servers. MCP has won the tool-calling layer.
But MCP has no concept of a peer agent with its own goals, its own model, and its own authority to act. If your procurement agent needs your finance agent to approve a payment, MCP has nothing to say about that conversation. The finance agent is not a tool to be called; it is an actor with its own reasoning and its own right to refuse.
A2A handles the horizontal case: agents discovering each other, exchanging messages, and coordinating tasks across organizational and platform boundaries.
Each agent publishes an "Agent Card" describing what it can do, and other agents query that card to decide what work to delegate. The protocol defines task lifecycle states, support for synchronous and asynchronous interaction, and a structure for agents that don't share memory or trust each other.
By April 2026, more than 150 organizations supported A2A, with active production deployments across supply chains, financial services, and mobile platforms. Major cloud providers—including Google Cloud, AWS Bedrock AgentCore, and Microsoft Azure AI Foundry—have built native A2A support directly into their infrastructure. Enterprise SaaS platforms like ServiceNow, Salesforce, Atlassian, and SAP use A2A to connect workflows across their products.
Cisco's CAIPE (Community AI Platform Engineering) uses multi-agent orchestration with tool calling via both MCP and A2A. Their agents chain across Argo CD, Kubernetes, and Komodor to synthesize actionable answers. The result: response times dropped from hours to seconds, and MTTR reduced by up to 80%.
Elastic's LLM newsroom demonstrates the hybrid pattern in production code. A Reporter Agent delegates research tasks to a Researcher Agent via A2A, and delegates archive searches to an Archive Agent via A2A. The Archive Agent then uses MCP to access Elasticsearch tools. A2A enables agent collaboration; MCP provides tool access. They run together in the same system, each doing what it's best at.