A2UI is a protocol that lets AI Agents move beyond chat by generating agent-driven, on-demand interfaces using a declarative UI model.
By reducing multi-step conversations into structured interactions, A2UI improves reliability, speed, and execution in real-world workflows.

AI systems have come a long way in the last two years. Today, they can reason over data, draft reports, and plan multi-step workflows. Yet, for most users, the way we interact with these systems hasn’t evolved much. We still type instructions into a chat box and wait for text responses.

This mismatch creates friction. Users end up explaining what they want across several messages, correcting misunderstandings, and confirming details that could have been captured upfront. As the number of steps involved increases, the interaction and experience become more tedious.

This is where A2UI comes into play. A2UI enables agent-driven interfaces to move beyond chat by allowing AI agents to present on-demand interfaces like forms, tables, or visual components generated specifically for the task at hand.

These interfaces are defined using a declarative UI model, making them safe, consistent, and adaptable across products. Together, they form the foundation for what many teams are now calling adaptive AI-powered UI.

What Is A2UI?

A2UI (Agent-to-User Interface) is a protocol that enables AI Agents to create custom visual interfaces for users, rather than using text-based chat.

Instead of responding with a paragraph like, “Please enter the date, location, and number of participants,” an agent can request a structured interface that already contains those fields. The application receives this request as structured data and renders it using its own UI components.

This approach shifts responsibility from developers to the AI Agent. The agent decides what the user needs to see to complete a task, while the application decides how that interface is rendered.

The Power of a Declarative UI

A key reason A2UI works in real systems is its use of declarative UI.

In this model, the agent never sends executable code to the application. Instead, it sends a structured JSON "blueprint" that describes which UI components should appear, how they relate to one another, and what data they should display. The host application then renders those components using its own design system.

This approach is better for two main reasons:

Security: Since the agent only sends data, not code, there is no risk of the AI running malicious scripts in your system.
Native Feel: The host application stays in control. It receives the blueprint and draws the components using its own styles and themes, so the AI-generated tools look like a natural part of the app.

By treating the interface as data, A2UI separates the "what" (the component) from the "how" (the rendering). This makes it easy for Large Language Models to suggest changes piece-by-piece, correcting errors as they stream the output.

From Chat to Agent-Driven Interfaces

Chat interfaces are great for exploration or open-ended discussion, but struggle when the goal is execution.

Consider a common workflow like booking travel or approving expenses. In a chat-based system, the AI has to ask questions one by one. It asks about the date, then the location, then your preferences, and so on. Each question-and-answer adds another step where things can go wrong or get confusing.

With agent-driven interfaces, the agent collapses these steps into a single interaction. Instead of asking multiple questions, it presents an interface that captures all required inputs at once, reducing the back and forth. These on-demand interfaces appear only when needed and disappear once the task is complete.

The benefit is not just speed, but reliability. Fewer conversational turns mean fewer chances of mistakes.

Adaptive AI-Powered UI in Practice

Traditional software relies on predefined screens and flows. Designers attempt to anticipate every path a user might take, which becomes increasingly difficult as workflows grow more complex.

Adaptive AI-powered UI takes a different approach. Instead of locking users into fixed screens, the interface adapts based on intent, context, and the state of the task. With A2UI, the agent determines which components are needed at a given moment and requests them dynamically.

This adaptability is especially useful in operational and internal tools, where the same system may serve users with very different goals. It also supports accessibility more naturally, since the application renders interfaces using native components that already support keyboard navigation, screen readers, and other assistive features.

Solving the Reliability Problem

One of the most common concerns with AI Agents in production is reliability. Even a well-performing model can fail when interactions span many steps.

A useful way to think about this is probability. If an agent succeeds 95 percent of the time at each step, a ten-step chat interaction has a much lower overall success rate. Each additional turn compounds the risk.

Agent-driven interfaces reduce this risk by reducing the number of steps. Instead of guiding users through a long conversation, the agent presents a single structured interface that captures everything required to move forward. The outcome is more predictable and easier to monitor.

Where A2UI Fits in the Agentic Stack

A2UI is not a standalone solution; to understand the complete value of these tools, it helps to know how they fit into the broader ecosystem.

It fits into a broader ecosystem of agent technologies. In a typical setup, AG-UI connects user interactions to the agent runtime, A2UI defines the declarative interface the agent wants to present, MCP handles access to tools and data, and A2A enables agents to delegate tasks to one another.

AG-UI: The "plumbing" that connects the user to the agent runtime.
A2UI: The spec that defines the declarative UI the agent wants to show.
MCP: The standard for how agents talk to external tools and data.
A2A: How agents talk to other agents to delegate work.

Organizations using this stack are seeing massive productivity gains. By moving to agent-driven interfaces, they are cutting release cycles from weeks to hours and ensuring their AI projects actually deliver on their promises.

Planning for Agent-Driven Interfaces in 2026

As AI systems become more proactive, demand for secure, reusable UI generation will increase.

Teams preparing for this shift should focus on:

Building a trusted catalog of UI components
Defining guardrails for what agents can render
Keeping humans in the loop for sensitive actions

A2UI provides the standard format that makes this possible.

For teams looking to apply these ideas today, platforms like C1 by Thesys already put A2UI principles into practice by allowing AI outputs to be rendered as structured, interactive interfaces instead of plain text.

C1 by Thesys integrates seamlessly with your AI stack, from popular LLMs like OpenAI, Anthropic, etc. to frameworks like Vercel AI SDK, CopilotKit, Mastra, LangChain, LangGraph, CrewAI, Autogen, and Streamlit, helping you build Generative UI experiences that work everywhere.

If you’re exploring agent-driven interfaces or adaptive AI-powered UI in your product, it’s worth seeing how these patterns work in real applications.

Explore C1 by Thesys to see agent-generated UI in action.

FAQs: Understanding the A2UI Protocol

1. What is A2UI?
A2UI is an open protocol that lets AI Agents build native, interactive tools on the fly using structured data instead of plain text.

2. Is it safe for enterprise systems?
Yes. Because it uses a declarative UI model, agents only send data "blueprints," not executable code, keeping your system secure.

3. What are on demand interfaces?
These are temporary tools created by an agent to solve a specific task and then disappear, removing digital clutter.

4. How does it improve business ROI?
It replaces long text conversations with single graphical steps. This reduces mistakes and helps automated tasks succeed more often.

5. Can I use A2UI with my current app?
Yes. It is framework-agnostic, meaning it works with React, Flutter, and native mobile apps

Related articles

May 2026 Security Incident

Why We're Open Sourcing OpenUI

AI Copilots: A Complete Guide to Intelligent Assistance

What Are AI Agents: Types, Capabilities, and Real-World Use

ChatKit: What It Is, What It Isn’t, and Where C1 Fits In

PowerPoint Automation Reimagined with C1 Artifacts API

The Future of AI Interfaces is Generative

MCP UI: Making AI Apps Interactive

What Is AG-UI and Why It Matters for AI-Native User Interfaces

How to design AI-Native Conversational Interfaces : From Templates to Generative UI

GPT 5 vs. GPT 4.1

How to Build Generative UI Applications

Implementing Generative Analytics with Thesys and MCP

Evolution of Analytics: From Static Dashboards to Generative UI

Why Generating Code for Generative UI is a bad idea

Building the First Generative UI API: Technical Architecture and Design Decisions Behind C1

How we evaluate LLMs for Generative UI

Generative UI vs Prompt to UI vs Prompt to Design

Generative UI: What It Is and Why It Matters