Agent2Agent protocol (A2A)
Also known as: A2A protocol, Agent2Agent, agent-to-agent protocol
The Agent2Agent protocol (A2A) is an open standard that lets AI agents built by different vendors communicate with each other, share tasks, and exchange results.
An agent publishes an 'agent card' describing what it can do, and other agents can send it work. While MCP connects an agent to tools and data, A2A connects agents to other agents, and in practice many systems use both.
Agent2Agent protocol (A2A), explained at three levels
At home
Imagine your travel assistant phoning a hotel's front desk to ask about rooms, with both sides following the same etiquette so the call makes sense. A2A is that shared etiquette for AI agents. It lets an assistant built by one company find an agent built by another, hand it a task, and get the answer back, without either needing custom code for the other.
At work
The Agent2Agent protocol is an open standard that lets AI agents from different vendors work together. A sales agent from one company can ask a billing agent from another to check an invoice, then use the result. For a business, it means agents can be mixed and matched across platforms instead of being locked into one vendor's ecosystem.
At home
Each A2A agent publishes an 'agent card,' a small file at a known web address that works like a business card, listing its name, skills, and how to reach it. Another agent reads the card, picks the right skill, and sends a task. The task then moves through states such as working, needs input, and completed, and the helper agent sends progress updates and finally the result, such as a booking confirmation.
At work
A2A is built on ordinary web standards: requests travel over HTTPS as JSON-RPC, with gRPC also supported in later versions, and long-running tasks report progress through server-sent events or push notifications to a webhook. Messages carry typed 'parts,' such as text, files, or structured data. Agents stay opaque, meaning they share results without exposing their internal tools, prompts, or memory. Authentication uses standard schemes such as OAuth and API keys, declared in the agent card.
At home
When one agent hands work to another, each step involves a separate model making its own decisions, and none of them sees the whole chain. If something goes wrong, such as a booking at the wrong price, it is hard to trace which agent made the mistake. While A2A passes task records between agents, it can't make each agent's judgment reliable. In my opinion, that's why people should stay in the loop for anything important, like payments.
At work
Cross-organization agent chains raise problems the protocol only partly solves. Each agent must authenticate the other, and a user's permissions must be delegated without handing over full credentials. Audit trails have to stitch together logs from several vendors, and a compromised or manipulated agent can feed false results to others, a form of prompt injection between agents. Liability for an action taken three agents down the chain is legally unsettled, so I'd check vendor support and log every hand-off before committing.
Real-world examples
At home
Fatima's AI assistant planned a dinner by checking a restaurant's booking agent for open tables, then confirmed with her before reserving.
At work
Marcus is a solutions architect at a Vancouver logistics firm. He piloted A2A so the company's customer-service agent could ask a separate shipment-tracking agent, built by another vendor, for delivery updates.
How it compares
| feature | Agent2Agent protocol (A2A) | Model Context Protocol (MCP) |
|---|---|---|
| Connects | Agents to other agents | An agent to tools and data |
| Originally from | Google, 2025 | Anthropic, 2024 |
| Governance | Linux Foundation | Agentic AI Foundation (Linux Foundation) |
| Typical use | Delegating tasks between agents | Calling tools and reading data |
MCP gives an agent hands. A2A gives agents colleagues.
For analysts
Multi-agent setups add complexity fast. I'd start with clear handoffs and audit logs, and only add agent-to-agent communication when one agent truly can't do the job alone.
History & origin
As companies began deploying AI agents from multiple vendors in 2024 and 2025, those agents had no common way to coordinate. Google announced the Agent2Agent protocol in April 2025, with support from more than 50 technology partners. In June 2025, Google transferred the protocol, its SDKs, and developer tools to the Linux Foundation as an open-source project. The Linux Foundation reported in 2026 that more than 150 organizations supported the standard, and official SDKs exist for Python, JavaScript, Java, Go, and other languages. IBM's competing Agent Communication Protocol merged into A2A in late summer 2025, and in 2026 A2A was reported to join MCP under the Linux Foundation's Agentic AI Foundation. In my view, A2A is promising, but most businesses should get one agent working reliably before worrying about agents talking to agents.