A2UI 1.0 released: Google's stable protocol for agent-generated native UIs

Google released A2UI 1.0 on 11 November 2026, calling it the first stable version of its open protocol for generative UI. A2UI lets an AI agent describe an interactive screen (a form, a confirmation, a chart) as structured data, and lets the app that hosts the agent draw that screen with its own native components, instead of the agent returning only text. For developers building agents, 1.0 is the point at which Google says the message format and the renderer and agent SDKs can be relied on.

Key points

• A2UI 1.0 was announced by the A2UI team on Google's developers blog on 11 November 2026 as the first stable version of the protocol.
• New in 1.0, per Google: bidirectional function calls, accessibility support, extensions for extra metadata, and server-side binding of data and child components so sensitive values never reach the model.
• Renderers exist for React, Angular, Lit, Flutter and SwiftUI; Jetpack Compose is at v0.9.1 with 1.0 "coming soon". Agent SDKs are published for Python and TypeScript.
• The specification page lists v1.0 as "Current" and keeps v0.9.1 documented alongside it; Gemini itself still supports 0.9.1, with a Gemini Enterprise upgrade to 1.0 in progress, according to Google.
• A2UI was introduced as open source under Apache 2.0, per The Decoder's December 2025 report on the 0.8 release; Google's 1.0 post does not restate the licence.

What happened

Google's post, credited to the A2UI team and written by its product manager Vishal Motwani, describes A2UI as "an open protocol for generative UI". The agent says what to show; the host app renders it with the components the developer has registered. That keeps the look of the app consistent and restricts what an agent can place on screen to a list the developer controls.

The post lists what 1.0 adds. Bidirectional function calls let, for example, a flight or reservation picker check availability in real time instead of relying on stale data in the model's context. Accessibility support and metadata extensions are new. Server-side binding of data and child components means sensitive values stay on the server and are filled in at render time, so they do not need to pass through the model.

Renderers named in the post cover the web (React as @a2ui/react, Angular as @a2ui/angular, Lit as @a2ui/lit), Flutter (a2ui_flutter) for mobile, web and desktop, SwiftUI for iOS, and Jetpack Compose for Android. Compose is currently at v0.9.1, with 1.0 listed as coming soon, and ByteDance's Lynx renderer, released in June 2026, supports 0.9 and is adapting to 1.0. On the agent side the post names a Python SDK (a2ui-agent-sdk on PyPI) and a TypeScript SDK (@a2ui/agent on npm), with Python adding "A2UI Macros" for programmatic component expansion and data binding, plus an inference format called A2UI Express for models that compose UI. SD Times, reporting the release, also lists Dart among agent SDKs; Google's post is ambiguous on that point, so treat Dart support as unconfirmed until you see the package.

Google names several adopters: Atlassian (follow-up cards from its Jira agent), Alation, Bloomberg, ByteDance, and Google's own Gemini Notebook and Gemini Enterprise, plus unreleased Google features. We have only Google's description of how each uses it.

Background

Google introduced A2UI in late 2025. The Decoder's report on version 0.8, published 20 December 2025, describes the core idea: the agent streams JSON describing the interface, not executable HTML or JavaScript, and the client draws it with widgets from a local catalog. Google framed this against approaches that load prebuilt HTML in sandboxed iframes, arguing that sending data rather than code reduces injection risk and avoids mismatched styling. The Decoder notes that these comparisons, including those with Anthropic's MCP and OpenAI's ChatKit, are Google's own framing, and that no independent benchmarks or security audits were provided.

By mid-2026 the project had reached 0.9 and 0.9.1, and Google's 1.0 post says the web and Flutter renderers also work inside MCP Apps, the mechanism by which an assistant that supports MCP can show an app's interface. We covered what Gemini 4 Hydrogen means for developers, the model family Google is rolling the protocol into.

How it works

The specification page for 1.0 shows the shape of the protocol. The agent sends a stream of messages to the renderer: createSurface, updateComponents, updateDataModel and deleteSurface, plus callRendererFunction and agentFunctionResponse for the new function calls. The renderer replies with action, callAgentFunction, rendererFunctionResponse and error.

What an agent may use is set by a catalog, identified by a catalogId. A surface can set a default catalog, and a Basic Catalog supplies baseline components and functions; custom catalogs are allowed and follow identifier naming rules.

The spec also describes a security model. Each function declares who may call it (rendererOnly, agentOnly or rendererOrAgent), and the renderer enforces this at runtime. Functions that need user activation run only from a user gesture, never from a passive binding. Regular-expression patterns go through a safety check to limit complexity. The protocol is transport-agnostic and names AG-UI, A2A and MCP as bindings, with server-sent events over JSON-RPC, WebSockets and REST as other options.

Changes from 0.9, according to the same page: a single createSurface message can now carry a full UI and its data model; theme properties are removed from createSurface, so a message with theme is invalid; the envelopes are renamed agent_to_renderer and renderer_to_agent; bindings and component keys gain @ prefixes such as @path, @call and @catalogId; function definitions become object maps with $schema and $id support; and identifier rules are stricter. If you wrote against 0.9, expect a migration. Google points to an evolution guide in the repository.

What it means

For developers building agents, the practical change is a stable target. The protocol surface is now versioned and documented, with two agent SDKs and several renderers, so a team can commit a mobile or web app to rendering agent-described screens without chasing breaking changes every release. The catch is the migration from 0.9, and the fact that Gemini itself is still on 0.9.1 for now.

For app owners, the registered-component model is the main appeal: the agent cannot invent arbitrary widgets, and brand and accessibility rules live in your own components. The cost is the one The Decoder flagged for earlier versions: a predefined catalog limits what an agent can build.

For the wider agent ecosystem, A2UI sits beside MCP and A2A rather than replacing them; the spec lists both as possible transports. SD Times notes that people can reach an agent in its own app or in a third-party assistant that hosts MCP apps, such as Gemini or Claude, though it does not list those as adopters.

What we don't know yet

• Which licence the 1.0 SDKs carry. Google's post says only "open-source", and the Apache 2.0 detail comes from the 0.8-era report.
• Performance and security results. Google's post reports no benchmarks, and we found no independent audit.
• When Gemini and Gemini Enterprise move to 1.0, and when the Compose renderer follows.
• Whether non-Google assistants will render A2UI surfaces natively.

What to watch next

The Compose renderer's 1.0 release; the Gemini upgrade to 1.0; the migration experience for 0.9 users; and whether other platforms adopt the protocol, which would show whether it becomes a shared standard or stays mainly a Google ecosystem tool.

Sources

• Google Developers Blog, A2UI 1.0: Build delightful, fast, reliable, agentic experiences (11 Nov 2026)
• A2UI specification v1.0
• SD Times, Google releases A2UI 1.0 for generative UI
• The Decoder, Google's open standard lets AI agents build user interfaces on the fly (20 Dec 2025)