AI Agent Protocol Guide: MCP, A2A, UCP, AP2, A2UI, and AG-UI

Why 6 Protocols?

By late 2025, AI agents were working as standalone tools. Every integration required custom glue code. In 2026, things changed: with contributions from Google, Anthropic, CopilotKit, and the Linux Foundation, 6 open protocols are standardizing different layers of the agent ecosystem¹.

Each of these protocols answers a different question:

Protocol	Question	Developed by
MCP	What tools and data can the agent access?	Anthropic
A2A	How do agents discover each other and delegate tasks?	Google (Linux Foundation)
UCP	How is the commerce flow (discovery, cart, checkout) standardized?	Google + Shopify, Walmart, Etsy
AP2	How is payment securely authorized on behalf of the agent?	Google + Mastercard, PayPal, Adyen
A2UI	What does the agent show the user?	Google
AG-UI	How does the agent communicate with the frontend in real time?	CopilotKit

The protocols work as a stack, but they are modular: you use the layer you need, you don’t have to use all of them at once.

MCP: The Agent’s Connection to the Outside World

Model Context Protocol (MCP) is developed by Anthropic and enables agents to access tools, data, and external resources through a standard interface². It is the most mature of the 6 protocols.

The problem MCP solves is straightforward: instead of writing custom integrations for every API, database, and tool, you connect through a single standard. MCP servers provide tools and data, MCP clients (Claude Code, Cursor, etc.) connect to these servers.

Client (Claude Code) ──MCP──> Server (PostgreSQL)
                     ──MCP──> Server (GitHub)
                     ──MCP──> Server (Sentry)

I actively use 8+ MCP servers in my daily workflow: dnomia-knowledge (FTS5 + sqlite-vec hybrid search), Neon (PostgreSQL), Cloudflare, GitHub, and more. In the context engineering ecosystem post, I detail MCP’s role in the four-layer context architecture. In the Pre-injection vs MCP post, I compare the MCP tool loop with the pre-injection strategy.

Core concepts

• Tools: Functions the agent can call (database queries, file writes, API calls)
• Resources: Data the agent can read (files, schemas, configurations)
• Prompts: Pre-defined prompt templates

MCP’s strength lies in being agent-agnostic. The same MCP server works with Claude Code, Cursor, or any other MCP-compatible client.

A2A: Inter-Agent Communication

Agent2Agent (A2A) is an open protocol initiated by Google and transferred to the Linux Foundation³. It standardizes how agents discover each other, share capabilities, and delegate tasks.

While MCP enables an agent to talk to tools, A2A enables agents to talk to each other. That is the fundamental difference.

How does it work?

1. Agent Card: Each agent publishes its capabilities in a /.well-known/agent-card.json file. In JSON format: “I can do these things, I accept these inputs, I produce these outputs.”

2. Task lifecycle: Communication is task-oriented. A client agent sends a task to a remote agent. The task goes through a submitted > working > completed cycle.

3. Transport: JSON-RPC 2.0 over HTTPS. gRPC support was added starting from v0.3.

4. Security: Compatible with the OpenAPI specification. Supports API key, OAuth 2.0, and OpenID Connect.

{
  "name": "invoice-agent",
  "description": "Invoice creation and management agent",
  "capabilities": ["create_invoice", "send_reminder"],
  "endpoint": "https://api.example.com/a2a",
  "security": [{ "oauth2": { "flows": { "clientCredentials": {} } } }]
}

Practical perspective

I am not yet using A2A in production. However, the multi-model tribunal structure in the Decision Gate v2 post is a custom implementation of the problem A2A solves: multiple AIs independently evaluating the same task and merging the results. A2A standardizes these kinds of scenarios.

UCP: Standardized Commerce Flow

Universal Commerce Protocol (UCP) is an open protocol developed by Google together with Shopify, Etsy, Wayfair, Target, and Walmart⁴. It standardizes how AI agents can operate throughout the entire shopping journey (discovery, cart, checkout, post-sale).

Core capabilities (March 2026)

Capability	What it does
Cart	Agent can add multiple products to cart in a single operation
Catalog	Real-time price, inventory, and variant data retrieval
Identity Linking	Automatic application of loyalty/membership benefits
Native Checkout	Direct purchasing through Google Search AI Mode and Gemini

