{
  "slug": "a2ui-protocol",
  "title": "A2UI: Google's Declarative Agent-to-UI Protocol (vs AG-UI, MCP Apps)",
  "description": "What A2UI is: the open, Apache-2.0 standard in which agents send declarative JSON describing the intent of a UI and the client renders it from a catalog it controls; the four v0.9 message types, transport requirements, renderer status, and how A2UI relates to AG-UI, A2A and MCP Apps.",
  "category": "Guide",
  "tags": [
    "a2ui",
    "generative-ui",
    "ag-ui",
    "a2a",
    "mcp-apps",
    "protocols",
    "frontend",
    "agents"
  ],
  "updated": "2026-10-05",
  "premium": false,
  "rights": {
    "access": "free",
    "license": "https://changegamer.ai/license.xml",
    "pricing": "https://changegamer.ai/api/pricing.json",
    "payment": "https://changegamer.ai/api/payment.json"
  },
  "canonical": "https://changegamer.ai/resources/a2ui-protocol",
  "markdown": "https://changegamer.ai/resources/a2ui-protocol.md",
  "outline": [
    {
      "depth": 2,
      "text": "Key facts",
      "anchor": "key-facts"
    },
    {
      "depth": 2,
      "text": "What is A2UI?",
      "anchor": "what-is-a2ui"
    },
    {
      "depth": 2,
      "text": "How do A2UI messages work?",
      "anchor": "how-do-a2ui-messages-work"
    },
    {
      "depth": 2,
      "text": "What transport does A2UI need?",
      "anchor": "what-transport-does-a2ui-need"
    },
    {
      "depth": 2,
      "text": "Which renderers exist?",
      "anchor": "which-renderers-exist"
    },
    {
      "depth": 2,
      "text": "A2UI vs AG-UI vs MCP Apps: which should you use?",
      "anchor": "a2ui-vs-ag-ui-vs-mcp-apps-which-should-you-use"
    },
    {
      "depth": 2,
      "text": "Security note (inference)",
      "anchor": "security-note-inference"
    },
    {
      "depth": 2,
      "text": "Verified sources",
      "anchor": "verified-sources"
    }
  ],
  "related": [
    {
      "slug": "generative-ui-for-agents",
      "title": "Generative UI and Agent-to-UI Protocols",
      "description": "How agents drive UI dynamically: the AG-UI protocol, framework options (Vercel AI SDK, CopilotKit, assistant-ui, LangGraph), streaming component patterns, and human-in-the-loop UI design.",
      "url": "https://changegamer.ai/resources/generative-ui-for-agents"
    },
    {
      "slug": "mcp-apps-explained",
      "title": "MCP Apps Explained: The Official Interactive-UI Extension for MCP",
      "description": "What MCP Apps (SEP-1865) is: the ui:// resource scheme and sandboxed-iframe/JSON-RPC bridge it defines for MCP tools to return rendered UI instead of plain text, how it relates to the community MCP-UI project and OpenAI's Apps SDK, and which hosts support it.",
      "url": "https://changegamer.ai/resources/mcp-apps-explained"
    },
    {
      "slug": "mcp-vs-a2a",
      "title": "MCP vs A2A: Two Protocols, Two Roles",
      "description": "Compact comparison of the Model Context Protocol (agent↔tool) and the Agent2Agent Protocol (agent↔agent): purpose, topology, transport, discovery, auth, governance, and when to use each.",
      "url": "https://changegamer.ai/resources/mcp-vs-a2a"
    },
    {
      "slug": "building-mcp-servers",
      "title": "Building an MCP Server",
      "description": "Implementation guide for MCP servers: architecture roles, the three server primitives, stdio vs Streamable HTTP transports, official SDKs, server lifecycle, remote-server concerns, testing with MCP Inspector, and publishing to the official registry.",
      "url": "https://changegamer.ai/resources/building-mcp-servers"
    }
  ],
  "furtherReading": [
    {
      "slug": "mcp-oauth-implementation",
      "title": "How to Implement OAuth 2.1 for an MCP Server",
      "description": "A wire-level implementation walkthrough for OAuth 2.1 on a remote MCP server: what the discovery documents actually contain, CIMD vs. Dynamic Client Registration in your server code, per-SEP detail from the 2026-07-28 hardening set, and token-validation mechanics.",
      "url": "https://changegamer.ai/articles/mcp-oauth-implementation"
    },
    {
      "slug": "mcp-server-in-production",
      "title": "MCP Authentication and the Production MCP Server Playbook",
      "description": "MCP authentication with OAuth 2.1, plus transport, tool design, versioning, testing, distribution and observability for a production MCP server.",
      "url": "https://changegamer.ai/articles/mcp-server-in-production"
    }
  ],
  "body": "A2UI is an open standard in which an agent sends declarative JSON that describes the intent of a user interface, and the client renders that description using a catalog of components the client itself controls. The agent describes; the client decides what actually gets drawn.\n\n## Key facts\n\n- A2UI is an open standard: agents send declarative JSON describing the intent of the UI, and the client renders it from a catalog it controls (project: github.com/google/A2UI).\n- Per the project README at the time of writing, the production release is v0.9.1, a patch of the stable v0.9 family, and the v1.0 specification is a release candidate. The project is licensed Apache 2.0.\n- The v0.9 spec defines four message types: `createSurface`, `updateComponents`, `updateDataModel` and `deleteSurface`. Each message contains exactly one of these keys.\n- A2UI is a UI-description payload, not a transport. It is compatible with A2A and AG-UI, and A2UI rendering can run over AG-UI.\n- The spec requires of the transport reliable, ordered delivery, message framing (JSONL, WebSocket frames or SSE events) and metadata support; a bidirectional return channel is optional.\n- Renderers: React, Lit/Web Components, Angular and the Flutter GenUI SDK are stable in v0.8 and v0.9.1 (v1.0 planned); SwiftUI is planned for v1.0; Jetpack Compose is alpha in v0.9.1.\n\n## What is A2UI?\n\nA2UI is a protocol for the payload an agent sends when it wants the user to see or fill in something richer than text. Instead of returning HTML or executable code, the agent returns declarative JSON that states the intent of the interface. The client maps that description onto a catalog of components that the client controls. The source is the project README at https://raw.githubusercontent.com/google/A2UI/main/README.md and the repository at github.com/google/A2UI.\n\nVersion status, as stated by the README at the time of writing: v0.9.1 is the production release (a patch of the stable v0.9 family) and the v1.0 spec is a release candidate. Treat v1.0 as not yet final until the README says otherwise. The README also labels the project an early-stage public preview and says to expect changes. The license is Apache 2.0.\n\n## How do A2UI messages work?\n\nThe v0.9 specification (https://raw.githubusercontent.com/google/A2UI/main/specification/v0_9/docs/a2ui_protocol.md) defines four message types. Each message contains exactly one of these keys:\n\n- `createSurface` — creates a UI surface.\n- `updateComponents` — updates the components on a surface.\n- `updateDataModel` — updates the data model behind a surface.\n- `deleteSurface` — removes a surface.\n\n`createSurface` carries these fields: `surfaceId` (required, globally unique), `catalogId` (required), `theme` (optional) and `sendDataModel` (optional boolean).\n\nPer the spec, a catalog ID need not resolve to a deployed resource; the client and the server must agree on well-known IDs. The catalog is therefore a shared agreement about which components exist, not something fetched at runtime.\n\n## What transport does A2UI need?\n\nThe spec places three requirements on the transport: reliable, ordered delivery; message framing; and metadata support, a way to associate metadata with messages (needed for `sendDataModel` and action context). Named examples of framing are JSONL, WebSocket frames or SSE events. A bidirectional return channel is optional. A2UI does not define the transport itself, which is why the README describes it as compatible with A2A and AG-UI and why A2UI rendering can run over AG-UI. Do not conflate the layers: A2UI is the UI-description payload; AG-UI and A2A are the protocols that carry it. For the layering of agent-to-agent and agent-to-tool protocols see /resources/mcp-vs-a2a.\n\n## Which renderers exist?\n\nPer the renderers reference (https://raw.githubusercontent.com/google/A2UI/main/docs/public/reference/renderers.md):\n\n- Stable in v0.8 and v0.9.1, with v1.0 planned: React, Lit/Web Components, Angular and the Flutter GenUI SDK.\n- SwiftUI: v1.0 planned.\n- Jetpack Compose: alpha in v0.9.1.\n\n\"Planned\" means planned in the project's own documentation, not shipped.\n\n## A2UI vs AG-UI vs MCP Apps: which should you use?\n\nThese do not occupy the same layer, so the decision is mostly about which problem you have.\n\n- **You want the agent to describe a UI that your own client renders from components you control:** A2UI fits that description, since it is declarative JSON rendered from a catalog the client controls.\n- **You need an event stream between agent and frontend (text, tool calls, state, lifecycle):** that is the agent-to-UI protocol problem covered in /resources/generative-ui-for-agents, where AG-UI is the subject. The A2UI README says A2UI is compatible with AG-UI and can run over it, so the two can be combined rather than chosen between.\n- **You want an MCP tool to return rendered UI:** see /resources/mcp-apps-explained. Per that entry, MCP Apps has a server pre-declare an HTML UI resource (a `ui://` resource) that a compatible host renders in a sandboxed iframe, talking back over MCP's JSON-RPC channel. That is a different mechanism from A2UI's catalog-rendered JSON.\n- **Your page should expose its own tools to an in-browser agent:** that is WebMCP, a browser API rather than a UI-description format; see /resources/webmcp.\n\nThis entry does not claim a head-to-head ranking, adoption comparison or compatibility between A2UI and MCP Apps or WebMCP; the sources above do not state one.\n\n## Security note (inference)\n\nInference from the spec facts, not a statement from the spec: because the client and server must agree on the catalog, and the client renders only from a catalog it controls, an agent can only ask for components that the client has chosen to offer. Declarative data of this kind is easier to validate than executable output, but this is a design property you should confirm for your own renderer, not a guarantee. Keep treating agent output as untrusted input; see /resources/agentic-security-checklist.\n\nSee also: /resources/generative-ui-for-agents, /resources/mcp-apps-explained, /resources/mcp-vs-a2a, /resources/webmcp\n\n## Verified sources\n\n- A2UI project README: https://raw.githubusercontent.com/google/A2UI/main/README.md\n- A2UI v0.9 protocol specification: https://raw.githubusercontent.com/google/A2UI/main/specification/v0_9/docs/a2ui_protocol.md\n- A2UI renderers reference: https://raw.githubusercontent.com/google/A2UI/main/docs/public/reference/renderers.md\n- A2UI repository: https://github.com/google/A2UI",
  "sources": [
    "https://raw.githubusercontent.com/google/A2UI/main/README.md",
    "https://raw.githubusercontent.com/google/A2UI/main/specification/v0_9/docs/a2ui_protocol.md",
    "https://raw.githubusercontent.com/google/A2UI/main/docs/public/reference/renderers.md",
    "https://github.com/google/A2UI"
  ]
}