A2UI is an open protocol developed by Google that enables AI agents to generate rich, interactive user interfaces that render natively across web, mobile, and desktop platforms. It solves the critical problem of how AI agents can safely send rich UIs across trust boundaries by providing a declarative data format, not executable code. This protocol is designed for developers and organizations building AI-driven applications where agents need to present dynamic interfaces without the security risks of arbitrary code execution. Its core value lies in allowing agents to speak a universal UI language, ensuring safety and cross-platform consistency.
The concrete problem A2UI addresses is the inherent risk and complexity when AI agents need to generate user interfaces. Traditionally, agents might send text-only responses, which are limited, or attempt to execute code, which poses significant security threats like UI injection attacks. A2UI eliminates this dilemma by letting agents send declarative component descriptions that clients render using their own native widgets. This matters profoundly to users because it maintains security boundaries—agents can only use pre-approved components from a catalog—while enabling rich, interactive experiences. It fundamentally changes how agents and clients communicate, prioritizing safety without sacrificing capability.
One major feature group is its secure by design architecture. A2UI uses a declarative data format, not executable code, which means agents can only use pre-approved components from your catalog. This prevents UI injection attacks because the agent cannot inject arbitrary code or components. The protocol ensures that all UI generation happens within a controlled, predefined set of components that the client application trusts and has implemented natively. This security model is crucial for applications operating across trust boundaries, such as those integrating third-party AI services, as it guarantees that the agent's output is safe to render without sandboxing or complex validation.
Another major feature is its LLM-friendly structure. A2UI employs a flat, streaming JSON structure designed for easy generation by large language models. LLMs can build UIs incrementally without needing to produce perfect JSON in one shot, which aligns with how these models generate content. This design allows for progressive rendering, where UI updates stream as they are generated, enabling users to see the interface building in real-time instead of waiting for a complete response. The streaming capability enhances user experience by providing immediate feedback and making interactions feel more responsive and dynamic, which is essential for conversational AI applications.
admin
A third feature group is its framework-agnostic nature and support for custom components. One agent response works everywhere because the same A2UI JSON can be rendered on Angular, Flutter, React, or native mobile platforms using respective renderers. Clients use their own styled native widgets, ensuring consistency with the application's design system. The protocol also supports custom catalogs, allowing developers to define their own component libraries, such as interactive charts or Google Maps, which agents can then utilize. This extensibility means A2UI can adapt to specialized use cases, like data visualization or location-based interfaces, while maintaining the core security and cross-platform benefits.
The overall workflow of A2UI follows a structured interaction flow. First, a user sends a message to an AI agent. The agent then generates A2UI messages describing the UI structure and data. These messages stream to the client application via transports like A2A. The client renders the UI using its native components based on the declarative descriptions. When the user interacts with the UI, actions are sent back to the agent. The agent responds with updated A2UI messages, creating a continuous loop. This methodology emphasizes a prompt-first approach, where the agent drives the interface generation based on conversational context, and the client handles the safe rendering and interaction handling.
Concrete use cases include a landscape architect application where a user uploads a photo, and the agent uses Gemini to understand it and generate a custom form for landscaping needs. Another scenario involves an agent choosing to respond with a chart component to answer a numerical summary question or a Google Map component for a location query, utilizing custom components offered by the client. These demonstrations show how A2UI enables dynamic, context-aware interfaces that go beyond static text. The outcomes for users are rich, interactive experiences tailored to their immediate needs, with interfaces that feel native and responsive, all generated safely in real-time by AI.
Target users include developers integrating AI agents into web, mobile, and desktop applications, particularly those using frameworks like Angular, Flutter, Lit, or React. The tech stack involves the A2UI protocol specifications, client-side renderers for various frameworks, and transports like A2A for communication. The project is Apache 2.0 licensed and in active development on GitHub, with contributions from Google, CopilotKit, and the open-source community. Pricing is not mentioned, indicating it is an open protocol. The summary takeaway is that A2UI provides a secure, LLM-friendly, and framework-agnostic way for AI agents to generate native, interactive UIs, solving the trust and safety challenges in agent-driven interfaces.
Developers and organizations building AI-driven applications that require dynamic user interfaces, particularly those integrating AI agents into web, mobile, or desktop platforms using frameworks like Angular, Flutter, React, or Lit. It targets teams needing secure, cross-platform UI generation from AI agents without executing arbitrary code, including those working on conversational AI, copilots, or agent-enhanced tools.