Multi-Agent Communication with Google's A2A
Agent2Agent (A2A) Protocol is an open standard for communication and collaboration between AI agents.2 Though it’s new, it’s gaining attention, especially since it works well with MCP, which is becoming the industry standard. A2A is expected to become the go-to protocol for multi-agent communication.
Initially, when Google released the Protocol Specification, it was unclear how to use it. However, with the release of the official Python SDK, it’s now easier to implement. This article will explore how the protocol facilitates communication between agents and clients.
A2A components
Actors and protocols
The A2A protocol defines three main actors:
- User: The end-user who initiates a task.
- Client agent: The entity that requests and sends the task on behalf of the user.
- Remote agent: The agent that performs the task and returns the results.
In the diagram example, the blue agent is the client agent, and the green agent is the remote agent.
Agent cards and discovery
Agents share their metadata and capabilities through a standardized JSON document known as an Agent Card, typically hosted at /.well-known/agent.json. This card includes:
- Name, version, and hosting URL
- Description and service provider
- Supported input/output modalities and content types
- Authentication methods
- List of agent skills with tags and examples
Discovery can be done via DNS, registries, marketplaces, or private catalogs.
Core communication objects
At the core of A2A communication is the Task, a structured object representing a unit of work. Tasks go through various lifecycle states like submitted, working, input-required, or completed.
Each Task contains:
- Messages: Used for communication between the Client and Remote agent.
- Artifacts: Immutable results produced by the remote agent.
- Parts: Self-contained data blocks within messages or artifacts, such as JSON.
How the A2A protocol works?
The below workflow example illustrates how communication flows between the Client and Server in the A2A protocol:
How the system communicates
The system consists of three main participants: the user, the Event Agent, and the Alert Agent.
They communicate using “Messages”, which are just individual exchanges of information in the A2A protocol.
These agents are hosted on A2A Servers that handle incoming requests through HTTP endpoints. Each server has Event queues that temporarily hold information while waiting for responses.
A2A client and server roles
The A2A Client starts the communication process. However, an A2A Server can also act as a Client if two agents need to communicate directly.
EventQueue and tasks
The EventQueue stores various objects, including Messages and Tasks. When an agent needs to fulfill a request, it may create a Task, which represents a goal that requires several steps to complete.
A Task goes through different stages, such as being created (submitted), in progress (working), requiring more information (input-required), completed, or failed. Each Task has a unique ID, making it easy to track its progress.
In this example system, there are two main tasks: detecting an event, handled by the Event Agent, and alerting the user, managed by the Alert Agent.
Tasks often involve multiple exchanges of messages between agents, with each message helping to move the task toward completion.
The Event Agent is wrapped in an A2A Server, which manages how messages are sent and received. When a task is triggered, the server oversees the task’s lifecycle, updates, and communication between agents.
How does A2A differ from MCP?
While A2A and MCP both improve AI interoperability, their scopes differ:
- Model Context Protocol (MCP): Focuses on sharing contextual data between AI models and tools. It enables models to access external knowledge sources and user context, thereby improving their responses.
- Agent2Agent Protocol (A2A): Builds upon MCP by enabling full agent-to-agent task coordination, including messaging, role assignment, and artifact sharing. MCP enhances context-awareness in isolated agents. A2A enables autonomous and collaborative workflows among multiple agents.
Other AI agent communication protocols
While A2A (Agent2Agent Protocol) focuses on task coordination and communication within enterprise environments, several other agent communication standards are emerging. Some of them are:
- ANP (Agent Network Protocol): Promotes open, decentralized agent networks using DID (Decentralized Identity) and secure negotiation.3
- AITP: Built for secure economic transactions between agents, particularly across organizational or trust boundaries.4
- Agora: A protocol enabling LLM-based agents to negotiate how they communicate autonomously.5
- LMOS (Language Model OS): Provides a platform to orchestrate cross-framework interoperability across diverse enterprise agent systems.6
FAQ
Further reading
Reference Links
Cem's work has been cited by leading global publications including Business Insider, Forbes, Washington Post, global firms like Deloitte, HPE and NGOs like World Economic Forum and supranational organizations like European Commission. You can see more reputable companies and resources that referenced AIMultiple.
Throughout his career, Cem served as a tech consultant, tech buyer and tech entrepreneur. He advised enterprises on their technology decisions at McKinsey & Company and Altman Solon for more than a decade. He also published a McKinsey report on digitalization.
He led technology strategy and procurement of a telco while reporting to the CEO. He has also led commercial growth of deep tech company Hypatos that reached a 7 digit annual recurring revenue and a 9 digit valuation from 0 within 2 years. Cem's work in Hypatos was covered by leading technology publications like TechCrunch and Business Insider.
Cem regularly speaks at international technology conferences. He graduated from Bogazici University as a computer engineer and holds an MBA from Columbia Business School.
Be the first to comment
Your email address will not be published. All fields are required.