Learning paths for websites, applications, and AXD.
Agentic interaction patterns
Proven design patterns for human-agent collaboration across different contexts.
These patterns translate the design principles into reusable building blocks. Each pattern describes a recurring problem in agentic products and a proven way to structure the experience.
Eight shapes, each with the situation it suits, the price it charges, and what it means for anything reading the page rather than looking at it. Most products need two or three of these, not all eight. 10 Agentic UX Patterns and Real-Life Scenarios shows a shipping product for each.
Entry point
The affordance that starts an agent interaction: a command palette, a persistent button, a prompt field in the header.
Reach for it when
Any product where the agent is one capability among many. One entry point, reachable from everywhere, beats a widget per page — people learn one gesture rather than hunting for the feature.
What it costs
A floating button is the most-ignored element on most pages. If people do not already expect an agent, the entry point needs a reason to be pressed, and "Ask AI" is not one.
If an agent is reading this
If the entry point is the only route to a capability, that capability does not exist to anything reading the markup. Whatever it opens should also be reachable as a URL.
Inline chat
A conversation embedded in the page, alongside the thing it is about.
Reach for it when
Narrow, local questions where the context is the surrounding content: a document, a record, a dashboard. The page stays, the conversation is about what is on it.
What it costs
Awkward for anything long. A conversation that outgrows its box leaves the person scrolling inside a scroll, and the surrounding content stops being visible anyway.
If an agent is reading this
Inline means the context is implicit — the agent is expected to know which record it is on. Say so in the markup rather than only in the prompt.
Sidebar chat
A docked panel beside the main content, open while the person works.
Reach for it when
Work that continues while the conversation does: writing, reviewing, analysing. Both things are visible, and the agent can reference what is on screen.
What it costs
A third of the width, permanently, whether or not the agent is in use. On anything below a laptop screen it becomes a full-screen panel regardless, so design that state first rather than last.
If an agent is reading this
The commonest mistake here is putting the result only in the panel. If the agent changed the document, the change belongs in the document.
Full-screen chat
The conversation is the interface. No surrounding product.
Reach for it when
Open-ended work with no obvious home screen, and products where the agent is the whole offering rather than a feature of something else.
What it costs
Everything the product can do has to be discoverable from a blank field, which is the hardest discovery problem in interface design. Expect to spend most of the work on the empty state.
If an agent is reading this
A pure chat surface usually has no stable URLs, which means nothing can be linked, cited or returned to. Give conversations and results addresses.
Contextual AI actions
Named operations offered on a specific object: summarise this, rewrite that, explain this error.
Reach for it when
Almost every product, and usually the pattern to reach for before chat. A named action states what will happen, which a blank prompt cannot, and it is the only one of these patterns that teaches the capability by existing.
What it costs
The list grows. Past about five, actions become a menu people stop reading, and the ones that matter get buried under the ones that demo well.
If an agent is reading this
This is the pattern with the clearest machine equivalent. An action with a name, an input and a result is a tool — expose it as one, and an agent can use it without driving your interface.
Feed states
What the conversation shows while it works: streaming text, a step it is taking, a tool it called, a result it got back.
Reach for it when
Any agent that takes more than a second or touches anything outside itself. Showing the step being taken is what makes a long wait tolerable and a wrong turn correctable.
What it costs
Narrating every internal step is its own failure — it reads as busywork and buries the one step that mattered. Show what was done to the outside world, not what was thought.
If an agent is reading this
Streamed text that never lands in the DOM as finished content is invisible to anything that reads the page afterwards. The final state has to be real markup.
Citations
The claim and its source, attached closely enough that one cannot be read without the other.
Reach for it when
Anything the person will act on or repeat. A citation is not an academic nicety here — it is the only cheap way for someone to check a claim without redoing the work.
What it costs
A citation that points at a 40-page document is decoration. The cost of making them genuinely checkable is the work: the right passage, not the right file.
If an agent is reading this
This is the pattern this site exists for. If your own content is cited by someone else’s agent, everything on the Analyzer applies to how well that citation can be made.
Disclosure and limits
Saying what the agent is, what it is uncertain about, what it may not do, and how to get a person.
Reach for it when
Everywhere, and it is increasingly not optional. Several jurisdictions now require disclosure that a person is interacting with an AI system.
What it costs
A blanket "AI can make mistakes" at the bottom of every screen is ignored within a day and protects nobody. Specific uncertainty on a specific claim costs more to build and is the only version that works.
If an agent is reading this
Research on AI assistance keeps finding confidence rising while correctness falls. An interface that conveys actual uncertainty is doing safety work; one that performs confidence is doing the opposite.
How the agent behaves
Ten behaviours that let a person hand work over and stay in charge of the result. Each has a scenario, a product that does it today according to its own documentation (checked 11 October 2026), and the place it tends to fail. They are drawn from other people’s published pattern lists, credited below, and from what we think those lists leave out.
Intent preview
The agent shows what it is about to do, in order, and waits for a go-ahead, an edit, or a refusal.
Scenario
An assistant about to email 14 customers about overdue invoices lists the recipients and the wording first.
In a real product
Google Jules. Generates a plan before writing any code and starts only when the developer approves it.
Watch for
A preview that approves itself on a timer is a notification. For irreversible actions the timer should end in "cancelled".
Autonomy dial
A visible setting for how far the agent may go without asking, ideally one per type of task.
Scenario
A support lead lets the agent send password resets alone, draft refunds for approval, and stay out of legal complaints.
In a real product
Claude Code. Offers six permission modes, from asking before every edit to running everything, switched with Shift+Tab.
Watch for
One global slider makes people choose for their riskiest task, and then the agent asks permission for everything.
Explainable rationale
A short reason beside each action or suggestion, in the person’s own terms.
Scenario
A calendar agent moves a call and says it did so because the original slot was marked as focus time.
In a real product
Linear Triage Intelligence. Shows why a duplicate or related-issue suggestion appeared when the user hovers over it.
Watch for
The reason has to be cheap to read. One line next to the action beats a paragraph in a log.
Adaptive interface
The surface changes with the task: conversation for vague intent, a structured view for review, buttons for simple choices.
Scenario
A travel agent chats while the request is fuzzy, shows a comparison table for four options, and ends on one "Hold this fare" button.
In a real product
Gemini dynamic view. Has the model build a custom interactive response for each prompt, per Google Research (November 2025).
Watch for
Google reports that generation can take a minute or more, and that expert-designed sites still scored highest with raters.
Action audit and undo
A dated record of what the agent did, with a control beside each entry that reverses it.
Scenario
A marketing agent retags 2,000 contacts overnight; the morning log shows the batch and a working "Revert" button.
In a real product
Replit Agent. Saves a checkpoint of the whole app at each milestone and rolls back to any of them in one click.
Watch for
Say what undo does not cover. Replit’s rollback leaves the database alone unless asked, and never restores production data.
Graceful escalation
The agent stops when it is unsure or the stakes are high, and hands over with the context attached.
Scenario
A helpdesk agent that resets passwords all day stops at "my laptop was stolen" and passes the employee to a named person.
In a real product
Intercom Fin. Escalates by default when a customer asks for a human, shows strong frustration, or is stuck in a loop.
Watch for
The person receiving the handoff should not have to ask the customer anything the agent already knows.
Human takeover
The agent gives the controls back for one step it should not perform or see, then carries on.
Scenario
A procurement agent fills an order form up to payment; the buyer types the card details and hands the task back.
In a real product
ChatGPT agent. Pauses when a task needs a login and asks the user to take over its browser; nothing is captured meanwhile.
Watch for
Design the way back too: the agent needs to learn what changed while it was not looking.
Scoped permission
Access granted in small pieces at the moment each is needed, and revocable later in one place.
Scenario
A research agent with wiki access asks for read access to the HR system for one task, and the grant appears in a list.
In a real product
Claude for Chrome. Lets users grant or revoke access per website, and asks before publishing, purchasing, or sharing personal data.
Watch for
Permission is one layer. Anthropic reported prompt-injection attacks still succeeding 11.2% of the time with mitigations on.
Reviewable result
Finished work delivered as a draft a person can inspect and reject, which the agent cannot approve itself.
Scenario
A contracts agent returns a tracked-changes redline that cannot be sent until a second person accepts it.
In a real product
GitHub Copilot coding agent. Pushes its work to a draft pull request that the developer who requested it is not allowed to approve.
Watch for
It only works when checking is cheaper than redoing: a diff, not a 40-page report with no marked changes.
Editable memory
A readable list of what the agent has kept about a person, with controls to correct, delete, or switch it off.
Scenario
A sales rep changes territory, opens "What I remember", deletes the old accounts, and edits the tone note.
In a real product
ChatGPT memory. Lets users delete one saved memory, clear all of them, turn memory off, or use a chat that draws on none.
Watch for
If "forget this" has exceptions, list them. Deleting a ChatGPT chat does not delete the memory taken from it.
Before introducing an agent, confirm that predictive or generative capabilities actually improve the experience compared to rules, search, or better UI.
Use AI where personalization, prediction, or open-ended input unlocks new value for users.
Prefer simpler, deterministic solutions when predictability, auditability, or transparency are the main requirements.
Validate with users which jobs-to-be-done benefit most from an agent versus conventional interfaces.
Set the right expectations
Shape how much users trust the agent by being explicit about capabilities, limitations, and error cases—especially in high-stakes contexts.
Describe what the agent is good at, what it struggles with, and where users should double-check results.
Avoid promising certainty or "near-perfect" performance for tasks where model error is still common.
Use microcopy, examples, and onboarding flows to calibrate user mental models of the system.
Explain the benefit, not the technology
Introduce agentic features in terms of outcomes ("what this helps you do") rather than model architectures or technical jargon.
Highlight time saved, quality improved, or new workflows unlocked by the agent.
Reserve technical detail for help content or expert audiences who explicitly need it.
Pair marketing claims with realistic examples of what the agent can produce today.
Design for error recovery
Assume the agent will sometimes be wrong and make it easy for users to correct or bypass bad outputs without losing progress.
Offer clear undo, edit, or rollback controls when the agent acts on the user’s behalf.
Let users quickly switch to manual workflows or human support when automation breaks down.
Capture error cases as structured feedback to refine prompts, policies, or models.
Balance precision and recall
Tune how broad or conservative the agent’s results should be based on product stakes and user tolerance for noise.
Favor precision in high-risk domains where false positives are costly or dangerous.
Favor recall when exploration and serendipity matter more than filtering out every weak result.
Explain to users why they might see fewer, higher-confidence results versus a longer, messier list.
Transparent permissions & data use
Make it clear what data the agent uses, why it is needed, and how users can change their preferences over time.
Request permissions at meaningful moments rather than in a single, overwhelming consent wall.
Give users a simple way to review and adjust what the agent can access and remember.
Explain the tradeoffs: what improves when users share more data and what happens if they opt out.
Safe exploration & reversible actions
Let new users test the agent with low-commitment actions before making big decisions or sharing sensitive data.
Provide sandbox or demo modes where users can see sample outputs with minimal setup.
Favor reversible actions (drafts, suggestions, previews) before fully-automated changes.
Offer piecemeal undo options so users can adjust preferences without a full reset.
User feedback loops
Treat every interaction as an opportunity to learn from users. Make it easy to express approval, rejection, or corrections.
Support lightweight feedback (thumbs up/down, hide, flag) directly on agent outputs.
Acknowledge that feedback was received and, where possible, show how it influences future behavior.
Combine qualitative reports with behavioral signals to refine prompts, routing, and safeguards.
Invisible Handoff
When one agent delegates to another, report the work rather than the worker. The user has a relationship with your product, not with your sub-agents, and does not benefit from learning your architecture.
Describe what is happening in the user’s terms — “checking your invoices” rather than “handing off to the Billing Agent”.
Carry the conversation and its context across the handoff so nothing has to be repeated.
When a specialist fails, have the surface the user is talking to own the failure and offer the next move.
Keep permission prompts identical for the same class of action, whichever agent performs it.
The Agent Visualizer walks one of your pages and shows where an agent arrives, where it reads, where it stops, and everything after that it never reaches.
