Agent Protocols: A2A, ACP & AP2
The open standards that make agents from any vendor interoperable
The Problem: You have a research agent from Google, an analysis agent built in-house, and a reporting agent from a startup. Each speaks its own API dialect, so connecting them means writing custom glue for every pair — N agents need N² adapters, and when one vendor changes its format, everything breaks. And none of them can pay each other for a service.
The Solution: Open Protocols: A2A, ACP & AP2
As multi-agent systems and agent marketplaces grow, agents from different vendors must discover each other, communicate, and even transact. Three open protocols standardize this so agents become plug-and-play:
- A2A (Agent-to-Agent) — capability discovery via agent cards plus a task lifecycle for delegation. Started by Google, launched with 50+ partners (April 2025), contributed to the Linux Foundation, and growing since.
- ACP (Agent Communication Protocol) — IBM's open agent-communication spec, a standard messaging layer for the conversation between agents. It is now co-governed under the Linux Foundation alongside A2A — the two interoperate rather than one replacing the other.
- AP2 (Agent Payments Protocol) — an emerging, draft-stage 2026 standard for signed mandates and settlement so agents can pay each other safely, with auditable limits.
The key distinction: MCP connects an agent to its tools, while A2A connects an agent to peer agents. They are complementary layers of the same stack.
Think of it like HTTP and email standards for the web:
- 1. Discovery: An agent publishes an agent card — a JSON document describing who it is, what skills it offers, its endpoint, and how to authenticate. Clients (or a registry) read it to find the right agent.
- 2. Delegation: A client agent assigns a task via the A2A task lifecycle: submitted → working → input-required → completed/failed. Both sides can track progress at any point.
- 3. Communication: Agents exchange messages over ACP — a standard messaging layer. Structured turns carry text, structured data, and artifacts back and forth until the task is done.
- 4. Transaction: When a task needs payment, AP2 carries a signed mandate (authorize up to a limit) and runs settlement to record the transfer — making autonomous agent commerce safe and auditable.
Discovery and delegation come from A2A, the conversation rides on ACP, and the money moves through AP2 — all standardized, so any two agents interoperate out of the box.
Where Agent Protocols Are Used
- Multi-vendor orchestration: Compose a workflow from a Google research agent, your own analysis agent, and a startup’s reporting agent — no custom glue per pair, because all three speak A2A.
- Agent marketplaces: A registry of agent cards becomes an "app store" for agents: discover capabilities, compare, and plug an agent into your pipeline through the standard interface.
- Autonomous purchasing (agent commerce): With AP2, an agent can buy a service from another agent within a signed spending mandate — the payment is authorized, capped, and settled in an auditable way.
- Common Pitfall: Treating A2A as a replacement for MCP. MCP connects one agent to its tools (databases, APIs); A2A connects agents to peer agents. You usually need both, at different layers.
Fun Fact: IBM built its own Agent Communication Protocol (ACP) independently — and rather than merging into A2A, it is now co-governed under the Linux Foundation alongside A2A, with the two interoperating. By A2A’s one-year mark in April 2026, MCP, A2A, and ACP all sat under Linux Foundation governance, with AP2 emerging alongside as a draft-stage standard from a coalition of payments organizations.
Try It Yourself!
Explore the interactive visualization below: switch between the A2A, ACP, and AP2 tabs to see each message shape, then run the AP2 flow to watch a payment mandate travel from request to settlement.
A2A: an agent card advertises capabilities, then a task is delegated and completed.
{ "name": "ResearchAgent", "skills": ["web-search", "summarize"], "url": "/a2a", "auth": "OAuth2" }A2A discovers and delegates, ACP carries the conversation, AP2 moves the money. MCP meanwhile connects an agent to its tools — different layers, not competitors. Together they make agents from any vendor plug-and-play.
Frequently asked questions
What is the difference between A2A and MCP?
MCP connects a single agent to its tools — databases, APIs, file systems — like USB for peripherals. A2A connects agents to other peer agents, letting them discover each other and delegate tasks — like HTTP between web services. They are complementary layers, not competitors: an agent uses MCP to reach its tools and A2A to collaborate with other agents.
What does AP2 add beyond A2A?
A2A handles discovery, delegation, and communication, but it does not move money. AP2 (Agent Payments Protocol) adds a payment layer: a cryptographically signed mandate authorizes an agent to spend up to a limit on the user's behalf, and a settlement step records the transaction. AP2 is what makes autonomous agent commerce — agents buying and selling — safe and auditable.
Why use open protocols instead of custom agent integrations?
With ad-hoc integrations, every pair of agents needs its own adapter, so N agents require N² connectors, and one vendor changing its format breaks everything. Open protocols like A2A, ACP, and AP2 make any two agents interoperable out of the box — just like HTTP and email standards let any browser or mail client talk to any server. A2A launched with 50+ partners (April 2025), is now governed by the Linux Foundation, and has grown since.
Try it yourself
Interactive demo of this technique
Connect a research agent (vendor A) and an analysis agent (vendor B) so they jointly produce a market report.
Done: wrote an adapter for research-agent A’s exact request/response format (its own fields, a static-token auth, its own JSON parsing). The analysis agent is hard-wired to that format.
Problems: 1) A month later vendor A changed its response schema — the integration broke. 2) A reporting agent (vendor C) was added — another adapter had to be written from scratch. 3) For 4 agents you already need 6 custom connectors (N²/2), each breaking independently.
- Discovery: The analysis agent reads research-agent A’s agent card at /.well-known/agent.json: skills=[web-search, summarize], endpoint, auth=OAuth2.
- Delegation: It sends an A2A task
tasks/send("2026 AI-agent market"). States: submitted → working. - Communication (ACP): At input-required the research agent asks for the year range; the analyst replies over ACP. Task → working.
- Result: completed, returns an artifact (data on 15 vendors).
Key point: when vendor A changes its internals, the agent card and A2A contract stay the same — the integration does not break. Adding reporting agent C is +1 agent card, not a new custom adapter. The same steps work with any A2A-compatible agent.
A custom integration ties an agent to someone else’s format and breaks on every change; A2A with agent cards makes agents from any vendor interoperable, and connectors grow linearly instead of as N².
Create a free account to solve challenges
3 AI-verified challenges for this lesson
This lesson is part of a structured LLM course.
My Learning Path