Learning Path

Agentic Experience Design (AXD) is the design discipline concerned with creating usable, explainable, and trustworthy interactions between humans, AI agents, and the systems those agents act on. Where traditional UX designs for direct manipulation — the person clicks the button themselves — AXD designs for delegated autonomy: a person states an intent, an agent carries it out, and the interface exists to make that work legible, supervisable, and correctable. Its central questions are not “can the user complete this task?” but “does the user understand what the agent is about to do, can they stop it, and can they undo it?”

The name is deliberate. “Agentic” distinguishes these systems from AI features that only produce text or predictions: an agent takes actions with consequences in the world — sending an email, filing a ticket, editing a file, buying something. “Experience” rather than “interface” because much of what the designer shapes happens away from the screen: what the agent is permitted to do, when it interrupts, what it reports afterward, and how a person recovers when it gets something wrong.

How AXD differs from UX and conversation design

AXD does not replace either discipline — it borrows heavily from both. The difference is who performs the action and what the interface is therefore for.

Traditional UX

Model: direct manipulation.

The person performs every step. The interface’s job is to make the next step obvious and the system state visible. Affordances constrain what can happen: if there is no delete button, nothing gets deleted.

Conversation design

Model: dialogue.

The person and the system exchange turns to reach shared understanding. The craft is in prompts, repair, disambiguation, and tone. The system mostly answers, retrieves, or routes — it rarely commits irreversible acts on its own.

AXD

Model: delegated autonomy.

The person delegates an outcome and the agent decides the steps. The interface’s job is oversight: showing intent before action, exposing a stop control during action, and giving an honest account with a path to reversal afterward.

A useful test: if you can enumerate every state the user can reach by clicking, you are doing UX. If you can enumerate every turn the system might take, you are doing conversation design. If you can enumerate neither — because the system will compose its own sequence of tool calls to satisfy an intent you only partially specified — you are doing AXD.

Why traditional UX patterns break down

Most of the UX canon assumes the user is the actor. Remove that assumption and a surprising amount stops working:

Affordances stop constraining behavior. In a click-driven product, capability and interface are the same thing. An agent’s capability is its tool set, which is usually far wider than anything rendered on screen. The visible UI no longer tells the user what is possible.
Feedback arrives after the fact, not during. Classic heuristics ask for visibility of system status while the user acts. An agent may work for minutes across systems the user is not looking at. Status has to be pushed, summarized, and made resumable rather than simply displayed.
The error model inverts. Traditional error prevention stops the user from doing the wrong thing. Here the system is the one that may do the wrong thing, confidently and quickly, at a scale a person would never reach by hand. Prevention shifts from input validation to scoping, confirmation thresholds, and reversibility.
Consent granularity is unresolved. A single delegated request can expand into dozens of consequential steps. Approving each one destroys the value of delegating; approving none is a blank check. The design problem is choosing which steps deserve a stop.
Mental models form from behavior, not layout. Users learn what a conventional app does by looking at it. They learn what an agent does by watching it succeed and fail. Onboarding becomes calibration work, not a tour.

The core problems AXD solves

Trust calibration

The goal is not maximum trust but accurate trust. Over-trust means a person rubber-stamps approvals they should have read; under-trust means they supervise so closely that delegation saves nothing. Interfaces calibrate by being specific about what the agent is reliable at, by showing its work at a resolution the user can actually check, and by failing visibly rather than quietly.

Legibility of intent

Before an agent acts, the person should be able to see what it believes it was asked to do, the plan it derived, and the specific next operation — in the user’s terms, not as raw tool calls. Legibility is what makes supervision possible at all: you cannot approve what you cannot read, and a wall of trace output is not readable.

Recovery from wrong actions

Agents will act on misread intent, stale data, and bad pages. The design question is what the person can do about it thirty seconds later and thirty minutes later. That means an activity record specific enough to identify the bad step, undo where the underlying system supports it, and a documented compensating path where it does not.

Consent for consequential steps

Reading a page, drafting a message, and spending money are not the same act and should not carry the same confirmation. Consent design means classifying actions by consequence and reversibility, attaching the friction to the classification rather than to the moment, and letting a person set standing limits in advance so routine work does not require an interruption.

How AXD relates to AXO

Agent Experience Optimization (AXO) and Agentic Experience Design are two halves of the same shift, pointed in opposite directions.

AXO

How your content, product, and data are found, understood, and used by agents. The audience is the machine: structure, retrievability, machine-readable claims, citation-worthy sourcing, and the interfaces a site exposes for automated use.

AXD

How a person experiences working with an agent. The audience is the human: what they see before, during, and after delegation, and how much control they keep over an actor that is not them.

They meet in products that are both — an application that an agent operates on a customer’s behalf has to be legible to the agent (AXO) and accountable to the person (AXD). If you only do AXO, agents can use you but nobody can tell what they did. If you only do AXD, you build a careful supervision layer over systems agents cannot reliably operate.

What AXD work actually looks like

In practice the discipline produces a recognizable set of artifacts, most of which have no equivalent in a conventional design process:

An action taxonomy: every operation the agent can perform, classified by consequence, reversibility, and who may authorize it.
An oversight model: which interaction model applies where, and what triggers a move from autonomous to supervised execution.
Intent and plan surfaces: the specific language and layout used to state what the agent understood and what it will do next.
Interruption and recovery flows: stop, amend, resume, and undo — designed as first-class paths rather than error states.
Failure inventories: the ways this agent is known to be wrong, written down and used to decide where confirmation is required.

The rest of this section works through those pieces: interaction models for choosing an oversight posture, design principles for the guardrails, interaction patterns for reusable building blocks, and generative UI for interfaces the model assembles at runtime.

Interaction Models Back to AXD

Stay Updated

Analysis of AI search, crawler policy and agent standards — sent when there is something worth reading, roughly twice a month. Unsubscribe anytime.