Your agents can reason, plan, and act. But how should they present their work so your users understand it best?
Gartner predicts that 30% of all new applications will use AI-driven adaptive interfaces this year, up from less than 5% two years ago. Separately, they forecast that 60% of brands will use agentic AI for one-to-one customer interactions by 2028. McKinsey finds that companies excelling at AI-driven personalization generate 40% more revenue than average players. And when AI-powered interfaces deliver rich, structured content rather than basic conversational responses, conversion rates quadruple (12.3% versus 3.1%).
The business case for agent-generated interfaces is surfacing. Currently, there's a meaningful gap between what agents can do behind the scenes and what they can present to the people using them. At AG2, we're closing this gap.
The Presentation Gap
Agents are increasingly capable, able to orchestrate workflows, call tools, coordinate with other agents. But when it comes time to present results, most are limited to conversational responses. These may include an image or chart, but still embedded in a text block, and that may be adequate for answering questions, but enterprise applications demand richer interaction: product cards with images and pricing, booking forms with date pickers, dashboards with real-time metrics, approval workflows with structured options.
This presentation gap is the disconnect between an agent's ability to reason and act, and its ability to communicate results in the visual, interactive formats users expect. It's not a minor limitation. It's where most high-value enterprise interactions live: placing orders, reviewing reports, comparing options, approving workflows. Jakob Nielsen mentions Generative UI in his 2026 predictions, and highlights that nearly half the population in wealthy countries struggles with complex texts. When agent output requires careful reading and interpretation, adoption suffers.
As a developer, we're used to building specific interfaces to represent data. Rich output from an agent typically means custom rendering logic, bespoke data formats, and fragile integration code. Agents, powered by LLMs, are non-deterministic and orchestrations organic, so tightly coupled interfaces don't work. When Gartner predicts that over 40% of agentic AI projects will be canceled by 2027 due to escalating costs and unclear value, the presentation bottleneck can be considered part of the story. Users need to interact with agents naturally and efficiently, otherwise adoption stalls.
Why Agents Should Generate UI
With the traditional approach to agent interfaces every new capability requires a new screen, a new component, a new deployment cycle.
Agent-driven UI inverts this. Instead of developers pre-building every possible interface, the agent composes the right interface at the moment it's needed based on context, user intent, and the task at hand. A travel agent doesn't need a pre-built hotel comparison page. Instead, when the user asks it to compare options, it generates one with images, star ratings, and a "Book Now" button.
This isn't about replacing designers or frontend developers. It's about closing the presentation gap so that agents can communicate expressively. We don't ask people in a business to communicate only in conversational responses. They use dashboards, reports, forms, and presentations to fit the audience and the message. Agents need the same range of expression.
For enterprises, there's an additional dimension: cross-platform delivery is table stakes. The same agent interaction needs to render on web, mobile, and desktop. Agent-driven UI solves this structurally. Instead of specifying how to render something (HTML, native views, Flutter widgets), the agent describes what to show. The client handles the rendering using its own native components. One agent, every surface.
This is what we've built at AG2 — agents that can now generate their own interfaces through open protocols, served natively across platforms.
A2UI: An Open Protocol for Agent-Generated UI
A2UI (Agent-to-User Interface) is an open protocol, launched by Google, that defines a standard way for agents to describe user interfaces. Rather than each team inventing their own output format, agents produce declarative JSON following A2UI's component catalog. Any A2UI-compatible renderer transforms that into native UI.
The protocol's design reflects a key security principle: the agent describes what to show, never how to render it. The client uses its own trusted, native components. There's no arbitrary code execution, no injected HTML, no cross-site scripting surface. The agent proposes; the renderer decides.
A2UI's basic catalog covers the building blocks most applications need: layout components like Card, Column, and Row; content components like Text (with heading variants), Image, and Divider; and interactive elements like Button, TextField, and ChoicePicker. For domain-specific needs, the catalog is extensible with teams able to define their own catalog of custom components (LinkedIn post previews, product comparison tables, medical intake forms) that the agent learns to generate alongside the standard ones.
What makes A2UI particularly relevant for the agentic ecosystem is its place alongside the other open standards emerging in this space. Just as MCP standardizes agent-to-tool communication, A2A standardizes agent-to-agent communication, and AG-UI standardizes agent-to-frontend streaming — A2UI standardizes what agents can say to users visually. This ecosystem of protocols comes together to create a cohesive stack for how agents connect, communicate, and express.
As an open-source multi-agent framework, AG2 brings these protocols together for effective agentic systems.
AG2's A2UIAgent
A2UIAgent is a new reference agent in AG2 with native A2UI capabilities. It generates structured A2UI output (cards, forms, buttons, images, and custom components) that any compatible A2UI renderer can display natively.
Under the hood, A2UIAgent handles the full lifecycle. It automatically engineers the system prompt with A2UI protocol instructions and the component catalog. Built-in validation and retry ensures the UI output is reliably well-formed, and if it can't be corrected, the agent degrades gracefully rather than rendering a broken interface.
Buttons in A2UI-generated interfaces are functional, connected to real behavior: a "Book Now" button can route directly to a tool that makes the reservation, while an "Open Website" button triggers client-side navigation. The agent defines these actions, and they work across platforms without additional wiring.
To create native UI for your platform, A2UIAgent supports custom catalogs. A marketing team can define a LinkedInPost component; a healthcare team can define a PatientSummaryCard. The agent learns to generate these alongside the standard catalog, producing purpose-built UI from natural language prompts.
A2UIAgent integrates with multiple serving protocols. Over AG-UI, it streams A2UI content to web frontends like CopilotKit's. Over A2A, it serves any A2A-compatible client — including Flutter apps using the GenUI SDK. Both paths use the same agent and this decoupling is what makes cross-platform delivery practical, and no longer aspirational.
Sitting inside an AG2 multi-agent orchestration, an A2UIAgent can be the UI connection, or consider multiple A2UIAgents and multiple UI surfaces to create a more dynamic experience.
What This Means for Businesses
Faster time-to-market. When agents generate UI on-the-fly, the build cycle for new agent experiences shrinks. Adding a new interaction pattern doesn't require a frontend sprint, just a prompt.
Cross-platform without cross-platform cost. One A2UIAgent serves web, mobile, and desktop through standard protocols. No separate rendering logic per platform.
Progressive enhancement. Clients that support A2UI get rich, interactive interfaces. Clients that don't still receive the text response.
Trust and adoption. Rich interfaces give users structured, scannable information in familiar visual patterns. A card with a product image, price, and rating is easier to verify at a glance than a conversational description of the same thing. When users can see and interact with agent output in the formats they're used to, confidence is boosted, and they'll be back.
What's Next
AG2's A2UIAgent currently supports A2UI's latest v0.9 specification and operates over A2A and AG-UI. As new A2UI specifications arrive or protocols change, we'll update A2UIAgent to support them.
Get started with AG2:
- Exploring our A2UIAgent documentation
- Reading our technical deep dive
- Learning about the A2UI protocol
