Authority model
What the agent may do alone, what needs confirmation, and what is forbidden. Mapped to roles and permissions in the product.
Agentic Workflow UX
Agentic workflow UX is designing what happens when the system stops talking and starts acting: planning, tool use, permissions, and rollback for software that changes state on its own. If the product's job is dialogue, see Conversational AI; this page is for when an agent plans, calls tools, and takes actions a human has to be accountable for.
Part of Creation. Category-leaning inbound: buyers know agents are coming and fear silent failure. Actions taken without visibility, approvals skipped, no undo when the tool call was wrong.
Agents are not chat with extra steps. They plan, call tools, and change state. UX must make that legible or users (and compliance teams) will shut the feature down.
Silent agents create silent liability
A demo hides tool calls behind a spinner. Production sends the wrong email, updates the wrong record, or spends budget nobody approved. Users cannot see the plan. Logs exist for engineers, not operators. Undo is undefined.
Accountability is a UX surface. Who approved what, what changed, how to roll back: not a legal footnote alone.
Who it's for
- AI product leads shipping agents that act, not only generate text
- Teams with compliance, finance, or ops approval requirements
- Platforms where tool use must be visible, permissioned, and reversible
- B2B products combining Creation with multi-step automation
Objections we clear
- "Users do not trust the agent to act alone"
- "We need human-in-the-loop but do not know what that looks like in UI"
- "Tool calls are a black box"
- "One bad autonomous action will kill the pilot"
- "Legal asked for audit trails; product has no surface for them"
What we tackle
Plan → act → review
Visible steps: proposed plan, executing, awaiting approval, completed, failed. So users are never surprised by side effects.
Tool transparency
Which tools were called, with what inputs, and what changed. In language operators understand, not raw JSON.
Failure and rollback
Designed recovery when a tool fails, partial completion, or human rejection, including state reconciliation UX.
Human approval moments
Clear approve/reject/edit flows with context preserved. Especially for high-impact actions (send, purchase, delete, publish).
What you get
- Agent task flows and control surface specifications - Authority / permission matrix tied to UX - Transparency and logging patterns (user-facing, not only backend) - Human approval and override interaction designs - Reviewable interaction prototypes - Pilot scope recommendation, one workflow that proves the pattern - Handoff for eng with behavior and edge cases documented
Typical work starts as a pilot sprint on one workflow. See Rates.
How it works
1. Authority model: what the agent may do alone. *Deliverable: permission matrix + policy UX notes.* 2. Plan → act → review: visible steps and status surfaces. *Deliverable: flow specs + UI patterns.* 3. Failure & rollback: designed, not hoped. *Deliverable: error/recovery matrix.* 4. Pilot UX: one workflow end-to-end with eval scenarios. *Deliverable: prototype + handoff + pilot checklist.*
Engagement shapes
- Pilot workflow: one high-value, bounded agent journey
- Audit → agent: UX Audit + AI Readiness then scoped agent UX
- Agent + system: patterns added via AI-native Design Systems
- Expand after pilot: sequence additional tools and approvals once the pattern holds
Related services
- Embedded AI without full agency → Creation
- Chat-primary assistants → Conversational AI
- Inconsistent agent UI → AI-native Design Systems
- Base product gaps → Product & Interface Design
Fit / not for
For products where agency needs accountability and a pilot owner. Not for demos that hide tool calls and hope. Not for fully autonomous systems with no human oversight when your buyers require it.
Frequently asked questions
What is agentic UX?
UX for systems that plan and take actions with tools. Not only generate text. Users need visibility, permissions, and oversight.
How do you handle accountability?
By designing who approves what, what is logged in user-facing surfaces, and how to undo. Accountability is a UX surface, not a legal footnote alone.
Is this ready for production everywhere?
We usually start with a pilot workflow. Agentic UX is emerging; sequencing risk is part of the design.
How is this different from conversational AI?
Conversational AI designs the dialogue — intents, tone, escalation — for a system that talks to someone. Agentic workflow UX designs the authority model, tool transparency, and rollback for a system that acts on its own across multiple steps. Chat can be one control surface inside an agentic system; agency, not conversation, is the product problem here.
Do you implement the agent framework?
We design UX and handoff. Orchestration (LangChain, custom, vendor) is eng's stack. We align specs to what it can expose in UI.
What industries need this most?
Regulated B2B, fintech, ops-heavy SaaS, and any product where automated actions have external side effects, sends, payments, publishes, data writes.
Can agents run fully autonomously?
Sometimes: when policy and risk allow. We design the authority model with you. Many pilots start human-in-the-loop and loosen as trust builds.
How long does a pilot take?
One bounded workflow often fits a focused sprint to prototype + spec. Production hardening is eng timeline; we deliver decision-ready UX.
What happens when an agent needs to coordinate across multiple tools or systems at once?
Multi-tool plans need a UX that shows the full sequence before execution, not just one tool call at a time — so an operator can catch a wrong step before three downstream tools compound it. We design the plan-review surface as its own step, distinct from individual tool transparency.
Pilot agent UX
Name the workflow, the tools involved, and what must never happen without approval. We will propose a pilot scope with visibility designed in.
Book a project call