8 minute read

“HTTP doesn’t compete with SMTP. One moves web pages, the other moves email. MCP and A2A have the same relationship.”

TL;DR

MCP standardizes agent-to-tool connections — 97 million monthly SDK downloads, 10,000+ servers. A2A standardizes agent-to-agent communication — 150+ organizations, v0.3 with gRPC and signed security cards. They are complementary layers, not competing standards. The Linux Foundation’s Agentic AI Foundation houses both. This is the protocol stack moment for AI agents. For how agents invoke tools via MCP, see tool calling fundamentals. For the security implications, see the MCP SSRF epidemic.

A cross-section of a building infrastructure wall showing vertical pipe risers running between three floor levels and horizontal cable conduits running along each floor ceiling, the vertical and horizontal systems physically distinct in material and color but connecting at junction boxes on each floor

Why do agents need two protocols?

Because talking to tools and talking to other agents are fundamentally different operations.

When an agent calls a database, it sends structured parameters and receives structured results. The interaction is synchronous, typed, and deterministic. The agent knows exactly what the tool does before calling it. This is what MCP handles — Anthropic’s Model Context Protocol, launched November 2024. It defines three primitives: Tools (functions agents can call), Resources (data sources agents can read), and Prompts (guidance templates). The architecture is client-server. Each MCP server wraps a single integration point — a database, a GitHub repo, a Slack workspace.

When an agent delegates a sub-task to another agent, the interaction is different. The delegating agent does not know the other agent’s internal implementation. It needs to discover what the other agent can do, negotiate task parameters, monitor progress, and handle partial failures. The interaction may be asynchronous, long-running, and require re-negotiation mid-task. This is what A2A handles — Google’s Agent-to-Agent Protocol, launched April 2025. It provides agent discovery, capability negotiation, task delegation, and progress tracking.

MCP is vertical. A2A is horizontal. A planning agent uses A2A to coordinate with a research agent, which internally uses MCP to query a vector database. Both protocols are active in the same system, at different layers.

graph TD
    subgraph "Horizontal Layer (A2A)"
        PA[Planning Agent] <-->|A2A: delegate task| RA[Research Agent]
        PA <-->|A2A: delegate task| WA[Writing Agent]
    end
    subgraph "Vertical Layer (MCP)"
        RA <-->|MCP: query| DB[(Vector DB)]
        RA <-->|MCP: search| WEB[Web Search]
        WA <-->|MCP: write| DOC[Document Store]
    end

What does A2A v0.3 change?

Google released A2A v0.3 as the first version they describe as production-stable. Three additions matter.

gRPC support. Prior versions used HTTP/JSON. gRPC adds language-agnostic, high-performance communication with protocol buffers, connection multiplexing, and bidirectional streaming. For enterprise deployments with thousands of inter-agent messages per second, the overhead reduction is significant.

Signed security cards. Agents now carry cryptographic identity cards that prove who they are and what they can do. Before signed cards, agent discovery relied on self-reported capability descriptions — the equivalent of trusting someone’s LinkedIn profile without checking. Signed cards enable verifiable capability claims. This is the foundation for agent trust in zero-trust enterprise networks.

Extended Python SDK with enterprise auth. OAuth integration, service account support, and deployment paths for Cloud Run, GKE, and Agent Engine. Production deployments at Tyson Foods and Gordon Food Service validated these enterprise features before the v0.3 public release.

The governance moved in parallel. Google donated A2A to the Linux Foundation’s Agentic AI Foundation (AAIF), formed in December 2025. AAIF was co-founded by Anthropic, OpenAI, and Block, each contributing a founding project: MCP, AGENTS.md, and goose respectively. Google, AWS, Microsoft, Bloomberg, and Cloudflare joined as platinum members. A2A entered the AAIF after Google’s earlier June 2025 donation to the Linux Foundation. 150+ organizations support A2A specifically.

The IBM convergence deserves attention. IBM launched its own Agent Communication Protocol (ACP) in March 2025 for the BeeAI framework. Five months later, IBM and Google aligned on a shared approach and the ACP team merged into A2A development. Kate Blair from IBM Research joined the A2A Technical Steering Committee. Migration paths exist for ACP users. This consolidation — a competing protocol merging into the winner — is the strongest signal that A2A has reached critical mass for agent-to-agent communication.

