A2A:The Agent-to-Agent Protocol
Heiko Hotz and Sokratis Kartakis of Google Cloud introduce the Agent-to-Agent (A2A) protocol, a new open standard for enabling stateful, secure, and asynchronous collaboration between AI agents built on different frameworks. They contrast it with tool-use protocols like MCP and discuss its microservices-like architectural benefits.
The current “Cambrian explosion” of AI agents, built with diverse frameworks like LangGraph, CrewAI, and Google’s Agent Development Kit (ADK), has created a significant integration challenge. As developers and organizations build more agents, the need arises to connect them without constantly rewriting application code. The Agent-to-Agent (A2A) protocol was created to address this, providing a common language for agents to collaborate effectively.
A2A is a forward-looking protocol designed for a future where different teams within an organization—or even different organizations—develop specialized agents (e.g., for financial analysis or travel booking) that others need to leverage. Traditional APIs are insufficient for agentic workflows, which require a stateful, asynchronous protocol capable of managing long-running tasks with intermittent status updates.
A2A vs. MCP: Complementary Protocols
A2A and the Model-centric Protocol (MCP) are seen as complementary, serving different purposes.
- MCP is designed for an agent using a tool. It is a single, one-shot interaction where the tool exposes its capabilities via a structured schema (e.g., “I require input A and B and will return their sum”). This is analogous to a vending machine: you provide specific inputs and get a predictable output.
- A2A is designed for an agent collaborating with another agent. It is stateful and asynchronous. An agent exposes its functionality through a natural language description (e.g., “This agent can add two numbers and return the sum”). This is analogous to a concierge: you give it a high-level goal (“I’m thirsty, buy me something to drink”), and it handles the underlying steps, providing updates along the way.
Architectural Shift: From Monolithic Agents to Microservices
The A2A protocol facilitates a shift from monolithic agent architectures to a more robust microservices-style approach.
- Monolithic Agents: A single agent equipped with a large number of tools can become confused, selecting the wrong tool and making evaluation and testing difficult.
- Multi-Agent Systems: A system can be composed of small, specialized agents, each with a limited set of tools, dedicated to specific tasks. This approach offers several benefits:
- Improved Performance: Reduces the risk of the underlying LLM getting confused.
- Easier Development: Developers can build, test, and evaluate smaller, focused agents more easily.
- Flexibility: Each specialized agent can use the most appropriate model for its task, from a small open-source model like Llama to a powerful one like Gemini 1.5 Pro.
A common pattern involves a central “router agent” that interacts with the user and delegates sub-tasks to specialized remote agents (e.g., a flight booking agent, a hotel booking agent). This router agent maintains the overall context, even if the specialized agents are built with different frameworks like LangChain or ADK.
Core Concepts and Security
The A2A protocol is built around a few key concepts, with security as a foundational principle.
- Agent Card: Each agent has a “business card” that describes its capabilities in natural language, how to communicate with it (e.g., live streaming vs. simple messaging), and its required security methods. This card can also be extended to signal other metadata, such as uptime or success rates.
- Security First: Understanding that enterprise adoption hinges on security, A2A was built with security as “priority number zero.” It natively supports common authentication methods like API keys, OAuth 2.0, and OpenID. While the protocol provides the mechanism, security remains a shared responsibility with the developer, who must implement necessary guardrails.
- Extensibility: The protocol is designed to be extensible. Developers can create custom extensions to define new data structures or enforce specific profiles, such as mandating a particular type of business-level encryption across all collaborating agents.
Adoption and Governance
The learning curve for A2A is low for developers familiar with RPCs, with SDKs available in Python, Java, .NET, and JavaScript/TypeScript to simplify implementation.
Adoption is growing as more companies scale their agentic solutions across different business units and encounter the need for inter-agent communication. Real-world use cases are emerging in industries like insurance, where a “broker agent” from one company might need to communicate with an “underwriter agent” from another.
To foster trust and broader adoption, the A2A protocol is now governed by the Linux Foundation. This ensures it remains an open, vendor-neutral standard with shared decision-making, making it a more attractive choice for enterprises building the next generation of collaborative AI systems.