As AI agents transition from simple conversational chatbots to autonomous actors capable of executing complex workflows, a major friction point has emerged: the conversational bottleneck.
Consider a typical interaction where a user wants to book a flight:
User: "Book a flight from DFW to DAA."
Agent: "Is it one-way or round trip?"
User: "Round trip."
Agent: "Please tell me a date."
User: "Nov 11, 2026."
Agent: "Return date?"
User: "Jan 25, 2027."
Agent: "Is it a flexible plan to search for low cost?"
User: "Yes."
Agent: "How many stops preferred?"
User: "1 or 2."This multi-turn interrogation typically takes anywhere from 1 to 5 minutes just to collect basic parameters before the agent can even begin its search. For the end-user, this sequential questioning is often more tedious and time-consuming than navigating a traditional website directly.
The Proposed Solution: Contextual Dynamic UIs
Instead of bogging down the user with a tedious succession of chat prompts, agents should leverage A2UI to dynamically emit structured user interfaces—such as pre-populated input forms—tailored specifically to the context, theme, and design guidelines of the host application.
By presenting a native form rather than a conversational wall of text, users can review all parameters at a glance, fill them out simultaneously, and submit their request instantly.
The A2UI Solution
The core philosophy behind A2UI is elegant and secure: Send Data, Not Code.
Rather than generating arbitrary, insecure code (such as raw HTML or client-side scripts) that the host application must execute, the AI agent transmits lightweight JSON messages. These messages simply reference a pre-defined, trusted catalog of components already built into your application.
Your application then renders these components natively across web, mobile, and desktop environments using its own established design system—ensuring complete visual consistency, responsiveness, and safety without the security risks of executing arbitrary code.
Who Decides the UI Layout?
The choice of interface (e.g., whether to display a form, a list, or a card grid) is determined dynamically by the model based on carefully configured system prompts, schemas, component catalogs, and layout rules.
For example, a directive might specify:
"If there are 5 flights or fewer, you MUST use the single-column list template."The application/a2ui+json Protocol
To signal and handle these dynamic elements, A2UI leverages a custom MIME type:
Core Primitives Inside the Protocol
application/a2ui+json
The payload handles UI construction through a modular set of core actions:
createSurface: Initializes a new rendering container or workspace on the client.updateComponents: Adds or modifies UI components within an active surface.updateDataModel: Synchronizes state changes between the agent and the client data model.deleteSurface: Dismantles and removes a surface when no longer needed.action: Binds user interactions back to execution pathways.
Streaming UI via Flat JSON
Traditional architectures often require waiting for an entire JSON payload to complete before rendering anything on the screen. A2UI bypasses this latency bottleneck by utilizing flat JSON streaming.
By emitting lightweight, flat component objects sequentially, the client can render UI elements incrementally in real-time as the agent streams the response. Component updates or modifications are isolated and handled instantly without re-rendering the entire view tree.
Flat json streaming through agent
Full json vs flat json
Handling User State and Entries
1. Local State Management
When a user enters values into a form field (such as typing a restaurant name or setting a time), the data is stored instantly within the client’s local model. No round-trip network request to the agent is required during local typing.
{
"form": {
"rep": "",
"when": ""
}
}
2. Server-Driven State Updates
When the agent needs to programmatically inject or update data into the form (e.g., autofilling location data), it pushes an updateDataModel command:
{
"updateDataModel": {
"path": "form/rep",
"value": "Bar Mila"
}
}
3. Client Submission Payload
When the user triggers a submission (such as clicking Confirm Booking), the client transmits a compact, structured message back to the agent containing three essential parameters:
{
"name": "confirm", // Which control/action was activated
"surfaceId": "book", // Which surface the action originated from
"context": {} // The snapshot context of the data model
}Security, Performance & Conclusion: The Future of Agentic Interfaces
As autonomous agents scale to handle increasingly sophisticated backend operations—from enterprise resource planning to multi-step travel and financial transactions—the user experience must evolve in tandem. Relying on conversational text for multi-parameter entry creates an unnecessary friction trap.
By combining the A2UI protocol with flat JSON streaming, developers achieve three distinct advantages:
- Uncompromised Security: By adhering strictly to the “Send Data, Not Code” philosophy, applications remain entirely secure. Because the host application manages the trusted component library locally, agents never inject arbitrary executable scripts or raw HTML payloads into the client environment.
- Sub-Second Perceived Latency: Flat JSON streaming breaks the traditional waiting cycle, allowing UI components to render incrementally and responsively as the model generates output.
- Frictionless User Experience: Users are liberated from tedious conversational interrogations, replacing multi-turn questioning with native, pre-populated interactive forms that can be reviewed and submitted instantly.
By shifting agent output from unstructured text to structured, native component references, A2UI bridges the gap between conversational intelligence and enterprise-grade user experience—paving the way for the next generation of seamless, human-in-the-loop applications
References
https://a2ui.org
https://www.youtube.com/watch?v=fTtfK_vHPxo&t=349s