Google introduces A2UI (Agent-to-User Interface): an open source protocol for agent-driven interfaces

Google has the open source A2UI, an Agent to User Interface specification and set of libraries that lets agents describe rich native interfaces in a declarative JSON format while client applications render them with their own components. The project targets a clear problem, how to let remote agents present secure, interactive interfaces across trust boundaries without sending executable code.

What is A2UI?

A2UI is an open standard and implementation that allows agents to speak UI. An agent does not output HTML or JavaScript. It outputs an A2UI response, which is a JSON payload describing a set of components, their properties, and a data model. The client application reads this description and maps each component to its parent widget, for example an Angular component, Flutter widget, web component, React component or SwiftUI view.

Problem, agents need to speak UI

Most chat-based agents respond with long texts. For tasks like restaurant booking or data entry, it produces multiple turns and dense answers. The A2UI launch post shows an example of a restaurant where a user asks for a table, then the agent asks several follow-up questions in text, which is slow. A better experience is a small form with a date selector, time selector and a submit button. A2UI lets the agent make a request as a structured UI description instead of describing that form in natural language.

The problem becomes even more difficult in multi-agent networks. In that setting, an orchestrator in one organization can delegate work to a remote A2A agent in another organization. The remote agent cannot touch the document object model of the host application. It can only send messages. Historically this meant HTML or script inside an iframe. This approach is cumbersome, often visually incompatible with the host, and risky from a security perspective. A2UI defines a data format that is secure as data but expressive enough to describe complex layouts.

Core design, security and LLM friendly architecture

A2UI focuses on security, LLM friendliness, and portability.

• Safety first. A2UI is a declarative data format, not executable code. The client maintains a list of trusted components such as cards, buttons, or textfields. The agent can only reference types in this catalog. This reduces the risk of UI injection and protects against arbitrary script execution from model output.
• LLM friendly representation. The UI is represented as a flat list of components with identifier references. This makes it easier to sequentially generate or update the interface to the language model and supports streaming updates. The agent can adjust a view as the conversation progresses without having to regenerate a full nested JSON tree.
• Framework agnostic. A single A2UI payload can be presented on multiple clients. The agent describes a component tree and associated data model. The client maps that structure to a native widget in a framework like Angular, Flutter, React, or SwiftUI. This allows reusing the same agent logic across web, mobile, and desktop surfaces.
• Progressive rendering. Because the format is designed for streaming, clients can show a partial interface while the agent continues computing. Users see the interface being assembled in real time rather than waiting for a complete response.

Architecture and data flow

A2UI is a pipeline that separates generation, transport, and rendering.

1. A user sends a message to an agent through chat or other surface.
2. The agent, often backed by Gemini or another model that can generate JSON, generates the A2UI response. It describes React components, layout, and data binding.
3. A2UI messages stream from agent to client over a transport such as the Agent Protocol or AG UI Protocol.
4. The client uses the A2UI renderer library. The renderer parses the payload and resolves each component type into a concrete widget in the host codebase.
5. User actions, for example button clicks or form submissions, are sent back to the agent as events. The agent can respond with new A2UI messages that update the existing interface.

key takeaways

• A2UI is an open standards and library set from Google that lets agents ‘speak UI’ by sending a declarative JSON specification for interfaces, while clients render them using native components like Angular, Flutter or Lit.
• The specification focuses on security by treating the UI as data, not code, so agents only reference a client-controlled catalog of components, which reduces UI injection risk and avoids executing arbitrary scripts from model output.
• The internal format uses an updatable, flat representation of components optimized for LLM, which supports streaming and incremental updates, so that agents can progressively refine the interface over the course of a session.
• A2UI is transport agnostic and is already used with the A2A protocol and AG UI, allowing orchestrator agents and remote sub agents to send UI payloads across trust boundaries, while the host application maintains control of branding, layout, and accessibility.
• The project is in early public preview at version v0.8, released under Apache 2.0, with reference renders, quickstart samples, and production integration into projects like Opal, Gemini Enterprise, and Flutter ZenUI, making it now directly usable by engineers building agentive applications.

check it out github repo And technical detailsAlso, feel free to follow us Twitter And don’t forget to join us 100k+ ml subreddit and subscribe our newsletterwait! Are you on Telegram? Now you can also connect with us on Telegram.