UCP is the infrastructure for e-commerce’s transition from a “site-centric” model to an “agent-centric” model. I examine the impact of this transition on conversion tracking, attribution, and remarketing in detail in the UCP: Agentic Commerce and the E-Commerce Ecosystem post.

A point worth noting

UCP is presented as an open standard, but the practical advantage is concentrated in the Google ecosystem: Search AI Mode + Gemini + Google Pay + Merchant Center. For e-commerce owners, the biggest risk is that most of the customer journey takes place on Google surfaces.

AP2: Cryptographic Payment Authorization

Agent Payments Protocol (AP2) is an open protocol developed by Google together with more than 60 organizations (Mastercard, PayPal, Adyen, American Express, Coinbase)⁵. It enables AI agents to make secure payments on behalf of users.

The problem AP2 solves: existing payment infrastructure was designed for “human-present” scenarios. Agents will make payments in “human-not-present” scenarios. This requires an entirely new security and authorization layer.

3 Mandate Types

AP2 uses a cryptographically signed Mandate (authorization document) system:

1. Intent Mandate: Defines under what conditions the agent can make purchases. For “human-not-present” scenarios. Example: “Can purchase up to $50 per month in office supplies.”

2. Cart Mandate: The user explicitly approves a specific cart. For “human-present” scenarios. The user’s cryptographic signature provides undeniable proof.

3. Payment Mandate: A document shared with the payment network and card issuer. Signals agent involvement and user presence/absence.

Mandates are signed with minimum ECDSA P-256 keys. Designed as an extension of A2A and MCP.

Why does it matter?

As agent commerce grows, scenarios like “the agent made a $5,000 purchase without my knowledge” are inevitable. AP2 prevents these scenarios with cryptographic proof: what the agent can buy and how much is limited by the user’s signature.

A2UI: What the Agent Shows

Agent-to-User Interface (A2UI) is a declarative UI protocol developed by Google⁶. It enables AI agents to produce rich, interactive user interfaces. Native rendering on web, mobile, and desktop.

18 Primitives

A2UI consists of 18 safe component primitives. The agent can compose these primitives to produce entirely different interfaces:

• Layout: Row, Column, Card, Divider
• Input: TextField, CheckBox, DateTimeInput, Select
• Display: Text, Image, Table, Chart
• Action: Button, Link

From the same 18 primitives: an inventory checklist, an order form, or a supplier comparison table can be created. No arbitrary code execution, just declarative blueprints.

Native-first approach

Instead of rendering an opaque payload in a sandbox, A2UI sends a native component blueprint. It inherits the host application’s styles and accessibility features. This ensures the agent UI looks consistent with the rest of the application.

Currently at v0.8 (Public Preview). Apache 2.0 licensed.

AG-UI: How the Agent Talks to the Frontend

AG-UI (Agent-User Interaction Protocol) is an open, lightweight, event-based protocol developed by CopilotKit⁷. It standardizes real-time communication between the agent backend and the frontend.

While A2UI answers “what to show”, AG-UI answers “how to deliver it”.

How does it work?

AG-UI sends a single JSON event stream (SSE) over standard HTTP. Event types:

• Messages: Chat messages (text, tool call results)
• Tool calls: Frontend or backend tool invocations
• State patches: Bi-directional synchronization of agent and application state
• Lifecycle signals: Start, end, error signals

Agent Backend ──SSE stream──> Frontend
              <──state sync──

Oracle, Google, and CopilotKit partnership

In 2026, Oracle, Google, and CopilotKit published a joint integration⁸: UI defined with A2UI is delivered to the frontend via AG-UI, and the agent is defined with Oracle’s Agent Spec. A “define once, render anywhere” approach.

How the Protocols Work Together

It is useful to think of the 6 protocols as a stack:

┌─────────────────────────────────────┐
│  A2UI + AG-UI  (User layer)         │  What the agent shows, how it delivers
├─────────────────────────────────────┤
│  A2A           (Agent layer)        │  Inter-agent discovery and delegation
├─────────────────────────────────────┤
│  UCP + AP2     (Commerce layer)     │  Shopping flow and payment security
├─────────────────────────────────────┤
│  MCP           (Tool layer)         │  Data and tool access
└─────────────────────────────────────┘

