Architecture

MCP + A2A: The Two Protocols Behind Every Production Agentic AI System

By IdeaBosqueLast updated: July 21, 2026

Key takeaways

MCP has 10,000+ published servers, 97M monthly SDK downloads, and 300+ clients — Anthropic's ecosystem update (December 2025) confirmed cross-vendor support from OpenAI, Google, Microsoft, and Cursor.
A2A surpassed 150 organizations in its first year — Linux Foundation announcement (April 2026), with production deployments across Google, Microsoft, and AWS platforms.
Google explicitly positioned A2A as complementary to MCP — MCP connects agents to tools; A2A connects agents to agents. Both are now under Linux Foundation governance.
23% of organizations have active AI agent pilots — Capgemini, 2026. The protocol question is no longer theoretical; it is an architecture decision.
Stacklok's 2026 survey shows 41% of software organizations in limited or broad production with MCP servers — the enterprise foothold is real, not speculative.

Two protocols launched within six months of each other and reshaped how AI agents connect. Anthropic released the Model Context Protocol (MCP) in November 2024 as an open standard for connecting AI agents to tools and data. Google released the Agent2Agent Protocol (A2A) in April 2025 as an open standard for connecting AI agents to each other. Both are now under Linux Foundation governance. Both are open source. Both are adopted by competing giants — OpenAI, Google, Microsoft, and Anthropic all support both.

The analogy that sticks: MCP is USB-C for AI. A2A is HTTP for agents. This article explains how they fit together in a production agentic AI system, what the adoption numbers say about where the ecosystem stands, and the architecture pattern for combining them in a B2B deployment.

The two-layer protocol stack

The diagram shows the two-layer stack: A2A at the top (agent-to-agent coordination), MCP in the middle (agent-to-tool access), and external systems and specialized agents at the bottom. An agent receives a task via A2A, delegates subtasks to other agents via A2A, and uses MCP to call tools that access NetSuite, HubSpot, BigCommerce, or any of the 10,000+ MCP servers.

MCP: the tool-access layer

MCP solves the M×N integration problem. Before MCP, every AI model needed bespoke integration code for every tool it called — M models × N tools = M×N integrations. MCP replaces that with an M+N solution: tool providers create N MCP servers, AI application developers create M MCP clients, and any client can call any server through the standardized protocol.

The adoption numbers are no longer speculative:

Metric	Value	Source
Active public MCP servers	10,000+	Anthropic ecosystem update, December 2025
Monthly SDK downloads	97M+ (Python + TypeScript)	Anthropic, December 2025
MCP clients	300+	Multiple ecosystem trackers
GitHub repositories with mcp-server topic	15,926	GitHub Search API, May 24, 2026
Enterprise production (limited or broad)	41% of software organizations	Stacklok State of MCP 2026 survey
Official registry server records	9,652	MCP Registry API, May 2026

MCP's July 28, 2026 release candidate makes the protocol layer stateless — removing the session handshake, introducing explicit handles for stateful workflows, and making OAuth 2.1 with PKCE mandatory. For B2B deployments, this means no sticky sessions, no shared session stores, and stateless horizontal scaling behind plain round-robin load balancers.

A2A: the agent-coordination layer

A2A fills the gap MCP does not cover. MCP connects an agent to tools. A2A connects an agent to another agent. An agent that needs a specialized capability — pricing logic, catalog search, RFQ processing — can delegate the work to a remote agent that exposes that capability via an A2A endpoint, receive the result as an A2A task, and continue its own workflow.

The Linux Foundation announcement (April 9, 2026) confirmed:

150+ organizations supporting the standard in its first year
Production deployments across Google, Microsoft, and AWS platforms
50+ launch partners including Salesforce, PayPal, Atlassian, Accenture, BCG, Deloitte, McKinsey, and PwC
Deep integration in Google Cloud (Vertex AI, Agent Engine, Agent Development Kit)

A2A defines three core primitives:

Agent Card — a JSON document at /.well-known/agent-card.json describing the agent's identity, capabilities, and endpoint. This is how agents discover each other.
Task — the unit of work, sent via message/send (non-streaming) or message/stream (streaming). Tasks transition through states: submitted, working, input-required, completed, failed, canceled.
Artifact — structured output produced during task execution, streamed to the client as it becomes available.

The complementary architecture

Google explicitly positioned A2A as complementary to MCP: "A2A is an open protocol that complements Anthropic's MCP." The positioning is precise — they operate at different layers:

Dimension	MCP	A2A
What it connects	Agent to tools/data	Agent to agent
Direction	Vertical (agent downward to systems)	Horizontal (agent sideways to agents)
Discovery	Tool list (`tools/list`)	Agent Card (`/.well-known/agent-card.json`)
Unit of work	Tool call (`tools/call`)	Task (`message/send`, `message/stream`)
Output	Tool result (JSON)	Artifact (streamed, structured)
Transport	STDIO, Streamable HTTP	JSON-RPC 2.0 over HTTP/SSE
Auth	OAuth 2.1 + PKCE (mandatory July 28)	Agent Card authentication (framework-defined)
State	Stateless (July 28 RC) + explicit handles	Task lifecycle (submitted to completed)
Backed by	Anthropic	Google
Governance	Linux Foundation (Agentic AI Foundation)	Linux Foundation
Adoption	10,000+ servers, 97M downloads	150+ organizations, 50+ launch partners

The architecture pattern for combining them in a B2B deployment:

A specialized agent (e.g., an RFQ processing agent) exposes its capabilities via an A2A Agent Card. Other agents discover it and delegate tasks to it.
The RFQ agent uses MCP to call tools that access NetSuite (catalog search, quote creation, availability holds), HubSpot (customer segment lookup), and BigCommerce (product catalog). The MCP module pattern provides typed schemas, rate limits, audit logs, and the explicit-handle pattern for stateful workflows.
The orchestrating agent receives a high-level task via A2A, delegates subtasks to specialized agents via A2A, and each specialized agent uses MCP to interact with the underlying systems. The orchestrator never touches NetSuite directly — it delegates to the RFQ agent, which delegates to its MCP tools.

This is the pattern that the existing A2A bridge article demonstrates: how to expose a framework's native API as an A2A Agent Card. The missing piece in most deployments is the MCP layer underneath — the typed modules that make the tools safe to call, auditable, and governed.

Why both protocols matter for B2B

A B2B deployment that uses only MCP has agents that can call tools but cannot coordinate with each other. Every workflow is a single-agent monolith. A deployment that uses only A2A has agents that can delegate tasks but cannot access external systems without bespoke integration code for every tool. Both protocols are needed.

The Capgemini 2026 research found that 23% of organizations have active AI agent pilots. The Anthropic 2026 State of AI Agents Report found that 46% of organizations identify integration as the #1 adoption barrier. The two protocols address exactly this barrier: MCP standardizes tool integration, A2A standardizes agent coordination. Together they reduce the integration burden from M×N custom connections to M+N standardized ones.

For a mid-market B2B company building a production agent system, the protocol question is not "which one?" — it is "how do they fit together?" The answer is the two-layer stack: A2A for agent-to-agent delegation, MCP for agent-to-tool access, and the MCP module pattern as the governed layer that makes the tools safe to call.