Scope
The 2025–2026 wave of open protocols that let agents connect outward — to tools, to other agents, to users, and to payment rails. One mental model (the protocol triangle), then each protocol: what it is, who made it, status, the message flow, and pros/cons/when. This whole space is bleeding-edge and churns fast — treat versions/dates as snapshots and re-check the primary source.
Related: Gen AI Engineer · 05 - Model Context Protocol (MCP) · 08 - Agents & Agentic Systems · 10 - Multi-Agent Systems · 18 - Multimodal, Voice & Computer-Use · 14 - Safety, Security & Risk
1. The mental model — the protocol triangle
An agent has exactly three directions it needs to connect, and a protocol has emerged for each:
The one framing to remember
MCP gives an agent hands. A2A lets agents converse. AG-UI puts the agent in front of a human.
- MCP — agent ↓ tools/data (vertical). The other end is passive: it just exposes capabilities.
- A2A — agent ↔ agent (horizontal). The other end is an autonomous peer with its own reasoning and state.
- AG-UI — agent ↑ user/frontend (upward). Streaming, shared state, human-in-the-loop into a real app.
They compose: an A2A peer can itself be an MCP host that drives an AG-UI frontend. The commerce and UI-render layers ride on top — AP2 extends A2A; A2UI travels inside AG-UI/A2A.
| Axis | Protocol | Other end | Analogy |
|---|---|---|---|
| ↓ tools/data | MCP | passive capability provider | hands |
| ↔ agent | A2A | autonomous peer agent | conversation |
| ↑ user | AG-UI | a frontend / human | the face |
| ↑ user (what to render) | A2UI | a UI renderer | the face’s expressions |
| 💳 payments | AP2 | merchant + payment network | the wallet |
2. MCP — Model Context Protocol (recap & positioning)
Covered in full in 05 - Model Context Protocol (MCP). Here’s only how it sits in the stack:
- Agent ↔ tools/data (the vertical axis). Roles: Host (LLM app), Client (connector), Server (capabilities: Resources / Prompts / Tools). JSON-RPC 2.0 over stdio or Streamable HTTP.
- Created by Anthropic (Nov 2024); donated to the Agentic AI Foundation (Linux Foundation) in Dec 2025. Current spec revision
2025-11-25. - The distinction that matters: MCP’s far end is passive — it answers calls. A2A’s far end is an active agent. If you’re “calling a tool,” that’s MCP; if you’re “delegating to another agent,” that’s A2A.
3. A2A — Agent2Agent Protocol
At a glance
Agent ↔ agent. Created by Google (Apr 2025), donated to the Linux Foundation Jun 2025 (founding members AWS, Cisco, Google, Microsoft, Salesforce, SAP, ServiceNow; 150+ orgs). Now v1.0.0 stable. Lets agents built on different frameworks/vendors discover each other and delegate tasks — opaquely, without exposing internal tools or IP.
Core concepts:
- Agent Card — JSON at
https://{domain}/.well-known/agent-card.json: identity, skills, endpoint, security schemes, transports, optional signature. This is how agents discover each other. - Task — the stateful unit of work:
id,contextId,status,artifacts[],history[]. - Lifecycle:
submitted → working → (input-required | auth-required) → completed | failed | canceled | rejected. - Message → Parts (text/file/data) → Artifact (the output).
Flow: discover (GET the Agent Card) → message/send (or message/stream) creates a Task → it runs (working, may pause for input-required) → results stream back over SSE (or poll tasks/get, or get pushed to a webhook) → terminal state + artifacts.
Transport: JSON-RPC 2.0 core, with three v1.0 bindings — JSON-RPC/HTTPS, gRPC, HTTP+JSON/REST. Streaming = SSE; async push = webhooks.
| Pros | Cons / caveats |
|---|---|
| Vendor-neutral, heavyweight backing (LF) | Young; multi-binding interop is uneven |
| Built on boring standards (HTTP/JSON-RPC/SSE) | New security model (signed cards) unproven at scale |
| Async-first: poll / stream / push | 0.x deployments drift — method names + card path (agent.json vs agent-card.json) differ; the /dev channel is unstable |
| Complements MCP cleanly | Overkill if one agent just calls tools → use MCP |
When to reach for A2A
Multi-agent systems spanning different vendors/frameworks, delegating to a specialist external agent, or long-running async cross-org workflows. Not for “my agent uses a tool” (MCP) and usually not for agents inside one codebase (just call functions — see 10 - Multi-Agent Systems).
4. AG-UI — Agent-User Interaction Protocol
At a glance
Agent ↔ user/frontend. Created by CopilotKit (community
ag-ui-protocol, MIT); adopted by the Microsoft Agent Framework. Pre-1.0 but widely used. A standard event stream so every framework stops reinventing how an agent talks to a UI — streaming text, tool calls, shared state, and human-in-the-loop.
~17 event types, in families:
- Lifecycle —
RUN_STARTED,RUN_FINISHED,RUN_ERROR,STEP_STARTED/FINISHED - Text —
TEXT_MESSAGE_START→TEXT_MESSAGE_CONTENT(token deltas) →TEXT_MESSAGE_END - Tool —
TOOL_CALL_START→TOOL_CALL_ARGS(streamed) →TOOL_CALL_END→TOOL_CALL_RESULT - State —
STATE_SNAPSHOT(full),STATE_DELTA(JSON Patch / RFC 6902, bidirectional),MESSAGES_SNAPSHOT - Special —
RAW,CUSTOM← this is the slot A2UI rides in
Flow: frontend sends RunAgentInput (threadId, runId, tools, context) → RUN_STARTED → text deltas render live → tool-call events → STATE_DELTA patches (both sides read/write shared agent.state) → RUN_FINISHED.
Transport: JSON events, transport-agnostic via middleware — SSE, WebSocket, HTTP, or webhooks (it is not locked to SSE).
| Pros | Cons / caveats |
|---|---|
| One event vocabulary, framework-agnostic | Pre-1.0 — event set still shifting |
| Live streaming + shared state + HITL built in | Cheapest value if you use a CopilotKit frontend |
| Maps directly onto LangGraph streaming (see LangGraph Senior Prep) | Transport flexibility = more integration choices to make |
5. A2UI — Agent-to-User Interface
A2UI is NOT the same as AG-UI
Common confusion — they’re complementary, at different layers:
- AG-UI = the transport/streaming/state plumbing (HOW events flow between agent and frontend).
- A2UI = the UI description format (WHAT widgets to render).
- They combine: AG-UI carries A2UI payloads inside its
CUSTOMevents; A2UI can also travel over A2A messages (one agent hands a UI to another).
At a glance
Google, home
a2ui.org, Apache 2.0, public Dec 2025 (v0.8 → v0.9 → v1.0 candidate — pre-1.0, fast-moving). Lets an agent generate the UI itself — e.g. emit a reservation form instead of another chat turn — as a declarative JSON component description rendered natively on Web (Lit/Angular), Flutter, SwiftUI, Android.
Design principles: declarative, not executable (“safe like data, expressive like code”); the agent may only reference component types in a client-maintained trusted catalog (no arbitrary code execution); flat adjacency-list layout streamed as JSONL for progressive render; bidirectional surface state. Contrast with MCP Apps (UI rendered sandboxed/iframe-like) — A2UI is native-first and inherits host styling.
6. AP2 — Agent Payments Protocol
Pre-1.0 — prototypes only
Google + 60+ partners (Mastercard, PayPal, Coinbase, Amex, Adyen, …), announced Sept 2025, standardization via the FIDO Alliance. Currently v0.2 — unstable, reference implementations only. Do not move real money in production until ≥1.0 lands. Prompt-injection attack papers already exist.
Lets an agent buy on a user’s behalf with cryptographic authorization, accountability, and audit trail, without changing existing card-network rails. The core is three signed mandates (W3C Verifiable Credentials, chained and tamper-evident):
- Intent Mandate — the user signs scope/constraints (“buy X under $Y”).
- Cart Mandate — the merchant binds the exact items + price to that intent (“what you see is what you pay”).
- Payment Mandate — a minimal credential giving the network visibility into agent presence (Human-Present vs Not-Present).
The signed chain is the audit trail. AP2 is an extension of A2A; stablecoin settlement uses the x402 extension. Payment-agnostic (cards, bank, crypto).
7. ACP — Agent Communication Protocol (legacy)
Merged into A2A — do not adopt for new work
IBM Research / BeeAI (Mar 2025). In Aug 2025 the ACP team announced it is winding down and contributing its tech directly to A2A; BeeAI itself moved to A2A. ACP matters now only as A2A’s lineage and for migrating existing BeeAI deployments. It was REST-native (plain HTTP, no SDK), with multipart-MIME messages and local-first/offline discovery — ideas partly carried into A2A.
8. Other 2025–2026 advances worth knowing
| Thing | What it is | Status |
|---|---|---|
| x402 (Coinbase) | Reuses HTTP 402 Payment Required: agent hits 402 → signs a stablecoin tx → retries with proof. AP2’s stablecoin layer. | Most production traction of the payment protocols |
| WebMCP (Google) | Structured agent ↔ website interaction (declarative form API + imperative JS API) | Chrome Canary preview (early 2026), experimental |
| Anthropic Computer Use | Agent drives screen/browser (see 18 - Multimodal, Voice & Computer-Use) | Beta, productizing |
| AGNTCY / Internet of Agents (Cisco) | Agent Connect Protocol — discovery, identity, group comms, observability | Donated to LF (Jul 2025); young |
| ANP (Agent Network Protocol) | “HTTP of the agentic internet” — open-network discovery/identity/auth | Standards-track, low production traction |
| Agentic memory | Portable/mesh memory proposals; frameworks Letta/MemGPT, Mem0, Zep | No ratified standard — the clearest gap (see 11 - Memory for LLM Apps) |
9. Stability scorecard
Re-verify before you build on any of these
The durable thing is the mental model (which axis each protocol owns). The volatile things — version numbers, spec dates, which body governs what — change monthly.
| Tier | Protocols |
|---|---|
| ✅ Stable / production | MCP (2025-11-25, LF), A2A (v1.0, LF), x402 (live) |
| 🟡 1.0-ish but young / single-vendor origin | AG-UI, A2UI (v0.9→1.0 candidate), AP2 (v0.2) |
| 🔵 Preview | WebMCP (Canary), AGNTCY stack, MCP Tasks primitive |
| ⚪ Research, not a standard | ANP, agentic-memory proposals |
| ⛔ Legacy / sunset | ACP (merged into A2A) |
Sources
- MCP: spec 2025-11-25 · Anthropic AAIF donation
- A2A: LF launch · spec · A2A & MCP
- AG-UI: docs / events · GitHub · the 17 event types
- A2UI: Google introduction · a2ui.org · AG-UI + A2UI explained
- AP2: Google Cloud launch · ap2-protocol.org
- ACP→A2A: LF AI & Data merger
- x402: github.com/coinbase/x402