Google is pushing AI agents beyond plain text with A2UI, an open-source standard designed to let agents create graphical interfaces as a conversation unfolds. Instead of replying only with words, an agent can suggest forms, buttons, date pickers, text fields and other app-native controls.
The idea is simple: some tasks become frustrating when everything has to happen through a chat box. A2UI gives agents a way to present useful interface elements while still letting the host app decide how those elements should look and behave.
Why A2UI exists
A2UI stands for Agent-to-User Interface. Released under the Apache 2.0 license, it is meant to standardize how AI agents produce visual responses inside applications.
Google points to restaurant reservations as a clear example. A text-only exchange can become slow when a user has to go back and forth about dates, times and availability. With A2UI, an agent can instead create a form with date pickers and available time slots.
That turns the interaction from a long conversation into a more direct workflow. The agent still understands the context, but the user can act through familiar interface controls rather than typing every detail.
Google describes the target as a "context-aware interface". In practice, that means the interface can change as the task changes, instead of forcing every interaction into the same chat format.
Data instead of executable code
A core design choice in A2UI is that agents do not send executable interface code. The standard moves away from approaches where agents generate HTML or JavaScript that runs inside sandboxes or iframes.
According to the research team, those code-based approaches can create security risks. They can also produce interfaces that feel out of place because the generated design may not match the surrounding app.
A2UI uses a different model. The agent sends a JSON structure that describes the interface it wants to show. The receiving app reads that structure and renders it using its own native UI components.
This keeps the agent within a predefined set of interface elements, such as buttons and text fields. It also reduces code injection risk because the agent is sending data, not executable logic.
The host app remains in control of presentation. The agent can describe the shape of the interaction, but it does not dictate pixel-level design. That matters for apps that need a consistent visual system across human-built and agent-generated screens.
Where A2UI fits among agentic UI tools
Google is positioning A2UI in a growing field of agentic UI standards and toolkits. The company draws a distinction between A2UI and Anthropic's Model Context Protocol, or MCP.
According to Google, MCP treats UI as a resource, commonly as prefab HTML loaded in a sandbox. A2UI is aimed at native-first integration, where the host app renders the interface through its own components.
Google also contrasts A2UI with OpenAI's ChatKit. ChatKit works best inside OpenAI's ecosystem, while A2UI is intended to be platform-agnostic.
The standard is also designed for complex multi-agent setups. In that model, one agent can orchestrate others and securely display UI suggestions from remote sub-agents.
This framing shows that A2UI is not only about making chat responses more visual. It is also about giving apps a controlled way to receive interface suggestions from agents that may be working across different systems.
How Google is already using it
A2UI is at version 0.8 and is already in production, according to Google. The GenUI SDK for Flutter uses A2UI to manage communication between server-side agents and mobile apps.
Google's internal mini-app platform Opal and Gemini Enterprise also run on the protocol. That gives the standard an existing base inside Google's own agent and app work.
The company has also connected A2UI to its recent work on Generative UI. Just weeks ago, Google showed how AI models can create interactive tools and simulations in real time in the Gemini app and search. That feature is called Dynamic View, and it generates tailored graphical interfaces to make complex topics easier to grasp.
A2UI extends the same broader direction: interfaces that are generated for the task, rather than fixed in advance or reduced to text.
What developers get now
Google has support from external frameworks as well. The teams behind AG UI and CopilotKit supported the protocol from day one.
The project currently ships client libraries for Flutter, Web Components and Angular. Google is inviting developers to contribute more renderers and integrations.
For developers, the practical appeal is clear. A2UI gives agents a structured way to request interface elements while leaving rendering, styling and security boundaries with the application.
That balance is the important part. AI agents can become more useful inside apps without being handed broad permission to inject code or override the app's design system.
Given how fast standards like MCP have spread, A2UI appears positioned for broad adoption. Its success will depend on whether developers and frameworks embrace the data-first model for agent-generated interfaces.