What Is the A2A Protocol? Agent-to-Agent Communication Explained
A beginner-friendly guide to the A2A (Agent-to-Agent) protocol: how AI agents from different vendors find each other, hand off tasks and return results.

Put a French speaker, a Japanese speaker and a Swahili speaker in a room and ask them to build a house, and not much gets done. However skilled they are, they can't coordinate without a shared language.
Artificial intelligence has the same problem. Companies now run many specialised AI agents: one handles billing, another writes code, another answers customers. When the support agent needs the billing agent to issue a refund, and the two were built by different teams on different frameworks, how do they talk?
That's what the A2A protocol is for.
A2A stands for Agent-to-Agent. It's an open standard that lets AI agents, including ones built by different companies, discover what each other can do, hand over tasks and send back results, without custom code for every pair.
This guide explains how A2A works, walks through an example, compares it with MCP, and covers what to check before you connect agents to each other.
Where A2A came from
Google introduced A2A in April 2025 with a group of technology partners. It was later handed to the Linux Foundation as an open project, and the specification has since reached version 1.0. The project's site, a2a-protocol.org (opens in a new tab), now lists it as part of the Agentic AI Foundation.
The idea behind it: agents should be able to work together while staying opaque. One agent doesn't need to see another's prompts, tools or internal reasoning. It only needs to know what the other agent offers and how to ask for it.
The problem A2A solves
Before a shared protocol, connecting two agents meant writing "glue" code for that specific pair: one format for requests, another for replies, a custom way to check on progress. Every new agent added more glue, and every change on one side could break the other.
A2A replaces that with one agreed way to:
- describe what an agent can do,
- send it a task,
- follow the task while it runs, and
- receive the results.
If both sides speak A2A, they can work together even if they were built with completely different tools. This is the foundation of a multi-agent system that spans teams or companies.
Need a refresher on agents?
Before diving into how agents communicate, make sure you understand how they work on their own.
How the A2A protocol works
Discovery: the Agent Card
Every A2A agent publishes an Agent Card, a small JSON document that works like a business card or résumé. It's usually served at a standard web address (
/.well-known/agent-card.json) and lists:- the agent's name, description and provider,
- its skills (what tasks it can take on),
- the address to send requests to,
- what it supports, such as streaming updates or push notifications, and
- which authentication methods it accepts.
A client agent reads the card to decide whether this agent can help, and how to connect.
Tasks, messages and artifacts
A2A organises work around a few simple objects:
- Message: one turn of communication ("Please summarise this spreadsheet"), made of parts such as text, a file or structured data.
- Task: the unit of work created from a request. It has a status that moves through stages: submitted, working, possibly input-required (the agent needs something from you) or auth-required, and finally completed, failed, canceled or rejected.
- Artifact: the output of a task, such as a report, a file or a data table.
Long-running work
Some tasks take seconds; others take hours. A2A supports both:
- Simple request and response for quick tasks.
- Streaming updates (over server-sent events) so the client sees progress as it happens.
- Push notifications: the remote agent calls a webhook the client registered when the task changes, so nobody has to keep asking "are you done yet?"
Security and trust
A2A doesn't invent its own security. It uses familiar web standards:
- The Agent Card declares which authentication schemes it accepts, such as API keys, OAuth 2.0, OpenID Connect or mutual TLS. Credentials are obtained through those normal channels.
- Agent Cards can be signed, so a client can check the card hasn't been tampered with.
- Traffic runs over HTTPS, using JSON-RPC, gRPC or a plain HTTP+JSON interface.
What A2A doesn't decide is whether an agent should be trusted to do something. That's still your call: which agents you connect to, what they're allowed to request, and which actions need a person's approval (human in the loop).
An example: a refund across two agents
- A customer asks your support agent for a refund on an annual plan.
- The support agent reads the billing agent's Agent Card and sees a skill called "Issue refund", which requires OAuth.
- It authenticates and sends a message: refund order 98765, reason "within 30-day window".
- The billing agent creates a task. It checks the order and needs approval for refunds over a set amount, so the task moves to input-required and a finance manager is notified.
- The manager approves. The task moves to working, then completed, with an artifact: the refund receipt.
- The support agent receives the update and tells the customer the refund is on its way.
Neither agent saw the other's prompts, tools or database. They only exchanged tasks, messages and results.
A2A vs MCP: what's the difference?
You'll often hear A2A mentioned alongside MCP (Model Context Protocol). They solve different problems and are designed to be used together.
| MCP | A2A | |
|---|---|---|
| Connects | An agent to tools and data | An agent to other agents |
| The other side is | A tool server that does what it's told | An independent agent that plans and works on its own |
| Typical use | Read a file, query a database, call an API | Delegate a task, get a finished result back |
| Interaction | Usually a quick call and response | Can be a long-running task with updates |
In a restaurant, MCP is how the chef opens the fridge and uses the oven. A2A is how the chef asks the pastry chef, who has their own station and methods, to make the dessert. Read the full comparison in MCP vs A2A.
Learn about MCP
Want to understand how agents access files and external databases? Read our beginner-friendly guide to MCP.
Before you connect agents: what to check
- Do you need A2A at all? If all your agents live in one application, a framework's built-in orchestration may be simpler. A2A shines when agents are built by different teams, vendors or organisations.
- Treat other agents' output as untrusted input. A remote agent's reply can contain instructions aimed at your agent: a form of prompt injection. Validate results before acting on them.
- Limit what each connection can do. Use narrowly scoped credentials, and put guardrails and approvals in front of anything that moves money or changes data.
- Log every task. Record who asked for what, and what came back, so you can trace mistakes.
- Plan for failure. Remote agents can be slow, unavailable or reject a task. Decide what your agent should do then.
Frequently asked questions
What does A2A stand for?
Agent-to-Agent. It's an open protocol for communication between AI agents.
Who created A2A?
Google announced it in 2025 with industry partners and handed it to the Linux Foundation as an open project. It's developed in the open by many companies.
Is A2A a replacement for MCP?
No. MCP connects an agent to tools and data; A2A connects agents to each other. Many systems use both.
What is an Agent Card?
A public JSON description of an agent: what it can do, where to reach it and how to authenticate. Other agents read it to discover and connect to it.
Do I need A2A to build a multi-agent system?
Not always. Inside one app, a framework can coordinate agents directly. A2A is most useful when agents come from different teams or vendors and need a shared standard.
Summary
- A2A is an open standard for agents to discover each other, delegate tasks and return results.
- Agents publish an Agent Card; work is organised as tasks, messages and artifacts, with streaming and push updates for long jobs.
- Security uses standard web authentication, and Agent Cards can be signed. Trust decisions are still yours.
- MCP connects agents to tools; A2A connects agents to agents.
- Treat other agents' output as untrusted input, and scope what each connection can do.

Stephen Gbolagade
Software Engineer and Technical Writer at Ploba
Writes Ploba's guides to AI tools, agents and protocols, explaining how they work in plain language.
Keep learning
Plain-language explanations, technical guides and practical comparisons.


