The Agent2Agent Protocol, abbreviated A2A, is a standard defining how agents communicate with each other. It is one of the protocols — standardised ways for agents to communicate with tools and other agents — that Model AI Governance Framework for Agentic AI lists among an agent’s core components, and it is positioned there as the agent-to-agent counterpart to Model Context Protocol, which was developed for agents to communicate with tools. That framework notes this is a fast-developing space, with more protocols being developed to standardise agent interactions, especially in agentic commerce.
Usage
Protocols are treated in that framework as a source of risk as well as a component: they can be poorly deployed or compromised, the example given being an untrusted MCP server containing code to exfiltrate a user’s data. Its recommended controls for multi-agent interactions do not name A2A specifically but bear on any agent-to-agent channel — requiring agents to communicate through structured schemas such as typed function calls rather than free text, so as to reduce unintended instructions passing between agents, and limiting shared memory access between agents.
A reported deployment shows what using it costs in practice. Agentic Engineering: How Swarms of AI Agents Are Redefining Software Engineering describes a multi-agent engineering system in which all worker agents communicate via A2A, while agents that do not support it are reached through an Model Context Protocol wrapper. Its authors found the AI coding agent they wanted to integrate had no native A2A capability, and built an MCP adapter tool to route requests from that coding agent to the worker agent — an arrangement they say makes the system IDE-agnostic.
A third source reports where the protocol has got to and names what it is being paired with. A chapter of Jimmy Song’s online handbook 智能体构建指南 describes A2A as Google-led and states that a 2026 update introduced an agent directory, which it presents as making agent discovery and invocation across organisations and across frameworks possible. It also reports that a mainstream Python agent framework was the first to gain native A2A support. That chapter names release dates and a version number for both of those events in passing; they are not restated here, because the announcements behind them are not among this page’s sources.
The framing that chapter puts on the result is a two-protocol stack it says the industry is settling into: MCP connects tools, A2A connects agents — the first answering how an agent reaches an external capability, the second how agents interoperate with one another, and the two together forming the protocol base of a LLM-Based Multi-Agent System. In its 2026 summary table it lists MCP as having become the de facto standard and A2A as Google-led, with the agent directory as its distinguishing addition. Those are stated there as assessments of where the ecosystem stands, not as measured findings.
A fourth source describes the protocol’s moving parts rather than its place in the ecosystem. Chapter 3 of the AI 原生应用架构白皮书 (AI-native application architecture whitepaper) hosted on jimmysong.io calls A2A an open standard for efficient communication and collaboration between heterogeneous agents, with three core roles — the user, the A2A client and the A2A server — and five main elements: the Agent Card, JSON-format metadata describing an agent’s capabilities and service endpoint; the Task, a stateful unit that supports multi-turn interaction; the Message, the basic unit of a single exchange; the Artifact, the concrete result produced once a task is complete; and the Part, the smallest unit of content within a message or artifact. It lists three interaction mechanisms — polling, streaming and push notification — and a three-step flow: discover the A2A server’s Agent Card, carry out authorisation and authentication, then send an A2A request, either synchronous or streaming.
The same chapter treats discovery as the problem distributed deployment raises. It calls the Agent Card a remote agent’s digital business card, which the A2A client parses in order to discover that agent, and names three ways of obtaining one: direct configuration, a fixed URI, and a registry. For the last it describes Nacos acting as the A2A registry, managing agents’ registration, discovery and retrieval in one place, and supporting agent version management and gray releases, which it presents as making distributed agent systems more maintainable and extensible.
A fifth source shows the discovery mechanism in use. Google’s
Developer’s Guide to AI Agent Protocols introduces A2A as the answer to expertise that
lives with remote agents — potentially built by different teams, on different frameworks, running on
different servers — and notes that some data may never be exposed through an API at all but could be
exposed through an agentic interface. In its description each A2A agent publishes an Agent Card at the
well-known path /.well-known/agent-card.json, describing its name, capabilities and endpoint; the
calling agent fetches these cards to learn what each remote agent does and routes queries to the right
one at runtime, so adding a new remote agent is a matter of adding its URL, with no code change or
redeployment. The guide’s worked example uses
Agent Development Kit (ADK), whose RemoteA2aAgent routes to one remote agent per
turn; where a query spans several remote agents at once, the guide uses the a2a-sdk directly. The same
guide places A2A in a six-protocol stack and summarizes its role there in one line: MCP connects agents
to tools and data, and A2A connects agents to other agents. It also notes that the
Universal Commerce Protocol (UCP) reuses A2A’s well-known-URL discovery pattern and can run over
A2A as a transport.
A Chinese-language post by Phodal Huang, 2026 年，万物皆 Coding Agent 的平台工程（A2A / ACP / MCP / Skill）, states that A2A was released by Google in April 2025 and names Microsoft, Anthropic and LangChain among its supporters. It places A2A in a three-layer protocol stack, likening it to the internet’s HTTP — how agents talk to one another — and argues that MCP, which handles tool calls, and the Agent Client Protocol (ACP), which handles coding-agent processes, are both confined to a single platform, whereas A2A supplies the cross-platform layer. The elements it names are the AgentCard, a capability declaration it likens to OpenAPI; the Skill, the kinds of task an agent is good at (its examples are code review and test generation); and the Task, a status flow from submitted through working to completed. With these, it says, an orchestration system could discover a GitLab security agent, delegate a task to GitHub’s coding agent, and receive a completion notice from a Vercel deployment agent.
A survey of four emerging agent communication protocols, A survey of agent interoperability protocols: Model Context Protocol (MCP), Agent Communication Protocol (ACP), Agent-to-Agent Protocol (A2A), and Agent Network Protocol (ANP), summarizes A2A as enabling peer-to-peer task delegation using capability-based Agent Cards, supporting secure and scalable collaboration across enterprise agent workflows. It compares A2A with Model Context Protocol, Agent Communication Protocol (ACP) and Agent Network Protocol (ANP), and in the phased adoption roadmap it proposes, A2A is adopted for collaborative task execution after MCP (for tool access) and ACP (for messaging), before adoption extends to ANP for decentralized agent marketplaces.
Related Terms
Model Context Protocol, AI Agent, Universal Commerce Protocol (UCP), Agent Communication Protocol (ACP), Agent Network Protocol (ANP), Agent Client Protocol (ACP)