The ‘Mandarin’ of Agent Communication: MCP, A2A and the Emerging Agentic Web

Scenario: a refund approval stuck in "miscommunication"

Imagine a customer‑service agent receiving a refund request that must be approved by a finance agent. The two agents run on different model stacks (Doubao vs. Kimi) with an intermediate DeepSeek‑driven approval model, and none have ever spoken to each other. The process, which should take seconds, stalls because each agent "doesn't understand" the other, forcing a manual OCR workaround.

Historical silo problem

For more than two decades, multi‑agent systems have suffered from isolated "gardens" where each vendor nurtures its own agents behind high walls. Interoperability required dozens of custom adapters and translators, creating massive technical debt.

Emergence of a common language

At the end of 2024, a wave of open protocols appeared to solve "how agents talk". Like HTTP or TCP/IP, these standards are publicly implementable and aim to provide a lingua franca for agents regardless of underlying models or frameworks.

1. MCP – giving agents a "hand"

In November 2024, Anthropic released the Model Context Protocol (MCP), defining how an agent calls external tools and data sources. It is likened to an AI "USB‑C interface". MCP specifies four primitives:

Tools : functions an agent can invoke, such as database queries or email sending.

Resources : read‑only data the model may access, like files or records.

Prompts : user‑side prompt templates.

Tasks (added November 2025): long‑running asynchronous jobs that can report progress.

MCP uses standard JSON‑RPC and can run over local stdio or streamable HTTP. Adoption metrics show rapid growth: by early 2026 the SDK reached 97 million monthly downloads and over 8 600 public servers, surpassing React’s 100 million‑download milestone in just sixteen months. In March 2026 Perplexity’s CTO announced an internal rollback, citing that MCP can consume up to 72 % of the context window before processing the first user message, leaving only 5.7 k tokens for actual reasoning.

2. A2A – giving agents a set of "colleagues"

While MCP connects agents to tools, it does not address collaboration between autonomous agents. In April 2025 Google, together with more than 50 partners, launched the Agent‑to‑Agent (A2A) protocol. A2A is described as "HTTP for agents" and introduces an Agent Card placed at /.well-known/agent.json on the agent’s domain, declaring its capabilities, I/O formats, and authentication method.

The protocol defines a full task lifecycle (submitted, working, input‑required, completed, failed, canceled) and supports streaming progress via Server‑Sent Events or webhook notifications. A strict "opacity" principle ensures that only declared capabilities and results are exchanged, keeping internal reasoning private.

By April 2026, A2A had over 150 supporting organizations and production deployments in supply‑chain, finance, insurance, and IT operations, with integrations into Azure AI Foundry, AWS Bedrock AgentCore, and Google Cloud. Google donated the specification to the Linux Foundation in June 2025.

3. ANP – an open‑internet layer for agents

The Agent Network Protocol (ANP) goes further by removing any central registry. Each agent generates a decentralized identifier (DID) and publishes metadata to a publicly resolvable HTTPS endpoint. Search engines and other agents crawl these descriptions, effectively creating an AI‑native "DNS + yellow pages".

ANP’s three‑layer architecture consists of:

Identity & encryption layer : DID‑based authentication and end‑to‑end encryption.

Meta‑protocol negotiation layer : agents dynamically agree on which protocol to use.

Application protocol layer : capabilities described using JSON‑LD and schema.org.

The protocol is stewarded by an open‑source community led by W3C AI Agent Protocol group co‑chair Gong Wei, emphasizing that agents belong to their owners, not to any platform.

Comparison of the three protocols

Primary purpose : MCP – tool/data integration; A2A – agent‑to‑agent collaboration; ANP – decentralized discovery.

Direction : MCP – vertical (downward); A2A – horizontal (peer); ANP – open (any).

Discovery mechanism : MCP – static/host exposure; A2A – Agent Card; ANP – DID + web crawling.

Identity model : MCP – token + TLS; A2A – DID handshake; ANP – self‑held DID.

Centralization : MCP – moderate (servers); A2A – low (peer); ANP – minimal (no central registry).

Governance : MCP & A2A – Linux Foundation; ANP – open community.

Protocol stack in production

In real systems the three protocols are layered: an orchestrator agent uses A2A to discover a specialist agent; that specialist uses MCP to invoke databases, search code, or send emails. A2A handles "find the right colleague, dispatch work, retrieve results" while MCP handles "how the colleague uses its tools".

Most of these protocols now reside under the Linux Foundation’s Agentic AI Foundation (AAIF), founded in late 2025 by OpenAI, Anthropic, Google, Microsoft, AWS, and Block. The consortium stresses that without a shared language the market cannot scale, and that imposing a proprietary dialect would drive ecosystems away.

Future outlook and open questions

The vision is a trillion‑scale Agentic Web where addressing shifts from IP‑based to capability‑based semantic addressing. Forecasts predict tens of billions of agents by 2026, each wrapping an API, microservice, or autonomous function. However, critical challenges remain: liability for broken agent links, the risk of a monopolistic registry emerging, and the need for safeguards against adversarial negotiation strategies among agents.

Conclusion

Revisiting the opening refund‑approval example, the solution today is clear: the customer‑service agent discovers the finance agent via A2A’s Agent Card, the finance agent retrieves account data through MCP, and the entire workflow is authenticated with Agent Cards and DIDs, completing in a few configuration lines instead of dozens of custom translators.

We are writing a second grammar for the Internet—one that connects capabilities and intent rather than documents and devices. The standards are still evolving, with gaps and power struggles, but the direction toward a common "Mandarin" for agents is unmistakable.