Introducing A2UI: An open project for agent-driven interfaces

Google’s A2UI project enables AI agents to generate dynamic, contextually relevant user interfaces that integrate seamlessly across platforms and frameworks. This open-source solution addresses the growing need for agents to communicate through rich interfaces rather than text alone.

The Problem: Agents Need Visual Communication

Traditional agent interactions rely on clunky text exchanges. Consider booking a restaurant table through text:

User: “Book a table for 2.”
Agent: “Okay, for what day?”
User: “Tomorrow.”
Agent: “What time?”

This back-and-forth continues until the agent finally lists available times. A2UI transforms this experience by letting agents generate custom forms with date pickers, time selectors, and submit buttons—creating intuitive interfaces tailored to specific tasks.

The Challenge: Rendering Across Trust Boundaries

Multi-agent systems create a user interface problem. When agents run remotely—on different servers or owned by different organizations—they cannot directly manipulate your application’s UI. They must send messages instead.

Traditional solutions involve sending HTML or JavaScript in sandboxed iframes. This approach creates heavy, visually disjointed experiences that rarely match your app’s native styling.

A2UI provides a way to transmit UI that is safe like data, but expressive like code.

The Solution: UI Specification as Messages

A2UI uses a standard JSON format that agents generate as structured output. The format works with remote A2A agents or local orchestrators, sending payloads over various transports while letting client applications render using their own native UI components.

This approach ensures clients retain full control over styling and security, making agent output feel native to your application.

Core Design Principles

Security First: A2UI uses declarative data format, not executable code. Client applications maintain catalogs of trusted, pre-approved UI components. Agents can only request components from this catalog, reducing UI injection risks.

LLM-Friendly: The UI appears as a flat list of components with ID references. This structure allows LLMs to generate content incrementally, enabling progressive rendering and responsive experiences.

Framework-Agnostic: A2UI separates UI structure from implementation. Agents send component tree descriptions and data models. Client applications map these to native widgets—web components, Flutter widgets, React components, or SwiftUI views.

Real-World Implementation

A2UI has been developed with several teams inside and outside Google:

AG UI / CopilotKit provides day-zero compatibility, offering developers a powerful integration story.

Opal uses A2UI to let users build AI mini-apps with dynamic, generative UI custom for each use case.

Gemini Enterprise integrates A2UI to allow enterprise agents to render rich, interactive UIs within host applications.

Flutter’s GenUI SDK uses A2UI as the UI declaration format between remote server-side agents and applications.

Getting Started

Try A2UI by visiting a2ui.org for documentation and quickstart guides. Run the restaurant finder sample:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
git clone https://github.com/google/A2UI.git
export GEMINI_API_KEY="your_gemini_api_key"

# Run the restaurant finder A2A agent
cd A2UI/samples/agent/adk/restaurant_finder
uv run .

# Run the lit client
cd A2UI/samples/client/lit/shell
npm install
npm run dev

You can also explore the GenUI SDK for Flutter at docs.flutter.dev/ai/genui or try CopilotKit’s A2UI Widget Builder.

Current Support and Future Plans

A2UI currently supports Flutter, Web Components, and Angular client libraries. The format is at version 0.8, reflecting extensive battle-testing while remaining open to evolution.

The project welcomes community contributions to:

Refine and evolve the format
Connect A2UI to additional client libraries
Build robust tools and developer resources
Create compelling demonstrations

A2UI is Apache 2 licensed and depends on community success. Whether you want to build a client for your favorite UI framework, add agent-building library support, or create demonstrations, the team wants to collaborate with you.

Check the public roadmap to see planned developments and discover how you can contribute to building the future of agentic user experiences.