Agentic UX (AX) is a framework for designing interfaces where humans supervise autonomous AI agents—not merely chat with them. Generative AI has made intent-based outcome specification the default interaction model: users describe what they want; systems orchestrate the steps to get there. Production agents already run for minutes or hours on a user's behalf. What they share is not a chat skin—it is a lifecycle to align before action, show work in progress, and make recovery explicit when something goes wrong.
This article introduces that lifecycle as eleven patterns (before, while, and after an agent run). Each pattern has a dedicated gallery page with anatomy, design guidance, interactive examples, and annotated production screenshots.
Thesis: Supervised Delegation
Traditional UX optimizes discrete tasks: click, type, submit. Agentic UX optimizes delegation under uncertainty. The user states intent; the agent proposes a plan, requests permissions, executes over time, explains decisions, and must offer a credible path back when the result is wrong.
The design goal is not maximum automation—it is calibrated autonomy: enough independence to be useful, enough visibility and control to remain trustworthy. PAIR's User Autonomy principle argues for matching automation to task stakes, expertise, and the effort required to steer the system; Agentic UX operationalizes that at run time as Autonomy Dial and Intent Preview.
Three principles recur across mature products:
- Align before action — Plans and permission boundaries precede irreversible work.
- Show work in progress — Ledgers, sources, and rationales prevent black-box anxiety.
- Make recovery explicit — Undo, checkpoints, and human escalation let users correct course without abandoning the agent.
The shift to outcome-oriented interaction
From process coordination to intent
For decades, digital products asked users to act as coordinators across rigid interfaces—searching, comparing, and reconciling information the system would not connect. Planning a trip meant flights on one site, hotels on another, activities on a third, with the human responsible for dates, tradeoffs, and logistics across tools.
Outcome-oriented design changes the contract. Users specify a desired result or end state; the system handles intermediary search, comparison, and coordination. The interface stops optimizing one path for the average user and starts adapting paths to individual constraints—budget, role, risk tolerance, context.
That is a genuine paradigm shift, not a UI refresh. It moves primary design attention from interaction steps and components to user goals and outcomes, and it automates the more mechanical parts of getting there.
Architects of possibility—not authors of one path
Outcome-oriented products do not eliminate design. They change what design optimizes.
Instead of crafting a single rigid route through a product, designers define the boundaries, quality bars, and frameworks within which an agent may generate a specific path for each user:
- Boundaries — what may be read, written, spent, or sent (Autonomy Dial)
- Quality — what counts as an acceptable plan or result before work proceeds (Intent Preview)
- Frameworks — where paths can be tried safely before they touch production (Sandbox Preview)
- Recovery — how users reverse, audit, or escalate when a path fails (Action Audit, Escalation Pathway)
Agentic UX names the lifecycle surfaces that make those definitions visible at run time—not only in policy documents or settings screens.
Supervised delegation closes the trust gap
Outcome specification alone is not enough for high-stakes or long-running work. When an agent may edit code, send email, or spend research time, fire-and-forget erodes trust quickly.
Supervised delegation is the product layer on top of outcome-oriented execution: users review the plan, grant scope deliberately, observe progress, inspect rationale, and recover when the run diverges from intent. The eleven patterns in this reference are how that supervision shows up in interfaces—grouped by when they appear in a run (before, while, after). PAIR's trust and control guidance emphasizes calibrated trust and clear takeover paths when automation fails; Escalation Pathway and Action Audit & Undo are the agent-run versions of those ideas.
| Traditional design | Outcome-oriented (AI) | Agentic UX (this framework) | |
|---|---|---|---|
| Primary focus | Interaction steps and components | User goals and outcomes | Goals + plan, permission, recovery |
| Interface | Static, optimized for the average user | Adaptive, individualized paths | Adaptive execution + lifecycle surfaces |
| User role | Executes the process | Specifies intent | Specifies intent + supervises the run |
| Designer role | Single optimized path | Frameworks of possibility | Lifecycle architecture and trust boundaries |
What endures in design practice
As more interface execution is automated, human-centered work becomes more strategic, not less relevant:
- Problem framing — choosing which outcomes matter, for whom, and under what constraints
- Critical judgment — evaluating whether an agent's result actually meets the need
- Holistic context — goals that span sessions, teams, policies, and consequences beyond one prompt
- Strategic oversight — ensuring autonomy serves outcomes users can defend
Tactical screen production is increasingly assisted; defining trust boundaries and inspectable runs is not. The role is evolving from building static interfaces to orchestrating adaptive, goal-focused experiences—with explainability, audit, and escalation as first-class design problems.
The Lifecycle Framework
| Phase | Purpose | Patterns |
|---|---|---|
| Before the agent acts | Establish intent and permission | Intent-First, Intent Preview, Clarifying Questions, Autonomy Dial |
| While the agent works | Maintain context, generate fit-for-task UI, preview safely | Progress Ledger, Explainable Rationale, Generative UI, Sandbox Preview |
| After the agent acts | Safety, recovery, return | Action Audit & Undo, Escalation Pathway, Return Moment |
Each pattern below links to its full reference in the gallery (anatomy, guidance, example UI, and production screenshots).
Before the agent acts: Establishing intent
1. Intent-First Interface
The main screen asks what the user wants to do—a large composer with constraints and attachments—not feature navigation. The user's first action is to state intent; the agent turns that goal into a plan. This is how surfaces before the agent acts establish what the run is for before any tool fires.
Intent-First Interface — full pattern
2. Intent Preview (Plan Summary)
Before important or irreversible work, the agent shows a short plan the user can approve, edit, or reject—steps, scope, and risks in plain language. This is the main align before action control for long or high-stakes runs.
3. Clarifying Questions
When a goal is ambiguous, the agent asks a small number of focused, scope-narrowing questions—option cards, structured prompts, or short follow-ups—before drafting a plan. Ask only what changes the plan, then converge.
Clarifying Questions — full pattern
4. Autonomy Dial (Progressive Authorization)
Users choose how much the agent can do on its own—from suggestions only to approved actions—and the product enforces that policy with settings plus runtime consent when scope expands. Permission boundaries belong before and during the run, not only in onboarding.
While the agent works: Providing context
Live status during background agent work
When agents run for minutes or hours in the background, live status answers "is it still working, and on what?" Without semantic updates, silence reads as failure—even when the agent is healthy.
- Live status line — what is happening right now, not only "Processing…"
- Step labels that advance as phases change
- Named artifacts — sources, files, or safe tool labels surfacing in real time
Progress Ledger supplies structure; Explainable Rationale supplies the why; this ambient layer makes both feel alive while the user is away. Avoid static spinners, motion without meaning, and status that stops updating while work continues off-screen.
5. Progress Ledger
A live step list shows what the agent is doing now and what it has finished—pending, active, done, failed—with links to artifacts where possible. This is the structured show work in progress surface for long runs; pair it with semantic live-status copy when users may leave the tab.
Progress Ledger — full pattern
6. Explainable Rationale
The agent explains key choices with facts the user can understand and check—named inputs, policies, or citations—not stack traces or opaque model messaging. Rationale belongs while and after the run so users can supervise and challenge decisions.
Explainable Rationale — full pattern
7. Generative UI
The agent creates forms, charts, or controls that fit the user's current task inside the thread or canvas—UI that did not exist before the prompt. It keeps interaction while the agent works fit-for-purpose instead of forcing every question through static chrome.
8. Sandbox Preview
A safe preview shows the outcome before the user approves a real change to code, data, or live systems. Promotion to production stays an explicit, separate step so users can watch the agent work without betting the production environment.
Sandbox Preview — full pattern
After the agent acts: Safety and recovery
9. Action Audit & Undo
A clear history shows what the agent changed and offers undo or restore when possible—including short-fuse undo for sends and purchases. Make recovery explicit is not optional; one uncorrectable mistake ends trust.
Action Audit & Undo — full pattern
10. Escalation Pathway
When the agent is unsure or the stakes are high, it pauses and brings in a human with context—transcript, collected fields, and a visible handoff—not another autonomous guess.
Escalation Pathway — full pattern
11. Return Moment (Smart Briefing)
When the user returns after hours or days, a short briefing shows what happened, what needs review, and what failed—with deep links, not a wall of narrative. Long-horizon agents need a re-entry surface as deliberate as the plan shown before the agent acts.
Choosing Patterns: A Decision Framework
Use this matrix when designing a new agent surface:
| Dimension | Low risk | High risk |
|---|---|---|
| Ambiguity | Clarifying Questions optional | Clarifying Questions → Intent Preview |
| Duration | Progress Ledger optional | Intent Preview + Progress Ledger required |
| Reversibility | Light audit | Undo + checkpoints + Sandbox Preview |
| Autonomy | Suggest-only default | Per-domain Autonomy Dial |
| Evidence quality | Rationale on demand | Rationale tied to named sources for every claim |
| Re-entry | Notifications | Return Moment briefing |
| Domain | Research, drafting | Money, health, legal → Escalation Pathway |
Trust grows with predictable recovery, not with bolder automation alone. PAIR's patterns on progressive automation and user control frame the same tradeoff at product level; this matrix maps it to agent-specific surfaces by risk, duration, and reversibility.
Conclusion
Agentic UX is not a skin on chat—it is lifecycle design for supervised delegation in an outcome-oriented world. The industry has converged on one contract: align before action, show work in progress, make recovery explicit. Products that feel credible—OpenAI Deep Research, Cursor, Replit, Slack AI, Intercom Fin, v0—share these mechanics even when branding differs.
Build agents as inspectable collaborators: start from the goal, plan first, clarify scope, permission by domain, ledger in flight, rationale tied to named sources, generate fit-for-task UI, preview in a sandbox, audit with undo, escalate when unsure, and brief users when they return. That is the bar for trustworthy Agentic UX—and for the products users will trust. Designers who architect possibilities well—and who wire supervision into every run—are not displaced by automation; they are how those products stay accountable.
Related reading: Designing For Agentic AI (Victor Yocco, Smashing Magazine, Feb 2026) — parallel lifecycle framing and six overlapping pattern names; this gallery extends the set with additional patterns, production examples, and agent-readable specs. People + AI Guidebook (Google PAIR) — cross-functional foundations for human-centered AI, trust calibration, and control; Agentic UX narrows that canon to run-time supervision surfaces for long-running agents.