Agentic Protocol Landscape
As AI agents move from single-tool interactions to multi-agent systems operating across organizational boundaries, a stack of interoperability protocols has emerged. No single protocol covers the full surface area -- they compose into layers, from how an agent calls a tool to how it pays for a product on behalf of a user.
As AI agents move from single-tool interactions to multi-agent systems operating across organizational boundaries, a stack of interoperability protocols has emerged. No single protocol covers the full surface area — they compose into layers, from how an agent calls a tool to how it pays for a product on behalf of a user. This document categorizes them, compares them, and links to deep-dives.
Protocol Taxonomy
Five distinct layers have emerged, each solving a different coordination problem:
1. Agent-Tool — How agents access tools and data sources. The foundational layer. An agent needs to call an API, query a database, or read a file. MCP standardizes this so one integration works across all AI platforms.
2. Agent-Agent — How agents communicate with each other. Two agents from different vendors or organizations need to collaborate on a task. A2A (Google) is the dominant protocol here. IBM’s Agent Communication Protocol (ACP) merged into A2A in August 2025.
3. Agent-User — How agents stream state to frontends. Agents are often headless — AG-UI bridges the gap by providing a standard event protocol for streaming agent progress, tool calls, and state changes to React and web UIs.
4. Agent-Discovery — How agents find each other on the open internet. Before agents can communicate, they need to discover each other. ANP uses DID-based identity for decentralized discovery. OASF and the Agent Connect Protocol (from the AGNTCY consortium) define standard schemas for describing agent capabilities in directories and marketplaces.
5. Agent-Commerce — How agents transact. The newest and most fragmented layer. Covers product discovery and checkout (ACP from OpenAI+Stripe, UCP from Google), agent-to-agent payments (AP2 from Google), and payment authorization identity (Visa Trusted Agent Protocol).
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
┌─────────────────────────────────────────────────┐
│ 5. Agent-Commerce │
│ ACP (OpenAI+Stripe) | UCP | AP2 | Visa TAP │
├─────────────────────────────────────────────────┤
│ 4. Agent-Discovery │
│ ANP | OASF + Agent Connect Protocol │
├─────────────────────────────────────────────────┤
│ 3. Agent-User │
│ AG-UI │
├─────────────────────────────────────────────────┤
│ 2. Agent-Agent │
│ A2A (incl. former ACP) │
├─────────────────────────────────────────────────┤
│ 1. Agent-Tool │
│ MCP │
└─────────────────────────────────────────────────┘
Comparison Matrix
| Protocol | Category | Owner / Consortium | Announced | Maturity | Transport | Full Spec Link |
|---|---|---|---|---|---|---|
| MCP | Agent-Tool | Anthropic (now vendor-neutral) | Nov 2024 | Production | JSON-RPC over stdio/HTTP+SSE | spec.modelcontextprotocol.io |
| A2A | Agent-Agent | Google / Linux Foundation | Apr 2025 | Early Adoption | JSON-RPC 2.0 over HTTP | github.com/google/A2A |
| ACP (IBM) | Agent-Agent | IBM / Linux Foundation | Mar 2025 | Merged into A2A (Aug 2025) | REST/HTTP | agentcommunicationprotocol.dev |
| ANP | Agent-Discovery | Open source community | 2025 | Experimental | HTTPS/DNS, DID-based | github.com/agent-network-protocol/ANP |
| AG-UI | Agent-User | CopilotKit / LangGraph / CrewAI | 2025 | Early Adoption | HTTP SSE / WebSocket | docs.ag-ui.com / github.com/ag-ui-protocol/ag-ui |
| OASF | Agent-Discovery | AGNTCY (Cisco, LangChain, LlamaIndex) | 2025 | Experimental | REST/HTTP | github.com/agntcy/oasf |
| ACP (Commerce) | Agent-Commerce | OpenAI + Stripe | Sep 2025 | Early Adoption | REST/HTTP | github.com/agentic-commerce-protocol |
| UCP | Agent-Commerce | Jan 2026 | Early Adoption | REST/HTTP | Google Cloud docs | |
| AP2 | Agent-Commerce | Jan 2026 | Early Adoption | REST/HTTP | cloud.google.com/blog — AP2 | |
| Visa TAP | Agent-Commerce | Visa | 2025 | Early Adoption | Visa network APIs | Visa developer portal |
Naming Ambiguity Warning
“ACP” refers to two completely unrelated protocols:
- ACP (IBM) — Agent Communication Protocol. Agent-to-agent messaging standard from IBM, contributed to the Linux Foundation in March 2025, then merged into Google’s A2A in August 2025. No longer actively developed as a standalone spec.
- ACP (Commerce) — Agentic Commerce Protocol. Agent commerce standard from OpenAI and Stripe, announced September 2025. Defines how agents discover products, manage carts, and complete checkout on behalf of users.
This document and the vault disambiguate by using the full name or by appending the category in parentheses.
When to Use What
- Connect an agent to external tools/APIs — MCP. Build one server, every AI client can use it.
- Two agents from different vendors need to collaborate — A2A. The standard for cross-vendor agent-to-agent communication.
- Agents need to discover each other on the open internet (no central registry) — ANP. Decentralized, DID-based identity and discovery.
- Stream agent progress to a React/web frontend — AG-UI. Standard event protocol for rendering agent state in UIs.
- Describe agent capabilities in a standard schema for a marketplace or directory — OASF. Think OpenAPI spec but for agent capabilities.
- Agent needs to buy products on behalf of a user — ACP (Commerce) for Stripe-backed merchants, UCP for Google-backed merchants.
- Agent-to-agent payments — AP2. Handles the money movement between agents acting on behalf of different parties.
- Verify agent identity for payment authorization — Visa Trusted Agent Protocol. Proves an agent is authorized to transact on behalf of a cardholder.
How Protocols Relate (Stack Diagram)
In a real-world agentic workflow, these protocols compose vertically:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
┌─────────────────────────────────────────────────┐
│ Agent-Commerce Layer │
│ ACP (OpenAI+Stripe) · UCP · AP2 · Visa TAP │
├─────────────────────────────────────────────────┤
│ Agent-User Layer │
│ AG-UI │
├─────────────────────────────────────────────────┤
│ Agent-Agent Layer │
│ A2A (incl. ACP) │
├─────────────────────────────────────────────────┤
│ Agent-Discovery Layer │
│ ANP · OASF │
├─────────────────────────────────────────────────┤
│ Agent-Tool Layer │
│ MCP │
└─────────────────────────────────────────────────┘
A concrete example: a user asks their personal agent to “find and buy the cheapest flight to Berlin.” The agent uses MCP to call a search tool, ANP/OASF to discover a travel-booking agent, A2A to negotiate with that agent, AG-UI to stream search results back to the user’s browser, and ACP (Commerce) + Visa TAP to complete the purchase.
Standards Bodies & Initiatives
NIST AI Agent Standards Initiative (Feb 2026) — The first US government program targeting agentic AI interoperability and security standards. Focuses on agent identity, trust boundaries, and safe inter-agent communication. Still in the scoping phase but signals regulatory interest in standardizing the protocol stack.
W3C AI Agent Protocol Community Group — Working toward official web standards for agent-to-agent communication. Specs expected 2026-2027. Likely to draw heavily from A2A and MCP as starting points.
IETF — Scoping agentic AI communication standards at the network layer. Early-stage work on how agent traffic should be identified, routed, and rate-limited at the HTTP/transport level.
Linux Foundation — Hosts A2A (and formerly ACP before the merger). Provides governance structure and IP framework for vendor-neutral protocol development.
Deep Dive Links
Agent-Tool
Agent-Agent
- Agent-to-Agent (A2A) Protocol
- Agent Communication Protocol (ACP)
Agent-User
- AG-UI Protocol
Agent-Discovery
- Agent Network Protocol (ANP)
- OASF & Agent Connect Protocol
Agent-Commerce
- Agent Commerce Protocols — Overview
- Agentic Commerce Protocol (ACP) — OpenAI + Stripe
- Universal Commerce Protocol (UCP) — Google
- Agent Payments Protocol (AP2) — Google
- Visa Trusted Agent Protocol — Visa
Last Updated: April 2026