Google shipped A2UI 1.0 on November 11, 2026. And it attacks a problem anyone running an AI agent already feels: the agent does the work, then hands the user a wall of text. A2UI is Google’s open protocol for generative user interfaces, and 1.0 is its first stable version. It lets AI agents answer with interactive screens, such as a form to confirm or a chart, instead of another paragraph in a chat bubble.
The short version, extracted for the skimmers: A2UI is a JSON-based streaming protocol where the agent sends a stream of JSON objects and the client renders them using its own native UI components across web, mobile, and desktop.
The agent never sends executable code. Google says open-source renderer SDKs are available now for the web, Android. And iOS, plus agent SDKs for Python, TypeScript, and Dart. That restraint is the entire story, and almost nobody covering the release is talking about it.
What A2UI 1.0 Actually Does Under The Hood
The A2UI protocol uses a unidirectional stream of JSON messages from the agent to the renderer to describe and update the UI, per the v1.0 specification.
Your agent describes a screen, your app draws it. And later messages mutate what’s on screen as the task evolves. The v1.0 spec defines wire envelopes, shared types, catalog formats.
And capability-negotiation payloads across 11 canonical JSON Schemas, published here.
Two of those pieces deserve your attention as an operator. Capability negotiation means the agent and the client agree on what’s possible before anything streams. So an agent can’t demand a widget your app doesn’t have. Catalog formats mean the components come from a defined set your client knows how to render. Your design system survives contact with the agent. Because the client application renders using its own native UI components rather than whatever markup the agent invents.
Transport stays deliberately boring.
The JSON payload can travel over A2A, AG-UI, server-sent events, or WebSockets, which means A2UI doesn’t demand you restructure how your agent talks to your app today.
It’s a payload format, not a stack replacement.
That’s why I’d take it seriously where I ignore most “agent framework” announcements: it composes with what you already run instead of asking you to migrate to it.
The Security Decision Nobody Is Covering
Here is the line that matters most in Google’s own material: “A2UI is a declarative data format, not executable code.” The original announcement also notes that orchestrator agents and remote A2A subagents generate UI layouts that are securely passed as messages, not as executable code.
Think about what that rules out. The lazy way to do generative UI is to let the model emit HTML and stuff it into an iframe, or to eval some generated markup and pray. Every one of those approaches hands a language model code execution rights inside your user-facing app. A JSON description of a button is data. Your renderer decides whether that button exists, what it looks like, and what it’s allowed to do.
For a small business, this is not a nice-to-have detail. You don’t have a security team to review what an agent-generated DOM might inject into your checkout flow. With A2UI, the worst a hostile or hallucinating agent can do is describe components your renderer either supports or rejects. I’ve spent enough late nights wiring model output into frontends to know that “what happens when the model emits something nasty” is the question that kills these projects. The protocol answers it structurally instead of leaving it to your discipline.
What’s New In 1.0, And Why Bidirectional Calls Matter
The 1.0 release post lists the additions plainly: bidirectional function calls, accessibility support, and extensions for any additional metadata. The release too brings swappable inference formats and secure data binding.
Bidirectional function calls are the one that changes product decisions. The standard protocol flow is a unidirectional stream from agent to renderer, which is great for describing screens but useless the moment a screen needs to react. Version 1.0 adds bidirectional function calls, so a flight or reservation picker can check availability on the spot. Read that again from a business owner’s chair: the agent generates a picker, the user taps a date. And the picker verifies live inventory during the interaction.
No custom round-trip frontend, no bespoke form API you hand-build for every agent feature.
The tooling is real enough to evaluate today.
Google lists renderer SDKs spanning React, Angular, Lit, Flutter, SwiftUI.
And Jetpack Compose, with agent SDKs for Python, TypeScript, and Dart.
If your product is a React web app and a Flutter mobile app, both ends are covered by the same protocol.
Accessibility support belongs in the protocol rather than left to each renderer’s goodwill. And that’s the right call for a spec whose whole pitch is native rendering across platforms.
Should You Build On This Now
My honest read: evaluate now, ship narrowly.
A “stable 1.0” label from any fast-moving spec deserves the same skepticism you’d give a vendor’s “production-ready” slide deck.
The announcement tells you what shipped; it doesn’t tell you what happens to your stored A2UI payloads when the format evolves. And none of the launch coverage addresses migration risk. Pin your renderer SDK versions and treat the schema as something that will move.
The smart first move costs you an afternoon.
Wire one screen behind a feature flag, and make it the exact case Google describes: a confirmation form. Pick the single place in your product where an agent currently asks a user to confirm something over text. And replace that exchange with an A2UI form. You’ll learn more from that one screen than from reading the whole spec, since you’ll see where your component catalog falls short.
The bigger picture for small operators is a shift in where the work lives. You stop hand-building one-off frontend glue for every agent capability. And you start curating the catalog of components your client is willing to render. That’s work you do once, control completely, and reuse across every agent you bolt on afterward. If agents are about to own more of your product surface, owning the renderer is how you keep owning the product.
Read the v1.0 specification, grab the renderer SDK that matches your stack, ship one confirmation form behind a flag this week. And tell me what breaks. That data point is worth more than any announcement post.