How does MCP’s adoption compare?

MCP’s numbers are staggering for a protocol that did not exist before November 2024: 97 million monthly SDK downloads across Python and TypeScript, 10,000+ published servers, adoption by every major AI provider (Anthropic, OpenAI, Google, Microsoft, Amazon).

The adoption pattern is supply-led. Of 2,500+ tracked MCP servers, only 8 exceeded 50,000 installs. Most servers are small, single-developer projects wrapping a specific API or data source. This creates breadth (you can find an MCP server for almost any service) at the cost of quality (many are unaudited, unmaintained, and insecure — see the MCP security post for the implications).

MCP’s architecture is intentionally simple. A server exposes tools, resources, and prompts over JSON-RPC. A client connects, retrieves the schema, and calls tools. There is no service discovery, no capability negotiation, no multi-party coordination — those are A2A’s territory. The simplicity is a feature: a developer can write an MCP server in 50 lines of Python. That low barrier to entry is what produced 10,000+ servers in 16 months.

What does the full protocol stack look like?

Some architects describe a three-layer stack:

Layer Protocol Function Analogy
Agent-to-User A2UI (emerging) How agents communicate with humans HTTP (browser ↔ server)
Agent-to-Agent A2A How agents discover and coordinate with each other SMTP (server ↔ server)
Agent-to-Tool MCP How agents connect to tools and data SQL (app ↔ database)

The AGNTCY project (recently welcomed by the Linux Foundation) adds cross-cutting concerns: agent discovery, identity, messaging, and observability that interoperate with both A2A and MCP.

In a production multi-agent system, the stack operates simultaneously. A user request arrives via the presentation layer. The orchestrator agent uses A2A to delegate to specialist agents. Each specialist uses MCP to access its tools. Results flow back up through A2A to the orchestrator, which synthesizes a response.

This maps to enterprise middleware patterns. A2A is the service mesh. MCP is the database adapter layer. The AAIF is the standards body. The parallel to web infrastructure standardization in the 1990s-2000s is close: multiple complementary protocols governed by a neutral foundation, each handling a different layer of the stack.

What should practitioners do now?

If you are building single-agent systems: MCP is sufficient. Connect your agent to tools via MCP servers. A2A adds nothing until you have multiple agents that need to coordinate.

If you are building multi-agent systems: Use both. MCP for each agent’s tool connections. A2A for inter-agent coordination. Start with A2A’s Python SDK and the canonical examples in the GitHub repo.

If you are building MCP servers: Follow the security guidance in the MCP security post. Pin tool definitions, authenticate every request, bind to localhost.

If you are choosing between A2A and a custom protocol: Choose A2A. The protocol has 150+ supporting organizations, Linux Foundation governance, IBM merger validation, and production deployments. Building a custom inter-agent protocol is technical debt you do not need. The existing post on agent communication protocols covers the general patterns; A2A is the concrete implementation.

Key takeaways

  • MCP = vertical, A2A = horizontal. MCP connects agents to tools (97M SDK downloads, 10K servers). A2A connects agents to agents (150+ organizations, v0.3 with gRPC). They are layers, not competitors.
  • The Linux Foundation houses both. The Agentic AI Foundation — AWS, Anthropic, Google, Microsoft, OpenAI as platinum members — governs the shared protocol stack.
  • IBM’s ACP merging into A2A is the consolidation signal. When a competing protocol folds into the winner, the standard war is effectively over for the horizontal layer.
  • A2A v0.3 is production-ready. gRPC, signed security cards, enterprise auth. Deployments at Tyson Foods and Gordon Food Service validated before public release.
  • Start with MCP, add A2A when you need multi-agent. Single-agent systems need tool connections. Multi-agent systems need both layers.

Further reading

Want to work together?

I take on projects, advisory roles, and fractional CTO engagements in AI/ML. I also help businesses go AI-native with agentic workflows and agent orchestration.

Get in touch

Related across topics