Software interfaces have always been built for one kind of actor: a human clicking through screens that behave the same way every time. AI agents introduce a second actor, one that works over minutes, produces interface as well as text, and needs to be supervised while it runs. Agentic UI is the interface layer built for that two-actor world.
What makes a user interface agentic?
Four capabilities separate an agentic interface from a conventional one. An application does not need all four on day one, but a mature agentic UI has each of them.
- Streaming output. Agents work for minutes, not milliseconds. An agentic interface shows the work as it happens: tokens as they generate, tool calls as they fire, intermediate results as they land. A spinner followed by a final answer is the request-response pattern wearing an agent costume.
- Shared state. The user and the agent operate on the same application state, and each sees the other’s changes immediately. When the agent updates a document, a form, or a plan, the interface reflects it; when the user edits the same object mid-run, the agent works from the edit, not from a stale copy.
- Human-in-the-loop interaction. The connection runs in both directions while the agent works. Users interrupt, redirect, answer the agent’s questions, and approve or reject consequential steps before they execute. The interface is where that steering happens, so it must expose intervention points rather than a single cancel button.
- Generative UI. Agents respond with interface, not only prose: a chart instead of a table of numbers, a booking card instead of a paragraph describing a flight. Generative UI spans a spectrum from agents selecting developer-built components to agents composing or generating interface outright; the generative UI spectrum maps those bands in detail.
The four capabilities reinforce each other. Streaming makes the agent’s work visible, shared state makes it grounded, human-in-the-loop makes it correctable, and generative UI makes it usable. Remove one and the others weaken: approvals without streaming ask users to judge work they never saw, and generative UI without shared state renders components that drift out of sync with the application.
Agentic UI vs. traditional UI
Traditional UI is built on the request-response assumption: the user acts, the system answers, and the exchange ends in milliseconds. Everything about conventional interface design flows from that assumption. Screens are deterministic because the software is. Loading states are brief because responses are fast. Nothing changes unless the user changes it, so there is no need to display another actor’s activity.
Agents break every one of those assumptions. A session is long-running, so the interface must narrate progress instead of blocking on a result. The agent acts on the application, so the interface must render changes the user did not make. Outcomes are non-deterministic, so the interface must support review and correction rather than assume the first result is final. Connections drop mid-run, so sessions must reconnect and resume without losing the thread. Traditional UI has no vocabulary for any of this; agentic UI is that vocabulary.
Agentic UI vs. chat UI
The two terms get conflated because chat was the first surface where agents met users, and for a while the chat window was the only agentic interface most people had seen. But chat is one surface; agentic UI is the capability set. A chat window with none of the four capabilities (a text box that returns completed answers) is chat UI without being agentic. A dashboard with no conversation anywhere can be deeply agentic if it streams agent activity, shares state with a running agent, and asks the user to approve consequential actions.
The practical consequence: “add a chatbot” and “build agentic UI” are different projects. The first adds a conversational widget. The second wires an agent into the application’s interface so that humans and agents can genuinely work together, wherever in the application that work happens.
Where does agentic UI show up?
Agentic UI appears on three application surfaces, distinguished by how much the application mediates the interaction.
- Chat. A threaded, turn-based conversation where agent work streams into the thread and generative UI appears inline as cards and blocks. Support agents, Q&A, and guided workflows live here.
- Chat plus canvas. A conversation pane beside a shared working area. The chat carries steering and approvals while the canvas holds the evolving artifact: a document, a plan, a design, a spreadsheet. This is the natural surface for co-creation, where shared state does the heaviest lifting.
- Chatless, or embedded. No conversation surface at all. The agent communicates with the application, and the application renders agent output as part of its native interface: suggestions inside a dashboard, drafted fields inside a form, triage decisions inside a queue. Users may never think of it as an agent; they experience a product feature.
Applications built around these surfaces from the ground up, rather than adding an assistant to the side, are what agent-native applications are. And the depth of agency behind the interface varies too: the same surfaces serve both copilots and autonomous agents, a distinction covered in copilots vs. agents.
What infrastructure does agentic UI need?
Every capability above is a transport problem before it is a design problem. Streaming needs an event channel that survives disconnects and resumes. Shared state needs synchronization between the agent runtime and the application frontend. Human-in-the-loop needs a bi-directional connection that can pause an agent mid-run and carry the user’s answer back. Generative UI needs a wire format for components, not just tokens.
In the three buckets of the agentic world, this is the second bucket: agent-user connectivity, the layer that connects agents to user-facing applications. It sits alongside agent orchestration (how agents reason and call tools, where MCP connects agents to tools and A2A connects agents to each other) and agent learning (how deployed agents improve from every interaction).
The connectivity layer is standardized by AG-UI, the open Agent-User Interaction protocol. AG-UI defines the event stream that carries agent output, state synchronization, human-in-the-loop interactions, and generative UI between any agent backend and any application frontend. With the transport standardized, agentic UI becomes a design surface to build on rather than infrastructure to reinvent, which is the same shift HTTP brought to the web: nobody builds the pipe anymore, they build what flows through it.
