What is A2UI?
A2UI (Agent-to-User Interface) is an open-source generative UI framework. An AI agent describes an interactive interface as a stream of JSON messages, and the client application draws that interface with its own native widgets instead of receiving HTML or JavaScript. The project consists of a protocol specification, renderer libraries for web and mobile frameworks, and agent SDKs that turn model output into valid protocol messages. Its official website presents it as a way for agents to answer with cards, forms and other controls in addition to text.
Google introduced A2UI as an open project on December 15, 2025, with the format at version 0.8, in a Google Developers Blog post that named Opal, Gemini Enterprise, the Flutter GenUI SDK and CopilotKit (AG-UI) as early contributors and adopters. The source code now lives in the a2ui-project organization on GitHub. Contributions still require the Google Contributor License Agreement and follow Google's open source community guidelines, according to CONTRIBUTING.md, and the 1.0 announcement was published by the Google A2UI Team. The project publishes no separate foundation or steering body.
Compatibility between agents and renderers is defined by the protocol specification version. A2UI 1.0 was announced on November 11, 2026 in the A2UI 1.0 post as the first stable version of the protocol, and the repository marks v1.0 as current with v0.9.1 and v0.9 as previous versions and v0.8 as deprecated. Version 1.0 was previously developed as 0.10; it adds bidirectional function calls between agent and renderer, mixing several catalogs on one surface, accessibility attributes, extension metadata and the reserved @ prefix for bindings such as @path. The evolution guide lists the changes from v0.9. The roadmap mentions a protocol 1.1 for which requirements are being collected.
The repository is a monorepo with independently versioned packages, so its GitHub releases do not carry the protocol version. The release GitHub marks as Latest, cli-v0.4.0 from November 17, 2026, only covers the A2UI command line tool; on the same day the project also tagged Swift 0.11.0 and the Python packages a2ui-core 0.7.0, a2ui-agent-sdk 0.12.0 and a2ui-a2a 0.4.0. The web renderers are published on npm as @a2ui/* 0.14 and 0.15 releases, and the Dart packages on pub.dev, for example a2ui_flutter 0.4.0.
A2UI is licensed under Apache-2.0. It does not ship a hosted service: the agent SDK runs inside the developer's own agent server, the renderer runs inside the client app, and the transport between them is chosen by the application. Model selection, tool execution, conversation state and hosting stay outside the framework. Similar projects on iThub include OpenUI, which the A2UI community page lists as a related generative UI profile with its own OpenUI Lang format, and AG-UI, the agent-to-application event protocol that can carry A2UI messages.
Key capabilities
- Declarative UI messages Agents send JSON envelopes instead of executable code. In v1.0 the agent-to-renderer messages include
createSurface,updateComponents,updateDataModeland a message to delete a surface, andcreateSurfacecan carry initial components and data in a single message. Components are sent as a flat list linked by IDs, with one component namedroot. The v1.0 specification defines the envelopes, composition model and processing rules. - Surfaces A surface is a region of the client screen that the agent fills, identified by a
surfaceId. One conversation can hold several surfaces, for example an inline card in the chat and a persistent sidebar, and each has its own component tree and data model. The renderer only touches the subtrees that change, so unchanged controls keep focus and local state. - Data model and binding Each surface has a JSON data model updated by JSON Pointer paths. Component properties bind to paths such as
/outbound/pax, collection templates repeat components over arrays, and input controls write user edits back to the local model without a round trip to the agent. The overview page traces a flight booking example through these steps. - Component catalogs A catalog is a JSON Schema document that lists the components and functions a client can render. Agents can only use components from the catalogs the client advertises, and the agent SDK validates every message against them before sending. The Basic Catalog ships with every official renderer and takes its styling from the host framework theme; applications can add domain catalogs such as a
FlightCardand, in v1.0, mix several catalogs on one surface. See the catalogs documentation. - Security model The project describes A2UI as data, not code: payloads are validated against a schema, arbitrary executable code is not allowed, and every capability the agent uses is either a standard capability of the framework or one the app developer grants in a catalog. The README names remote or third-party agents that operate across a trust boundary as a target case. In v1.0, catalog functions declare which side may call them and whether they require a direct user action, such as
openUrl. - User actions and function calls When a user taps a control with an action, the renderer resolves the bound context values and sends an
actionmessage back to the agent. Version 1.0 adds bidirectional function calls:callRendererFunctionfor agent calls into the client andcallAgentFunctionfor client calls to the agent, with typed responses and errors. Renderer SDKs also send structured error messages and data model sync metadata. - Official web renderers React (
@a2ui/react), Lit web components (@a2ui/lit) and Angular (@a2ui/angular) are maintained in the repository and share the@a2ui/web_corecore library and the@a2ui/markdown-itMarkdown renderer. They support protocol versions v0.8, v0.9.1 and v1.0. A setup is installed with, for example,npm install @a2ui/react @a2ui/web_core @a2ui/markdown-it zod, as shown in the client integration guide. - Flutter renderer The
a2ui_flutterpackage on pub.dev, built on the Darta2ui_corepackage, renders A2UI in Flutter apps for mobile, web and desktop and supports v0.9.1 and v1.0. Flutter samples in the repository registry come from the Flutter team's GenUI SDK project. The 1.0 announcement notes that the web and Flutter renderers can also run inside MCP Apps. - SwiftUI renderer The A2UISwiftCore, BasicCatalog, A2UISwiftUI and BasicCatalogSwiftUI libraries are distributed through Swift Package Manager from the repository root
Package.swift. They support protocol v0.9.1 and v1.0; the latest Swift release tag is 0.11.0. - Jetpack Compose renderer The Android renderer is developed in AndroidX rather than in the A2UI repository and is published on Google Maven as androidx.a2ui.compose. Its latest version is 1.0.0-alpha02 from October 21, 2026, and the SDK page lists protocol v0.9.1 support; the A2UI 1.0 post says v1.0 support is coming. A Material 3 catalog is provided as
material3-a2ui. - Agent SDKs Agent SDKs exist for Python (
a2ui-agent-sdk), TypeScript (@a2ui/agent) and Dart (a2ui_agent). They negotiate catalogs and protocol versions with the client, generate an A2UI skill and prompt instructions from the catalog schema, compile streaming model output into wire messages and validate them against live surface state so errors can be returned to the model. Python adds server-side macro expansion. The SDKs page lists packages and supported versions per language. - Inference formats Models do not have to write wire JSON. The default Express format is a compact DSL with component calls and
$/path = valuedata assignments that the SDK compiles into standard messages; Direct JSON lets the model emit wire JSON with chunk healing. The docs state that full JSON Schemas in a prompt use roughly twice the input tokens of compact component signatures, and that inference formats can change without client changes. - Transports A2UI defines message content, not delivery. The docs name AG-UI, A2A, MCP, Server-Sent Events, WebSockets and HTTP streaming as transports. The A2A extension is part of the v1.0 specification and is implemented by the
a2ui-a2aPython package, which advertises support on the agent card and streams messages asapplication/a2ui+jsondata parts. Google ADK is supported througha2ui-adk, and the agent integration guide covers the CopilotKit runtime for AG-UI. - MCP integration Four documented patterns connect A2UI and the Model Context Protocol: calling MCP tools from A2UI controls with
@a2ui/catalog-mcp, serving A2UI layouts asa2ui://resources from an MCP server, embedding MCP Apps HTML widgets inside an A2UI surface, and packaging an A2UI renderer inside an MCP App for hosts such as Claude Desktop, Cursor or VS Code. The MCP overview maps each pattern to a guide. - A2UI CLI The a2ui command line tool is written in Dart and distributed as standalone binaries for macOS, Linux and Windows.
a2ui codegengenerates typesafe component builders from a catalog, anda2ui lintchecks catalog files against protocol rules for v0.9, v0.9.1 and v1.0, with a--fatal-warningsoption for CI. Release 0.4.0 requiresa2ui_core0.8 and adjusts generated Python v1.0 builders for the@checkskey. - Composer, samples and evaluation A2UI Composer is a browser-based visual editor that generates A2UI JSON from prompts, and the CopilotKit A2UI Playground runs prompts and catalogs without local setup. The quickstart runs Travel A2UI from the A2UI Labs repository, a Python agent with React and Flutter clients. Maintained samples include restaurant finder clients for Lit, React, Angular and Flutter, and an evaluation framework built on Inspect AI scores model output against project datasets.
- Community renderers and libraries The community projects page lists third-party renderers for Vue, Svelte 5, React Native, Lynx, Compose Multiplatform, WeChat Mini Programs and terminal interfaces, plus Go libraries. These are maintained by their own authors, not by the A2UI maintainers, and many target v0.8 or v0.9 rather than v1.0.
Where A2UI fits
Adding generated UI to an agent chat
The documented flow starts with a catalog that lists the components the client can draw. The agent SDK generates an A2UI skill from that catalog, the agent calls its own domain tools, and the model answers with an A2UI block next to its prose. The SDK compiles and validates the block, the transport delivers createSurface, updateComponents and updateDataModel messages, and the renderer mounts the surface in the chat. The quickstart shows this with a trip planner.
One agent, several client platforms
Because the agent sends component descriptions rather than markup, the same agent output can be drawn by a React web client and a Flutter or SwiftUI mobile client, as in the Travel A2UI quickstart with one Python server and two clients. Each client registers implementations of the same catalog. Supported protocol versions differ per renderer: the web, Flutter and SwiftUI renderers support v1.0, while the Jetpack Compose renderer currently lists v0.9.1.
Domain components for a product
Teams define custom components such as a flight card, product tile or chart in a catalog JSON Schema and implement them once per platform. The catalog guide covers prompt instructions and metadata, and Universal Web Components let one custom web component register in Lit, React and Angular. a2ui codegen produces typesafe builders from the same catalog, and a2ui lint checks the schema.
Remote and third-party agents
When the agent runs on another server or belongs to another organization, the A2A extension lets it advertise A2UI support on its agent card and stream UI as data parts, while the client decides which catalogs it accepts. The Google launch post describes this multi-agent case as a main reason for the project. The A2A transport is defined in the v1.0 A2A extension specification.
Agents served through AG-UI and CopilotKit
Applications built on the AG-UI protocol can carry A2UI surfaces inside the AG-UI event stream. With the CopilotKit runtime, enabling injectA2UITool injects an A2UI generation tool and translates tool calls and state deltas into AG-UI events for backends such as Google ADK, LangGraph and AWS Strands. In this setup AG-UI handles the agent run and its events, while A2UI describes the interface.
UI from MCP servers
An MCP server can publish reusable A2UI layouts as a2ui:// resources and return small data model updates from tool calls, so the client renders native components instead of an embedded HTML app. In the other direction, an A2UI surface can host MCP Apps widgets in a sandboxed iframe, and an A2UI web or Flutter renderer can be packaged inside an MCP App for hosts that only support MCP Apps.
Install
npm install @a2ui/react @a2ui/web_core @a2ui/markdown-it zodReviews of A2UI
Be the first to share your experience with A2UI.
Write a review
Loading review form…
Found A2UI useful? Upvote it todayYour vote helps other IT teams find it in the daily ranking.






