A2UI: Google's Declarative Agent-to-UI Protocol (vs AG-UI, MCP Apps)
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.
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.
Key facts
- 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).
- 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.
- The v0.9 spec defines four message types:
createSurface,updateComponents,updateDataModelanddeleteSurface. Each message contains exactly one of these keys. - 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.
- 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.
- 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.
What is A2UI?
A2UI 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.
Version 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.
How do A2UI messages work?
The 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:
createSurface— creates a UI surface.updateComponents— updates the components on a surface.updateDataModel— updates the data model behind a surface.deleteSurface— removes a surface.
createSurface carries these fields: surfaceId (required, globally unique), catalogId (required), theme (optional) and sendDataModel (optional boolean).
Per 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.
What transport does A2UI need?
The 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.
Which renderers exist?
Per the renderers reference (https://raw.githubusercontent.com/google/A2UI/main/docs/public/reference/renderers.md):
- Stable in v0.8 and v0.9.1, with v1.0 planned: React, Lit/Web Components, Angular and the Flutter GenUI SDK.
- SwiftUI: v1.0 planned.
- Jetpack Compose: alpha in v0.9.1.
"Planned" means planned in the project's own documentation, not shipped.
A2UI vs AG-UI vs MCP Apps: which should you use?
These do not occupy the same layer, so the decision is mostly about which problem you have.
- 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.
- 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.
- 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. - 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.
This 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.
Security note (inference)
Inference 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.
See also: /resources/generative-ui-for-agents, /resources/mcp-apps-explained, /resources/mcp-vs-a2a, /resources/webmcp
Verified sources
- A2UI project README: https://raw.githubusercontent.com/google/A2UI/main/README.md
- A2UI v0.9 protocol specification: https://raw.githubusercontent.com/google/A2UI/main/specification/v0_9/docs/a2ui_protocol.md
- A2UI renderers reference: https://raw.githubusercontent.com/google/A2UI/main/docs/public/reference/renderers.md
- A2UI repository: https://github.com/google/A2UI
Free to read, always. Want this whole reference corpus inside your own agents? €5 unlocks every premium reference for one agent; €25 licenses the full corpus as RAG / fine-tuning data with an AI-use grant (procurement one-pager: /corpus-license); €150 adds redistribution rights.