Google A2UI standardises agent interfaces using declarative data structures

Google has published a new open standard called A2UI that allows artificial intelligence agents to generate rich user interfaces dynamically.confirmed This framework-agnostic protocol enables developers to render agentic UIs across multiple agent frameworks by describing the interface as data rather than executable code.

The evidence

According to an official advisory on the Google Developers blog, agent-user interactions are evolving from simple text exchanges to rich, interactive interfaces.reported Previously, agents would return walls of text for complex requests, such as holiday packages, lacking standard ways to render selectable lists or maps. Generative UI addresses this by letting agents build interfaces at runtime based on each specific request.

A2UI serves as the layer that describes these interfaces.reported The agent outputs data describing the UI, and the application draws it using existing components. This approach is transport-agnostic by design. CopilotKit provides the necessary agent-integration stack to connect frameworks like LangChain, AWS Strands, Microsoft agents and Google ADK to this rendering capability.

The decision

The advisory notes that generative UI approaches range from controlled to open-ended. At the controlled end, developers build components ahead of time, and the agent selects which to render. This method is brand-safe but limits deep customization. At the open end, agents return raw HTML, JavaScript or Dart code rendered in sandboxed iframes. This allows flexibility but risks design drift and executes model-written code.

A2UI operates across this entire spectrum.reported It supports controlled generation with decision models like Typesafe’s Jev and open-ended code generation that outputs A2UI JSON messages.reported However, the declarative mode, where agents assemble pre-declared components and functions, is reported as the most popular approach.reported This allows local or remote agents to generate UI from existing component catalogs using a common language.

The takeaway

Security is a primary design principle of the A2UI standard.reported Because it is a declarative data format rather than executable code, the client maintains a catalog of trusted components. Any element the agent invents outside this set is caught before it reaches the screen. This prevents the execution of untrusted code while still allowing for dynamic interface generation.

The payload structure is designed to be LLM-friendly and supports streaming. It consists of a flat list of small JSON messages that reference each other by ID. This allows the agent to emit the interface incrementally, and the client can render components as they arrive, improving perceived performance and responsiveness for the end user.

Building on this

Developers can leverage the Basic Catalog, which ships with 18 general-purpose primitives covering layout, display, input and containers. Agents can compose entirely different interfaces from these same 18 primitives depending on the request needs.reported However, the Basic Catalog is deliberately sparse, meaning most production applications will likely define their own custom catalogs.

A custom component can be anything the frontend already renders, such as a live map that the agent fills with coordinates while the renderer draws the route. Frontend developers can ship these building blocks once, and the agent composes them for each specific request. The same response can render through React, Lit, Angular, SwiftUI, Jetpack Compose or Flutter, with community renderers available for Vue or even the terminal.