A2A explains: When AI agents work as a team

We recently reported on MCP, Anthropic's Model Context Protocol, on our blog. Now Google is adding A2A - the Agent-to-Agent Protocol.

Does this mean that MCP is already obsolete?

In short: No. MCP and A2A solve different tasks - and even complement each other perfectly.

• MCP facilitates the vertical Integration: It connects tools, data sources and APIs.
• A2A enables the horizontal Collaboration: It gets different agents to find each other, understand each other and work together to accomplish complex tasks.

MCP integrates tools vertically - A2A networks agents horizontally.

Practical example: Booking a rental car with A2A

Let's take a look at how it works using a specific example.

Goal

You want to book a rental car for a specific period and location. The process is organized in four steps:
Selection → Availability → Payment → Confirmation.

Agents involved

Several specialized agents work together on this task - each one does exactly what they do best:

• Primary Assistant (PA): Coordinates the entire process for you.
• Rental Agent (RA): Provides rental car offers and reserves vehicles.
• Insurance Agent (IA): Offers you the right insurance on request.
• Payment Agent (PAYA): Takes care of secure payment.
• Notification Agent (NA): Sends you the booking confirmation.

Procedure

The PA takes over the control. As soon as you request a car, for example, it starts a task at the RA. This is followed by IA and PAYA - depending on what you select. At the end, you receive your confirmation via NA.

In the background, A2A ensures that the agents automatically find each other, communicate clearly and work together smoothly - even if they come from completely different systems.

From request to confirmation: Each agent takes on a specialized role - A2A ensures smooth communication in between.

What is A2A - and why is it so important?

The goal

A2A - the agent-to-agent protocol - creates A common language for AI agents.
Regardless of whether they come from different frameworks, programming languages or ecosystems: With A2A, they can communicate with each other in a secure and standardized way.

For you this means:

• You can combine specialized agents flexibly
• You no longer have to worry about incompatible interfaces
• And you benefit from a future-proof standard for AI collaboration

Design principles

Principle	Description
Opaque Agent Design	Black box design. An agent does not need the internal details of another agent. A2A is the basis for communication. So called. Agent Cards define the ability of an agent.
Build on Existing Standards	A2A uses established technologies such as HTTP(S), JSON-RPC 2.0 and Server-Sent Events (SSE). This makes integration into existing systems much easier.
Secure by default	Authentication, TLS, audit functions: A2A is "secure by default" - perfect for enterprise use.
Async-First / Long-Running	You can also use A2A to map long-running processes, including streaming and push mechanisms.
Modality Agnostic	Text, images, structured data - A2A can handle all data types.

These principles ensure that agents not only communicate, but also Collaborate efficiently and safely - no matter how complex the task is.

The architecture of A2A - open, standardized and scalable

A2A is an open protocol and is under the Apache License 2.0 - that means:
You can Use, extend and integrate freelywithout any license costs.

It is based on proven web technologiesincluding:

• TLS for secure connections
• HTTP & SSE for real-time communication
• JSON-RPC 2.0 as a lightweight protocol for structured API calls
• OAuth & API key for authentication and access control

These technologies not only make A2A robustbut also Easy to integrate into existing systems - whether cloud, on-premises or hybrid.

Interaction of client and server agent in the A2A context

There are 2 central roles in A2A:

A2A Client

This is the instance that initiates a task - often another agent or an assistant that interacts with you directly.

It sends tasks, e.g. ("tasks/send" or "tasks/sendSubscribe") to other agents and orchestrates the entire process.

A2A Server

An A2A server is an agent that has an HTTP interface and implements the A2A protocol. It receives incoming tasks from the client, processes them according to the defined task lifecycle (e.g. "submitted", "working", "completed", "failed") and returns the results in the form of artifacts. Servers advertise their capabilities using agent cards.

This simple model can also be used to create complex agent systems - each agent knows exactly what to do, when to act and who to talk to.

The building blocks of A2A - Agent Cards, Tasks & more

Agent Card - the digital business card

The Agent Card is the central document for describing an agent. It serves as a digital business card and contains all the information required for successful interaction. It is typically provided under a standardized path (/.well-known/agent.json) so that clients can retrieve it automatically.

An Agent Card includes:

• IdentityName, description, provider.
• Technical endpointsURL(s) for communication, protocol version.
• SkillsSupported features such as streaming or push notifications.
• SkillsSpecific functional areas, e.g. "Flight booking" or "Currency conversion".
• Authentication requirementsSecurity mechanisms such as OAuth2 or API keys.

You can find the Agent Card under the default path: /.well-known/agent.json.

The Agent Card thus lays the foundation for automated discoverability and interoperability, as clients can recognize in a standardized way how an agent is to be addressed and what services it offers.

Tasks - how agents start their work

A Task is a specific request that a client agent sends to a server agent.
It forms the basis for every collaboration.

Every task has:

• Unique IDEach task receives its own identifier.
• StatusTasks go through different phases such as submitted, working, input-required, completed, failed.
• Long-running processesUnlike classic API calls, tasks can run over longer periods of time and require multiple exchanges.

This allows complex processes to be implemented in several stages - with queries, interim results and aborts.

Messages - the dialog between the agents

About Messages communicate client and server - they are the "chat history" between the agents.

Each message contains:

• RoleEach message is sent either on behalf of the "user" (client) or "agent" (server).
• ContentsA message contains one or more content parts (see below).
• Unique identifierEach message has a messageId so that it can be clearly tracked.

The protocol thus enables a Clear dialog structure with traceable statuses and simple referencing of message sequences.

Content Parts - the information modules

The content of a message consists of so-called Content Parts. They are the building blocks with which different types of information are transmitted.

• TextPartTransmits plain text - e.g. questions, answers or instructions.
• FilePartEnables the exchange of files such as documents, images or binary data.
• DataPartTransports structured, machine-readable data (e.g. JSON parameters, form entries).

This clear separation ensures that Text, structured data and files processed seamlessly in the same protocol without any special solutions.

This is how communication works in the A2A protocol

A2A structures the interaction between agents in four clearly defined phases. This ensures transparency, reusability and a clear separation of tasks.

Phase 1 - Discovery: Finding the right agent

1. The client queries the server's agent card under /.well-known/agent.json.
2. The server then delivers the Agent Card with information on capabilities, endpoints and authentication.

Advantage: Agents can Find automaticallywithout manual configuration

Phase 2 - Start task: Initiate collaboration

3. The client sends a request (createTask) with the necessary entries.
4. The server creates the task and returns a task ID and the status (submitted).

Phase 3 - Engage in dialog: Clarify and ask questions

Now the actual exchange begins:

5. Swap client and server Messages e.g. with TextPart, DataPart, etc., to specify entries or communicate intermediate statuses.

Phase 4 - Conclusion: handing over the result

6. As soon as the task is completed, the server sends a Artefact back - the final result.
7. The client can now save it, display it or use it for the next step.

Conclusion: A2A brings order to the AI agent chaos

With A2A, Google is creating an open standard that allows agents from different providers to talk to each other - Standardized, secure and flexible.
Instead of rigid APIs and manual linking, A2A provides a Automated collaboration between specialized AI agents.

The result? You can combine, exchange and orchestrate agents - without worrying about compatibility or interfaces. So if you're thinking about scalable agent systems, A2A is a protocol you should consider. now should look at.