A2UI is an open source agent-driven interface protocol initiated by Google, which allows agents to output declarative JSON UI and be safely rendered into native interfaces by different renderers.

A2UI tool text

Core parameters and statistics

Parameters	Current public information	Description
Product positioning	Agent-driven UI protocol	Not terminal SaaS, but protocol and development infrastructure
Maintenance form	Official site + GitHub open source repository	Apache 2.0 license
Current mainline	v1.0 Candidate / v0.9.1 Stable	Candidate specification parallel to production stable version
Compatible transmission	A2A, AG-UI, REST, WebSockets, MCP	Suitable for connecting to a variety of Agent links
Renderer direction	React, Angular, Lit, Flutter, etc.	Emphasis on cross-client rendering

The core of A2UI is not to "make the chat bubble more beautiful", but to add a layer of safe, declarable, and cross-terminal UI protocol to the Agent product.

User and market recognition

• The initiator is Google, and the project is made public in the form of an independent documentation site and GitHub repository, indicating that it is not a one-time demo.
• Documentation and roadmap clearly link A2A, MCP, GenUI and other ecologies, which is a standard attempt at the Agent infrastructure layer.
• The public page does not have the scale and adoption of commercial customers, so at this stage it is more suitable to regard it as a "protocol direction worthy of attention" rather than a mature commercial platform.

Cost advantage

• C-side/Individual: There is no subscription price because it is not a tool sold to ordinary users.
• Developer/API: The open source protocol and reference implementation are public, and the trial cost is mainly the project access and renderer adaptation time.
• Enterprise/Private: The advantage is to reduce the cost of self-developed UI protocols and security patches, but there is no separate commercial purchase page.

Its hidden benefit is to reduce the risk and maintenance cost of Agent-generated front-end code; the hidden cost is that the team has to accept the "protocol layer construction" instead of expecting it to be ready to use.

Main functions

• Declarative UI Protocol: Let the Agent output structured JSON instead of arbitrary executable front-end code.
• Multiple renderer support: The same protocol can be implemented on different end-sides such as React, Lit, Angular, and Flutter.
• Multi-transport compatible: Can be embedded in A2A, AG-UI, REST, WebSockets, MCP and other transmission links.
• Component catalog and action callback: supports both interface display and user interaction callback to Agent.
• Streaming and progressive rendering: an incremental output method more suitable for LLM.

Model and version evolution

• ~2025-10 / v0.8 Initial Public Release: The roadmap marks the initial public release and lists the GitHub Apache 2.0 open source A2A extension and multi-renderer as key milestones.
• ~2026-03 / v0.9.1 Stable: Officially marked as current stable production release, used for current production.
• ~2026-03/v1.0 Candidate: The specification has entered the next stage of candidate version, indicating that the protocol is moving towards a more formal and stable version.

The main upgrade line of A2UI is not function buttons, but the gradual convergence of protocol constraints, compatibility, and cross-ecological interoperability.

Technical advantages

• Mechanism: Use declarative protocol instead of Agent to directly generate executable UI code.

  Effect: Significantly reduces the risk of UI injection and arbitrary code execution. Applicable scenarios: Enterprise Agent, remote Agent, and cross-trust boundary rendering scenarios.

• Mechanism: Tile and streaming JSON structures are better suited for LLM incremental generation.

  Effect: The client can do progressive rendering faster, instead of waiting for the entire code to be generated. Applicable scenarios: Chat Agent, dynamic cards, real-time forms.

• Mechanism: The protocol is decoupled from the renderer.

  Effectiveness: The front-end team does not need to rebuild an Agent UI protocol for each client. Applicable scenarios: Cross-Web, App, and embedded Agent interactive products.

How to use

• Protocol learning path: First read the roadmap and specification page to understand schema, surface, action and data flow.
• Development access path: Select an existing renderer -> Let Agent output A2UI JSON -> Render on the client and receive action return.
• Architecture verification path: First pilot in a single Agent scenario, and then decide whether to use it as a unified GenUI protocol layer.

Product Pricing

A2UI currently does not provide commercial subscription prices, and the public value mainly comes from open source protocols and reference implementations.

Level	Current public status	Description
Agreement and Documentation	Free	Official Site Public
Code Implementation	Free	GitHub Apache 2.0
Commercial version	Unpublished	No independent commercial purchasing page

For the team, the cost is not in the license, but in project access, protocol modeling and renderer selection.

Application scenarios

• Enterprise Agent Product: The agent needs to be able to output a safe and controllable business interface.
• Cross-terminal Agent interaction: It is hoped that the same Agent UI description supports both web and mobile terminals.
• Protocol layer standardization: We don’t want each Agent team to invent its own UI output format.

Applicable people

• Front-end or platform engineer: is building the Agent product and needs a sustainably maintained UI protocol layer.
• Enterprise Architecture Team: Focus on security, cross-end compatibility and protocol governance.
• A2A / MCP / AG-UI integrated developer: The UI layer needs to be incorporated into the Agent communication protocol.

Doesn’t fit the boundaries: Teams that treat A2UI as a ready-made terminal SaaS or “low-code visual chat component library” will quickly discover that it is not such a product.

Summary and Outlook

It provides competitive solutions in its field, and its core value lies in lowering the threshold for AI use in this field.

Current limitations: Some advanced features require paid subscription, and the free version has function or usage restrictions; specific technical details and performance benchmarks have not yet been fully disclosed.

Related tools: github-copilot, cursor

Version Info

• A2UI v1.0 Candidate ：The official specification page marks v1.0 as Candidate as the next phase of the protocol mainline; the production stable version is still 0.9.1. （~2026-03）
• Current Stable Production Release ：Officially marked as current production release, unifying MIME type and relaxing surfaceId constraints. （~2026-03）