Search tools, AI agents, MCP servers
Submit a tool

Search iThub

Search tools, categories and collections. Type at least two characters.

Explore all tools
↑ ↓ to explore resultsEnter to open · Esc to close

A2UI

Generative UI protocol and SDKs: agents stream JSON UI that apps render with their own native components

Agent FrameworksOpen sourcev1.0

A2UI at a glance

Pricing
Open source
License
Open source
Version
v1.0Checked November 21, 2026
Language
TypeScript
Data location
No hosted service: agent SDKs run on the developer's own agent server and renderers inside the client app; data stays wherever the application and its chosen model provider process it.
Maker
a2ui-project
Founded
2025

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, updateDataModel and a message to delete a surface, and createSurface can carry initial components and data in a single message. Components are sent as a flat list linked by IDs, with one component named root. 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 FlightCard and, 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 action message back to the agent. Version 1.0 adds bidirectional function calls: callRendererFunction for agent calls into the client and callAgentFunction for 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_core core library and the @a2ui/markdown-it Markdown 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_flutter package on pub.dev, built on the Dart a2ui_core package, 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 = value data 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-a2a Python package, which advertises support on the agent card and streams messages as application/a2ui+json data parts. Google ADK is supported through a2ui-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 as a2ui:// 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 codegen generates typesafe component builders from a catalog, and a2ui lint checks catalog files against protocol rules for v0.9, v0.9.1 and v1.0, with a --fatal-warnings option for CI. Release 0.4.0 requires a2ui_core 0.8 and adjusts generated Python v1.0 builders for the @checks key.
  • 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 zod

Reviews of A2UI

No reviews yet

Be the first to share your experience with A2UI.

Loading review form…

Found A2UI useful? Upvote it todayYour vote helps other IT teams find it in the daily ranking.

Similar to A2UI

Compare:A2UI vs OpenUIA2UI vs Agent ZeroA2UI vs OpenComputer

  1. OpenUIGenerative UI framework by Thesys that renders streamed OpenUI Lang model output with your own componentsWeb Frameworks & UI Libraries5 views
  2. Agent ZeroOpen-source AI agent framework with its own Linux workspaceAgent Frameworks8 views
  3. OpenComputerHosted platform for TypeScript agents and a Slack coding agent, with sandboxes, durable sessions and an APIAgent Frameworks5 views
  4. CrewAIMIT-licensed Python framework for role-based agent crews and event-driven flows, with the CrewAI AMP platformAgent Frameworks31 views
  5. LangChainOpen-source framework for LLM agents, with LangGraph and LangSmithAgent Frameworks31 views
  6. LlamaIndexOpen-source agent framework and LlamaParse document parsingAgent Frameworks22 views
  7. Hermes AgentSelf-hosted AI agent by Nous Research with persistent memory, self-written skills, cron jobs and chat gatewaysAgent Frameworks12 views
  8. borg (Rust agent runtime)Supervised Rust runtime that runs LLM agent pipelines with cancellation, panic isolation, budgets and checkpointsAgent Frameworks10 views