For the last few years, the industry has treated AI as a conversational layer—essentially a sophisticated command line that happens to speak English. We’ve spent our time refining prompt engineering, polishing chat bubbles, and adding “regenerate” buttons. This is conversational UI: a request-response loop where the human remains the primary engine of execution, and the AI is a highly capable assistant.
But a structural shift is occurring. We are moving from asking to assigning. This is the transition from conversational UI to delegative UI, where the user provides a goal and a set of constraints, and the AI agent autonomously determines the steps, selects the tools, and executes the workflow to completion. This transition demands a fundamental shift in how we approach agent UX—the design of interfaces where software acts on behalf of users rather than waiting for prompts.
This is not a subtle evolution of the chatbot. It is a fundamental change in the relationship between the user and the software. In conversational UI, the design object is the interaction (the prompt and the reply). In agent UX, the design object is the intent and the subsequent governance of the agent’s behavior.
The urgency of this shift is highlighted by a stark contradiction in current market signals. Gartner projects that 40% of enterprise applications will integrate task-specific AI agents by the end of 2026, up from less than 5% in 2025. Yet, there is a simultaneous warning that a significant portion of these agentic projects may be canceled by 2027 due to inadequate controls and unclear value. This gap suggests that while the technical capability for autonomy exists, the design patterns for managing that autonomy do not. We are attempting to deploy autonomous agents using interfaces designed for chatbots, and the result is a collapse of trust.
Generative UI vs. controlled composition: the A2UI model
One of the most immediate tensions in agent UX is how the interface actually manifests. If an agent is performing a multi-step task—say, researching a travel itinerary, booking flights, and adding events to a calendar—should it simply tell the user what it did in a chat window, or should it generate a bespoke interface to manage that specific process?
The industry is currently split between two paths: unconstrained generative UI (where the AI writes code on the fly to render a UI) and controlled composition. The latter is exemplified by Google’s A2UI project. In this model, the agent does not invent the UI from scratch; instead, it describes the required interface using a predefined catalog of components controlled by the receiving product.
This distinction is critical. Fully generative UI often suffers from “hallucinated” interactions—buttons that don’t work, inconsistent styling, and massive security vulnerabilities. Controlled composition ensures that the rendering, accessibility, and brand consistency remain within the product’s design system, while the agent decides which components are necessary for the current goal.
For product designers, this means our role is shifting. We are no longer designing static screens; we are designing a “grammar” of components that an agent can assemble. We are moving toward agent-facing infrastructure, where the design system serves as a menu of capabilities the AI can invoke to communicate state and request validation.
Four agent UX patterns traditional design systems don’t solve
Most existing design systems are built for human-driven navigation: a user clicks a button, a page loads, a form is submitted. Agent UX introduces a different set of failure modes and requirements because the software is now acting on the user’s behalf, often in the background.
Transparency layers: showing reasoning, not just results
In a standard UI, we show the result. In a delegative UI, the “how” is often more important than the “what.” If an agent autonomously cancels a subscription or moves funds between accounts, a simple “Task Completed” notification is insufficient and anxiety-inducing. Agent UX requires transparency layers that expose the agent’s reasoning mid-execution.
This isn’t about dumping a technical log on the user. It’s about designing “reasoning breadcrumbs”—high-level signals that indicate why the agent chose a specific path. When the agent deviates from the expected route, the transparency layer allows the user to spot the error before the action is finalized.
Override controls: interrupting the loop
Traditional UI handles errors via validation messages. Agent UX must handle “course correction.” When an agent is executing a 10-step plan, the user needs a way to interrupt, modify a single step, and resume without resetting the entire goal.
This requires a “malleable canvas” approach. Instead of a linear chat history, the agent’s plan should be presented as a living document or a sequence of blocks. The user should be able to reach into the middle of an active execution, tweak a constraint (e.g., “Actually, keep the budget under $500 instead of $700”), and watch the agent recalculate the remaining steps in real-time.
Risk-calibrated confidence indicators
We have seen many attempts to add “confidence scores” (e.g., “I am 85% sure this is correct”) to AI interfaces. As noted in critiques of trustworthy AI UI, these are largely useless because they are calibrated to model probability, not human risk. In agent UX, confidence must be mapped to the stakes of the action.
A low-risk action (summarizing a document) requires zero validation. A high-risk action (sending an email to a client) requires a “hard stop” for human approval. The interface must dynamically shift its friction based on the risk profile of the task, moving from full autonomy to “human-in-the-loop” validation seamlessly.
Named failure modes and recovery paths
When a human fails at a task in a UI, they just try again. When an agent fails, it can fail in ways that are invisible or catastrophic. Agent UX requires “named failure modes”—specific, user-facing explanations of why an autonomous action stopped.
Instead of a generic “Something went wrong,” the system must communicate: “I reached the payment screen, but the credit card on file was declined. Please update your payment method to continue.” The design challenge here is creating remediation paths that allow the user to fix the specific blocker and hand the task back to the agent without starting over.
The interface as accountability layer
If we accept that software is moving from a tool we operate to an agent we manage, the purpose of the interface changes. The UI is no longer the presentation layer for data; it is the accountability layer between user intent and autonomous action.
Chatbot skins fail as agent interfaces because they hide the system’s state. A chat bubble is a black box; you put a prompt in, and a result comes out. In a delegative system, the “black box” is the primary source of user anxiety. If the interface doesn’t provide a way to audit the agent’s logic, the user will never grant it true autonomy.
This shift redefines the designer’s responsibility. We are no longer arranging pixels to facilitate a click; we are designing trust contracts. We are deciding where the agent’s autonomy ends and where human governance must begin. The goal is “progressive delegation”—a process where the agent earns more autonomy over time by demonstrating reliability on low-stakes tasks, effectively building “conversational capital” with the user, a concept emphasized in Agentic Experience Design (AXD).
What gets designed when the interface generates itself?
As we move toward systems where the UI is composed dynamically by an agent, the daily artifacts of product design will change. We will spend less time in Figma drawing high-fidelity screens for every edge case and more time designing the constraints and schemas that govern how those screens are assembled. This mirrors the broader shift toward systems thinking in product design, where the focus moves from the individual screen to the underlying logic of the experience.
The new handoff artifacts for agent UX will likely include:
- Component Catalogs: A library of “agent-invokable” components with strict input/output definitions.
- Composition Rules: Logic that defines which components can be paired together and the hierarchy of information for different goal types.
- Fallback Specifications: Detailed maps of what happens when an agent cannot find a suitable component to represent a state.
- Governance Maps: A matrix of task risks that determines when an agent can act autonomously versus when it must trigger a “Human-in-the-loop” (HITL) request.
Success in this new paradigm will not be measured by time-on-task or click-through rates. Instead, the primary metrics for delegative UI will be:
- Intervention Rate: How often does a user feel the need to override an agent’s plan?
- Recovery Success: When an agent fails, how quickly can the user provide the necessary correction to resume the task?
- Autonomy Expansion: Does the user increase the scope of tasks they delegate to the agent over time?
The transition to agent UX is a move toward a world where the most successful interfaces are the ones that effectively disappear, leaving behind only the governance tools necessary to ensure the software is doing exactly what we intended. The challenge for designers is to ensure that in our quest for autonomy, we don’t accidentally design ourselves out of the loop, leaving users feeling surveilled rather than empowered.
