Skip to content
OriginalSoftware

A2UI 1.0: your AI agent can answer with a screen now

Google's A2UI 1.0 is the first stable protocol for generative UI: agents describe screens, apps render them with native components, and the agent never sends code. Here is how it works, what changed in 1.0, and where it is already running.

Hand-drawn schoolbook illustration of a large hand sketching a browser window filled with tiny charts, cards and buttons, a pencil mid-stroke
The agent sketches; the app draws. Original GREP PRINT illustration.
On this page

In brief

  • The agent describes the interface as data; the app renders it with its own native components.
  • The agent can only place components the app has registered — it never sends code, so the trust boundary is a catalogue, not a sandbox.
  • Version 1.0 adds bidirectional function calls, A2UI Express, and server-side macros that keep data off the model.
  • Renderers exist for the web, Flutter, SwiftUI, and Android; agent SDKs for Python, TypeScript, and Dart.
  • Atlassian, Alation, Bloomberg, and ByteDance are already building with it, and Gemini renders A2UI responses today.

The terminal era

Google's developers blog opens the A2UI 1.0 announcement with an image worth stealing: talking to an AI agent today is where computers were in the terminal era. Capable, and answering almost everything in text. You can ask an agent for anything by typing or talking, and what comes back is usually a wall of text — a poor way to compare three products, or to edit and approve a detailed plan.

A2UI is Google's answer to that wall. Version 1.0, released November 11, is the first stable version of its open protocol for generative UI: a way for AI agents to answer with interactive screens — a form to confirm, a chart to read, a booking to approve — instead of paragraphs. The agent describes what to show. Your app draws it, with its own native components, at native speed.

What A2UI actually is

A2UI stands for Agent-to-UI. It is a protocol, not a product: a shared language an agent uses to say "show a card with these three options and a confirm button," which the receiving app then renders however it renders things — React on the web, Flutter on mobile, SwiftUI on iOS.

The point is the split. The agent decides what the user should see. The app decides how it looks and what is allowed to run. The same agent output works on any screen: ask an agent to move dinner with Priya to Friday, and it can answer with one view that lines up your calendar, open tables from a restaurant booking app, and prices from a rideshare app, so the time that works for everyone is obvious. The developer builds that view once, and it renders natively on a phone and on a laptop.

Google's own example is a sick day. Getting through the morning takes six apps: book a video visit, move your meetings, tell your team, turn on an out-of-office reply, ask your partner to do school pickup, order soup. A text-only agent answers with a numbered wall of text and round after round of "which ones?" An A2UI agent could answer with one view of all six apps, where changing the plan is a couple of taps and nothing is sent until you confirm.

A thick wall divides the frame: a tangle of loose overlapping shapes on one side, a few neat solid shapes arranged in a row on the other
The description stops at the wall; only the app's own registered components render on the far side.

The one rule that makes it safe

The idea that should make a security-minded reader sit up is the trust boundary. An agent that can draw your interface sounds like an agent that can run code on your machine. A2UI's answer is that the agent never sends code at all. It sends a description, and the app renders it using only the components it has registered — its own design system and nothing else. The agent places and configures only the components you register.

That is the whole security model, and it is why the protocol's own summary of itself is "safe like data, but expressive like code." The description is data. The rendering is the app's code, already trusted. Sensitive values never reach the model at all: A2UI binds data on the server, so a chart can show your numbers without the model ever seeing them.

It is a genuinely different answer from the obvious one — letting the model write HTML or JavaScript and running it — and it is the reason companies with real design systems and real compliance teams are willing to try it.

What's new in 1.0

Version 1.0 is the first stable release after roughly ten months of candidate versions, and the changes are practical rather than ceremonial:

  • Bidirectional function calls. A flight or reservation picker can now check availability on the spot, instead of the agent guessing and the user finding out later.
  • Accessibility support and metadata extensions, so generated screens can carry the information assistive technology needs.
  • A2UI Express. Instead of writing JSON, the model can write a short Python-like language that compiles to the protocol on the server — fewer tokens, fewer chances to produce malformed output.
  • Server-side macros. A macro is a small program on the server the model calls like a component, so figures and charts never pass through the model at all. In one independent comparison by a developer building a currency agent, a rate card took 223 tokens as 0.9 JSON, 139 as 1.0 Express, and 21 as a macro call; a 90-day history chart took 1,060 tokens as JSON and 21 as a macro call. Those are the author's measurements on his own build, not Google's, but they show what the mechanism is for.
  • SDKs and renderers. New agent SDKs for TypeScript and Dart join Python. Open-source renderers cover React, Angular and Lit on the web, Flutter on mobile, web and desktop, and SwiftUI on iOS. Jetpack Compose on Android supports 0.9.1 today, with 1.0 coming soon.
A2UI 0.9A2UI 1.0
StatusCandidateFirst stable release
What the model writesJSONExpress, or a macro call
Function callsOne directionBidirectional
Data bindingThrough the modelServer-side, data never reaches the model
Jetpack Compose0.9.11.0 coming soon

A2UI also travels over AG-UI, the agent-user interaction protocol, and works inside MCP Apps, so its screens can appear in AI assistants that support them, such as Claude and Gemini.

Where it's already running

The launch post names Atlassian, Alation, Bloomberg and ByteDance as building with it, and the examples are concrete rather than decorative:

  • Atlassian is bringing A2UI to Jira, where teams assign work items to AI agents. When an agent needs a follow-up — a missing detail, a decision — it asks with an interactive card inside the work item, and the team answers right there.
  • Alation builds its Intelligence Operating System feeds with A2UI: metric cards, charts, each able to show the SQL query and the data behind it. The same feed renders in Claude and inside Alation's own app with a nearly identical layout.
  • ByteDance shipped an A2UI renderer for Lynx, its cross-platform framework, in June 2026, and its GenUI Playground renders A2UI messages natively — a two-day Kyoto trip planner among them.
  • Inside Google, Gemini Notebook answers a request for a slide deck with cards that ask about format and focus before generating anything, Gemini itself renders A2UI responses from registered agents, and Gemini Enterprise is being upgraded to 1.0.

What to try

The docs and quickstart live at a2ui.org, and CopilotKit runs an A2UI Playground where you can try the protocol live. If you are upgrading from 0.9, Google points to an evolution guide covering every change, including the rename of theme to surfaceProperties and the new client-to-server action responses.

The open question is not whether agents will answer with screens — the terminal era line is right, and text was never going to be the final interface. It is whether the industry converges on one protocol for it, or whether every assistant grows its own. A2UI 1.0 is Google's bid for the shared one, and the first stable version is the moment that bid gets serious.

More from grep.tips

All articles