What Is Agentic User Experience (AUX)?
The AUX Start Pack — manifesto, patterns, heuristics, and the TrustKit to ship it.
In April 2026, Dharmesh Shah published The Rise of Agentic User Experience (AUX) and gave a name to something the whole industry had been feeling but hadn't said out loud: the agent is a user now, and wrapping your API in MCP isn't the same as designing for that user.
He's right. But naming the problem is the easy part. The harder question — the one every product team is going to face in the next 18 months — is what does agentic UX actually look like as a discipline? What are the patterns? The heuristics? The artifacts? How do you audit a product you've already shipped? How do you brief a designer or an engineer on something that didn't exist as a category twelve months ago?
This is the AUX Start Pack. It's what we've built at auxfirst to answer those questions in a way teams can actually use on Monday morning: a manifesto, six foundational patterns, eight principles, ten heuristics, a four-stage trust architecture, an open Figma canvas, and an open-source TrustKit on GitHub. Everything below is either CC BY 4.0 or MIT — forkable, citable, not vendor-locked.
If you ship AI products, you don't have to wait for the category to settle. The vocabulary already exists. Here it is.
1. Why "agentic UX" is not just UX with AI in it
Shah's argument is simple and correct: if you treat MCP as the finish line, you end up with an agent that has to make five API calls per ticket, chain them itself, retry on failure, burn tokens reasoning through a workflow your backend already knows how to do — every single time, for every single ticket. That's not an interface. That's hazing.
A real AUX layer exposes processTicketQueue, not get_ticket + get_customer_history + search_knowledgebase + create_response + update_ticket + escalate_ticket. The agent works at the level of intent. Your backend does the workflow. The agent gets back a clean structured report.
That's the technical layer. But there's a deeper shift underneath it, and this is where auxfirst's thesis extends Shah's.
For forty years, UX was the discipline of making humans tap screens. Fewer clicks, clearer labels, smoother flows. The whole field is built on a single assumption: the software is a tool, and the human is operating it.
The day software gained memory, initiative, and judgment, that assumption broke. A product that remembers you, anticipates you, pushes back on you, and sometimes acts without asking — that's not a tool. That's a collaborator. And you don't design collaborators with information architecture and click-through funnels. You design them with relationships.
Nielsen Norman Group came to a similar conclusion, framing agents as a new class of user that breaks human-first interfaces the moment it tries to navigate them. Standard Beagle's Agentic UX piece makes the same move from a product-leadership angle — UX shifting from screens to structured data, APIs, explainability, and human oversight. And Markswebb's What Is Agentic UX lays out design patterns for intent-first flows, legible reasoning, and autonomy boundaries.
Agentic User Experience (AUX) is the discipline of designing enduring, adaptive relationships between users and systems with memory, initiative, and judgment.
Classic UX designs for discrete tasks. AUX designs for relationships. Trust isn't a feature in this world. Trust is the product.
Three terms in that definition do a lot of work:
Shah's framing — agent-as-user — is the technical entry point. Relationship design is the strategic entry point. Both are true. Teams that only solve the first one ship efficient agents that nobody trusts. Teams that only think about the second one write beautiful manifestos and ship nothing. You need both. That's why the start pack has two halves: the conceptual layer (manifesto, principles, heuristics) and the executable layer (patterns, trust architecture, TrustKit schemas).
2. The AUX Evolution Curve — where is your product right now?
Before any framework, you need to know where you're starting from. We use a four-stage curve to locate a product on the AUX maturity ladder. Most teams shipping AI features today are at stage 1 or 2. The interesting moats start at stage 3.
Conversational
Natural language replaces rigid forms. The product can hold a real conversation. Still a tool — the user does all the steering.
Most AI features todayTask-Aware
The product can do things on the user's behalf. Watches interactions, adapts in real time. Still session-bound and mostly reactive.
Copilots in 2026Personally Intelligent
Remembers preferences, tone, goals, and recurring tasks across sessions. Nudges. Anticipates. Feels like a colleague, not a feature.
Where the moat beginsSocially Embedded
Understands your team, role, shared vocabulary, and political reality. Not just personalized — part of how your organization works.
Almost nobody is here yetThe reason the curve matters: the further right you move, the harder it gets to swap you out. A stage 1 chatbot is replaceable in an afternoon. A stage 4 system with six months of context on your team is functionally irreplaceable. That's the AUX moat — built from time, trust, and accumulated context. It cannot be cloned by a competitor with more capital.
3. The six foundational patterns
Principles are good for conviction. Patterns are what you actually ship. These six are the structural building blocks of agentic interaction — repeatable, layerable, remixable. Almost every agentic feature you'll ever design is some combination of these.
Intent Handshake
A short exchange that clarifies the user's goal before the system acts. The agent restates what it thinks you want, names its assumptions, and offers a chance to redirect before any cost is incurred. The single highest-leverage pattern in agentic design.
Confidence Cues
Make reasoning visible. Expose sources, surface uncertainty, show the logic — but tapered, not overwhelming. Agents that show their work feel self-aware. Agents that don't feel mysterious, and mysterious is one bad output away from untrustworthy.
Adaptive Canvas
The interface reshapes itself in response to the evolving task. The right tools surface when needed. Previews appear when relevant. A stable substrate that adapts at the edges while preserving spatial memory.
Escape Hatch
Every agentic system needs obvious ways to undo, revise, or override. The Escape Hatch is what gives users psychological safety to engage in the first place. When people know they can recover, they explore more, delegate more, and trust more.
Memory in Motion
Recall of contextual relevance across time — past decisions, preferred formats, recurring tasks, corrections. Must be transparent and editable. Building memory governance is where the real design work lives.
Generative Momentum
The agent initiates — drafts, outlines, candidate queries — and invites the user to shape them. The blank page disappears. Co-authorship replaces command-and-execute. Must be paired with Pattern 01 and 04 to stay safe.
The Agentic Design Patterns library catalogs related primitives — confidence visualization, progressive disclosure, mixed-initiative controls — worth borrowing when you're designing Pattern 02.
4. The eight design principles
If the patterns are the building blocks, the principles are the conviction layer. These eight beliefs are what we test every design decision against. They don't tell you what to build — they tell you when something you've built is wrong.
5. The ten heuristics
Patterns are what you build. Principles are what you believe. Heuristics are how you evaluate what you've built. These are the AUX answer to Nielsen Norman Group's classic usability heuristics — reimagined for agents. Traditional UX heuristics optimize for clarity of interface. AUX heuristics optimize for quality of relationship.
| ID | Heuristic | What to evaluate |
|---|---|---|
| H01 | Visibility of Agent Intent & Action | Does the agent make its intent legible before or during action? Intent playback, plan preview, "here's what I'm about to do…" |
| H02 | Progressive Transparency | Early: full reasoning, sources, confidence. Later: concise or silent. The trajectory is transparency → summary → confident → silent. |
| H03 | User Control Through Steering | Do users guide via intent and correction — approve, modify, redirect — not step-by-step control? UX was about control. AUX is about steering. |
| H04 | Trust Is Dynamic, Not Static | Does agent behavior evolve as trust develops? New users get cautious, gated behavior. Experienced users get faster, more autonomous behavior. |
| H05 | Clear Boundaries of Autonomy | At any moment, does the user know what the agent can do autonomously, what requires confirmation, and what is blocked? Ambiguity here is where trust collapses. |
| H06 | Graceful Handling of Uncertainty | When unsure, does the agent ask, escalate, or return a partial result — not hallucinate? Failure is a first-class design surface, not an exception path. |
| H07 | Appropriate Assertiveness | Does the agent challenge users when necessary? The spectrum: compliant → advisory → assertive → protective. Pushback is professional. |
| H08 | Context Efficiency & Awareness | Does the agent use context intelligently, not exhaustively? Routing, indexing, and summarization beat full scans. Context is a cost and a performance constraint. |
| H09 | Multi-Actor & Multi-Agent Clarity | Is it always obvious who is acting — the human, this agent, a sub-agent? Who delegated? Who owns the outcome? Multi-agent systems collapse fast without this. |
| H10 | Consistency of Behavior, Not Interface | The interface can adapt (generative UI). But the agent's decision logic, trust boundaries, and tone must stay stable. Consistent agent, adaptive UI — that's the goal. |
Run your existing AI feature through these ten heuristics this week. You'll find at least three trust gaps you didn't know you had. The Berkeley CLTC research on human-AI agent interaction confirms where failures cluster: loss of user control and transparency gaps — exactly H03, H05, and H06.
6. The four-stage Trust Architecture
Everything above — patterns, principles, heuristics — exists to build one thing: trust. And trust is not a single property. It's a staged progression.
Functional Trust
"Can it complete basic tasks reliably?"
The baseline. If your agent can't reliably do what it claims to do, nothing else matters. Most AI products in 2026 are still fighting to nail this stage.
Contextual Trust
"Does it understand nuance, preferences, and history?"
The agent completes your task, the way you'd want it done, accounting for what it knows about your situation. This is where memory starts paying off.
Judgment Trust
"Can it make good calls in ambiguous situations?"
The hardest stage. Most products will never get here. Requires not just memory and context but the kind of seasoned judgment that makes an agent genuinely indispensable.
Advocacy Trust
"Will it act in my best interest, even when incentives misalign?"
The endgame. The agent isn't just competent and contextual — it's on your side. This is where the relationship transcends product and becomes loyalty.
The stages are sequential. You don't get contextual trust before functional trust. You don't get judgment trust before contextual. And you absolutely don't get advocacy trust before judgment. Every team I talk to wants to skip to stage 3 or 4. Almost none of them have actually nailed stage 1.
The architecture is also the diagnostic. When something feels wrong about an agentic product, ask: which stage of trust just broke? That's almost always more useful than asking "is the model good enough?"
For agencies building AI workflows, this trust architecture is the foundation of how we approach the Trustworthy Agents for Ad & Media Agencies framework — the same four stages, applied to client-facing agentic systems.
7. The Trust Canvas — a one-page map for any agentic product
The patterns, principles, heuristics, and trust stages are the vocabulary. The Trust Canvas is what you use when you actually sit down with a team and design (or audit) an agentic product.
It's a single Figma artifact, free and published in the Figma Community, that walks a team through the trust topology of an agent: where the autonomy boundaries are, where the handoffs happen, which patterns apply at which moments, and what trust stage each feature is targeting. Think of it as Lean Canvas or Business Model Canvas, but for AUX.
Three ways to use it:
Before writing a line of code, map the agent's trust topology and decision points on the canvas. It surfaces autonomy and handoff questions early, when they're cheap.
Overlay the canvas onto a shipped feature. The gaps light up almost immediately. Missing escape hatch. No intent handshake on the most expensive workflow. Memory with no governance.
Get product, design, engineering, and a business sponsor in a room with the canvas and the conversation stops being abstract within ten minutes.
And it's free. No sign-up wall. No "request a demo." Open it, fork it, run the session.
8. TrustKit — the executable layer
Frameworks without schemas are think-pieces. We knew from day one that AUX would only matter as a discipline if the definitions were machine-readable, forkable, and citable — not just slides.
That's what TrustKit is. It's the open-source canonical layer of AUX, published at github.com/auxfirst/trustkit. Everything in this article — the 10 heuristics, the 4 trust stages, the trust gap taxonomy — exists in there as editable YAML schemas. Definitions are CC BY 4.0. Executable tooling is MIT. No vendor lock-in. No "request a demo" wall.
What's in the repo today:
The governing principle of the repo, which I keep coming back to:
One technical post with runnable code + benchmark numbers will out-earn ten soft think-pieces.
TrustKit is the proof layer. Every claim ships with a schema, a CLI, or a reproducible scenario. The heuristics aren't just an inspirational list — they're a YAML file you can run aux-audit against. The trust stages aren't a marketing diagram — they're a taxonomy with named failure modes.
If you're a CTO or VP Engineering, start with onboarding/for-ctos.md. If you're a business operator evaluating AI vendors, start with onboarding/forwardables/A1-10-questions-for-your-ai-vendor.md — the single asset I'd hand to any executive about to sign a six-figure AI contract.
9. The AUX Start Pack — what to actually do this week
If you've made it this far, you have the whole vocabulary. Now: what's the minimum useful action?
Spend one hour with the Trust Canvas and your most-shipped AI feature. Mark every autonomy boundary, every handoff, every recovery point. Then run it through the ten heuristics. Fix the worst gap this sprint.
Pick one workflow. Just one. Make it actually great for an agent end-to-end — Intent Handshake on the way in, Confidence Cues during execution, Escape Hatch on every action, Memory in Motion that survives the session. Then expand.
Clone TrustKit. Read for-engineering.md. Look at the agent-spec.schema.yaml. The 30 minutes it takes to map your existing agent against that schema will tell you more about your real surface area than a week of architecture meetings.
Forward A1-10-questions-for-your-ai-vendor.md to the next vendor on your shortlist. The answers will tell you whether they've thought about AUX or are still hoping MCP is the finish line.
10. Why this matters now
Shah closes his piece with a line I think about a lot: "One day, your product may have more agent users than human users."
That day is closer than most teams are planning for. OpenAI's ChatGPT Agent launch and the more recent AgentKit announcement — with embedded agentic UIs and workflow-building primitives — are bets that agents become the primary surface, not a feature. TechRadar's The Agentic Internet Is Coming makes the strategic version of the same argument, framing machine-readable systems, structured interfaces, and governance as the new table stakes.
The window to design for this deliberately — rather than retrofit it under pressure — is open right now and will not stay open for long. The teams that name the discipline, ship the artifacts, and build the trust architecture in 2026 are going to look, in 2028, like the teams that nailed mobile-first in 2010. Not because they were smarter. Because they showed up before the category was settled.
That's what auxfirst exists to do. The manifesto, the six patterns, the eight principles, the ten heuristics, the four-stage trust architecture, the Trust Canvas, TrustKit — none of it is proprietary. It's the start pack. Take it. Fork it. Ship better agents.
We don't design interfaces. We design relationships between users and agents.
The agent is a user. The relationship is the product. Trust is the moat.
Welcome to AUX.