Practical scenario: A B2B purchasing agent connects to the supplier database via MCP. Delegates a price quote task to another agent via A2A. Manages the order flow via UCP. Authorizes the payment via AP2. Presents a confirmation interface to the user via A2UI. Delivers that interface in real time via AG-UI streaming.

Each protocol can also work independently. The “add protocols as you need them” principle applies: start with MCP, add the others as needed¹.

Practical Evaluation: Solo Developer Perspective

Protocol	Maturity	My usage	Assessment
MCP	Production-ready	8+ servers active	Indispensable. I use it every day
A2A	v0.3 (stable)	Not using	Will be needed for multi-agent scenarios
UCP	Early stage	Following	Critical for those doing e-commerce
AP2	Specification stage	Following	Too early for those not doing commerce
A2UI	v0.8 (preview)	Not using	Potential for dashboard/report UI
AG-UI	Active development	Not using	Promising for frontend agent interaction

I am not using any of them in production besides MCP. But the existence of these protocols matters: being able to integrate through a standard layer instead of writing custom glue code is a significant advantage for a solo developer. In the AI-assisted codebase audit post, I describe how MCP transformed the audit process from “dry file scanning” into “live system analysis”.

Open Questions

These protocols are still in their maturation phase. Questions that need answers:

1. Attack surface: Each of the 6 protocols is a new attack vector. OWASP’s “Top 10 for Agentic Applications 2026” list identifies these risks, but practical defense guides are still insufficient.

2. Vendor lock-in: Could UCP and AP2’s advantage within the Google ecosystem create a dependency beyond being an open standard?

3. Interoperability reality: The 6 protocols working together looks great in theory. In practice, how many different implementations and incompatibilities will emerge?

4. Governance: MCP belongs to Anthropic, A2A to the Linux Foundation, UCP/AP2 are Google-heavy, AG-UI belongs to CopilotKit. Can this distributed governance maintain consistency over the long term?

Time will answer these questions. For now, the most pragmatic approach: build a solid foundation with MCP, add the others as needed, and observe.

Footnotes

1. Developer’s Guide to AI Agent Protocols ↩ ↩²
2. Model Context Protocol ↩
3. Agent2Agent Protocol (A2A) ↩
4. UCP Updates ↩
5. Announcing Agent Payments Protocol (AP2) ↩
6. Introducing A2UI ↩
7. AG-UI: Agent-User Interaction Protocol ↩
8. Oracle adopts AG-UI protocol for Agent Spec ↩

Key Takeaways

• 01 MCP enables the agent to communicate with the outside world (databases, APIs, file systems). Developed by Anthropic, it is the most mature protocol.
• 02 A2A standardizes how agents discover each other and delegate tasks. Capability discovery via /.well-known/agent-card.json.
• 03 UCP standardizes e-commerce flows (discovery, cart, checkout) for agents. A partnership between Google, Shopify, and Walmart.
• 04 AP2 secures payment authorization with cryptographic mandates. Three mandate types: Intent, Cart, and Payment.
• 05 A2UI and AG-UI are complementary: A2UI defines what to render (18 primitives), AG-UI defines how to deliver it (SSE streaming, typed events).

Frequently Asked Questions (FAQ)

+ What is the difference between MCP and A2A?

MCP standardizes an agent's access to tools and data (agent-to-tool). A2A standardizes how agents communicate with each other (agent-to-agent). MCP answers 'what can I do', A2A answers 'who can I work with'.

+ What is the difference between A2UI and AG-UI?

A2UI is a declarative UI specification: the agent defines what should be rendered using 18 primitives. AG-UI is the transport layer: how that UI information is delivered to the frontend via SSE streaming and typed events. A2UI answers 'what', AG-UI answers 'how'.

+ Do I have to use all of these protocols?

No. The principle of 'add protocols as you need them' applies. Start with MCP, add A2A if you need inter-agent communication, add UCP/AP2 if you're doing commerce. The protocols are modular and can work independently.

+ Why is AP2 necessary? Aren't existing payment systems enough?

Existing payment systems were designed for human-present scenarios. AI agents will make payments in human-not-present scenarios. AP2 documents the user's intent in a provable way through cryptographic mandates and limits the agent's authority.