Google released A2UI 0.9, a standard allowing AI agents to generate UI elements dynamically using an app's existing components. It includes a web core library, React renderer, and support for Flutter, Angular, and Lit.

Google Launches A2UI 0.9, a Generative UI Standard for AI Agents

Google has released version 0.9 of A2UI (Agent-to-User Interface), a framework-agnostic protocol designed to enable AI agents to generate user interface elements dynamically. The standard allows agents to construct UIs on the fly by tapping into an application's existing component libraries across web, mobile, and other platforms, moving beyond static, pre-defined interfaces.

Key Takeaways

• Google released A2UI 0.9, a standard allowing AI agents to generate UI elements dynamically using an app's existing components.
• It includes a web core library, React renderer, and support for Flutter, Angular, and Lit.

What's New: A Framework-Agnostic Protocol

A2UI 0.9 is not another UI framework but a specification that defines how AI agents can describe and render interfaces. The core proposition is separation of concerns: the AI agent handles logic and intent, while the A2UI runtime handles rendering using the application's native components.

Key components of the release include:

• Shared Web Core Library: A foundational JavaScript/TypeScript library implementing the A2UI protocol for web environments.
• Official Renderers: An official React renderer, plus updated renderers for Flutter, Lit, and Angular. This allows developers to use A2UI within their existing tech stacks.
• Agent SDK: A new Python SDK aimed at simplifying agent development and integration. Google confirms Go and Kotlin versions are in development.
• Enhanced Protocol Features: Client-defined functions (allowing the UI to call back into agent logic), client-server data synchronization, and improved error handling.

Technical Details: How It Works in Practice

In a typical implementation, an AI agent (like a Gemini-based assistant) would generate a UI description following the A2UI schema. This description is sent to the client application, where the A2UI runtime interprets it and renders the interface using the actual React, Flutter, or Angular components already in the codebase.

For example, an agent helping a user book travel could generate a form with date pickers, destination inputs, and a submit button. The A2UI runtime would render this using the application's own styled DatePicker, TextInput, and Button components, ensuring visual and behavioral consistency.

Ecosystem and Early Adoption

Google reports rapid ecosystem growth with several key integrations:

• AG2 & A2A 1.0: Google's own agent development frameworks.
• Vercel's json-renderer: Enables use within Vercel's AI SDK ecosystem.
• Oracle's Agent Spec: A significant cross-vendor compatibility move.

Early sample applications demonstrate potential use cases:

• Personal Health Companion (Rebel App Studio): An agent that generates tailored health tracking dashboards.
• Life Goal Simulator (Very Good Ventures): An interactive planning tool with dynamically generated forms and visualizations.

Documentation, specifications, and examples are hosted at A2UI.org.

How It Compares: The Move Toward Dynamic Agent Interfaces

Approach	Description	Key Limitation A2UI Addresses
Pre-defined UI Templates	Agents trigger fixed screens or modals.	Inflexible; cannot adapt to novel agent tasks.
Raw HTML/JSON Generation	Agents output direct markup or structure.	Unconnected to app's design system; poor integration.
A2UI Protocol	Agents describe intent; runtime renders with native components.	Enables dynamic, consistent, and integrated UI generation.

The release positions A2UI as a potential standard for the emerging "agentic" layer of software, where AI doesn't just answer questions but takes actions through generated interfaces.

What to Watch: Limitations and the Road Ahead

As a 0.9 release, A2UI is still in development. Key questions remain:

• Performance: The overhead of runtime interpretation versus pre-rendered components.
• Complexity: Describing highly interactive, stateful UIs (like a full spreadsheet) via the protocol.
• Adoption: Whether major framework communities beyond Google's ecosystem will embrace the standard.

The promise is significant: breaking the tight coupling between an AI agent's capabilities and the hard-coded UI surfaces available to it. If widely adopted, it could let agents tackle open-ended tasks by constructing the appropriate interface as needed.

gentic.news Analysis

Google's A2UI launch is a direct attempt to standardize the front-end layer for AI agents, a critical piece of infrastructure that has been largely bespoke until now. This follows Google's pattern of releasing foundational protocols for emerging AI paradigms, similar to its earlier work on the Gemini API and the A2A (Agent-to-Agent) protocol. The integration with Vercel's json-renderer is particularly notable, bridging Google's ecosystem with a major player in the Next.js/React community and suggesting a push for broad industry alignment.

Technically, A2UI tackles a fundamental bottleneck in agent deployment: the UI barrier. Even a highly capable agent is limited by the interfaces engineers have explicitly built for it. By providing a way to generate UIs from existing components, A2UI could dramatically increase the action space of agents within applications. This aligns with the trend we identified in our December 2025 analysis, "The Year of the Agent: From Chatbots to Action-Takers," where we predicted infrastructure for agent embodiment would become a major investment area.

The mention of Oracle's Agent Spec integration is a signal that this may evolve into a multi-vendor standard, not just a Google project. However, the absence of immediate renderers for Vue.js or Svelte highlights the early-stage nature of the ecosystem. The success of A2UI will depend less on its technical elegance and more on whether it becomes the path of least resistance for developers building agent features into existing apps. If it does, it could become as fundamental to agent UIs as REST or GraphQL are to APIs.

Frequently Asked Questions

What is A2UI?

A2UI (Agent-to-User Interface) is an open protocol and set of libraries developed by Google that enables AI agents to dynamically generate user interfaces. Instead of outputting plain text or simple data, an agent following the A2UI spec can describe interactive UI elements like forms, buttons, and charts. A runtime on the client side then renders this description using the application's own pre-built UI components (like React or Flutter widgets), ensuring a native look and feel.

How is A2UI different from an AI generating HTML?

The key difference is integration and consistency. If an AI generates raw HTML, it creates entirely new, foreign markup that is disconnected from the host application's design system, state management, and accessibility features. A2UI acts as a translation layer. The agent describes the intent (e.g., "a date picker for check-in"), and the A2UI runtime maps that to the application's actual DatePicker component. This means the generated UI automatically inherits the app's styles, themes, behaviors, and any custom logic attached to those components.

What frameworks does A2UI support?

The A2UI 0.9 release includes official support and renderers for React, Flutter, Angular, and Lit. A core web library provides the foundation. Google has also announced an initial Agent SDK for Python to help build agents that use the protocol, with SDKs for Go and Kotlin in development. The protocol itself is designed to be framework-agnostic, so communities can build additional renderers.

Can I use A2UI with AI models from OpenAI or Anthropic?

Yes. The A2UI protocol is model-agnostic. Any AI model or agent system that can be prompted or fine-tuned to output valid A2UI schema descriptions can use it. The integrations mentioned with Vercel's AI SDK and Oracle's Agent Spec are early indicators that the protocol is intended for use across different AI backends, not just Google's Gemini models.

---

Originally published on gentic.news