The 10 AUX Heuristics for Agentic Experience

Classic UX only had to show system status — a spinner, a progress bar. An agent has something a tool never had: a reason. When an agent acts without exposing that reason, every action becomes a small mystery, and mysteries compound into distrust. Intent visibility is the cheapest trust you can buy: a one-line plan preview costs nothing and prevents the most corrosive question a user can ask — "wait, why did it do that?"

Full transparency forever is as much a design failure as no transparency at all. An agent that shows its complete reasoning on the 400th routine task is a colleague who narrates every keystroke — the explanations become noise, and users stop reading exactly the ones that matter. The AUX transparency model tapers deliberately: Transparency → Summary → Confident → Silent, with verbosity snapping back up whenever stakes rise or the agent enters unfamiliar territory.

If a user has to confirm every micro-step, the agent has failed at being an agent: the human is still doing the work, just through a slower interface. But removing all control fails in the other direction. The AUX answer is steering — the user sets direction, reviews at meaningful checkpoints, and corrects course, the way you'd manage a competent colleague rather than operate a machine. The design question is never "how do we let users control everything?" but "where are the few points of control that actually matter?"

A static trust posture is wrong twice. Day one, an agent that acts with full autonomy terrifies users who haven't seen it perform. Day two hundred, an agent still asking permission for everything insults a user who has watched it succeed a thousand times. Trust in AUX is a designed timeline: autonomy expands with demonstrated competence, contracts after failures, and is always inspectable. This is the core of the auxfirst Trust Architecture — Functional → Contextual → Judgment → Advocacy — applied to day-to-day behavior.

The single most common source of agent anxiety is not what the agent did — it's not knowing what it might do. Every consequential capability should sit in one of three visible states: Autonomous (acts freely), Confirmed (asks first), Blocked (cannot act). When users can read this map, delegation stops feeling like a leap of faith and starts feeling like a contract. auxfirst formalizes the grading of actions by consequence in the Action Heat Ladder: hotter actions demand tighter control.

In classic UX, an error was a dead end to recover from. In agentic systems, the most dangerous failure has no error message at all: the agent is uncertain, guesses, and presents the guess with full confidence. Failure design must be first-class — confidence thresholds that trigger different behaviors, escalation paths that are designed rather than improvised, and partial output as a legitimate deliverable. "I completed 8 of 10, and here's why I stopped on the other 2" is a far better outcome than 10 of 10 with two silent fabrications.

This heuristic has no ancestor in Nielsen's list, because tools don't disagree. Agents must — sometimes. An agent that executes every instruction, including the ones that contradict last week's instruction or this quarter's goal, isn't respectful; it's negligent. Assertiveness runs on a spectrum — Compliant → Advisory → Assertive → Protective — and the right level depends on the stakes and the relationship. Pushback is professional. The failure modes on both ends are real: the sycophant that lets you send the angry email, and the nanny that argues about font sizes.

Context is the agent's food and its poison. Too little and it acts ignorant of things it was told last week; too much and it gets slow, expensive, and distracted by irrelevant history. Nielsen's minimalist-design heuristic applied to pixels; this one applies the same discipline to memory and retrieval. Context is a cost and performance constraint, and its consumption is also a privacy question: an agent that reads everything it can reach, because it can, violates the spirit of the delegation even when it technically has access.

The moment a second agent enters the system, a new class of confusion appears that single-agent design never had to solve: attribution. Who wrote this? Who told it to? When an orchestrator delegates to a sub-agent that calls a third-party agent, accountability can vanish into the chain — and "the agents did it" is not an acceptable answer in any organization that ships real work to real clients. Every action needs a legible chain: acting agent → delegating authority → accountable human.

Classic consistency meant the button stays where you left it. Generative UI deliberately breaks that promise — the surface reshapes itself around the task, and that's a feature. What must not reshape is the character underneath: how the agent decides, where its boundaries sit, how it speaks. Users can adapt to a moving interface; they cannot build a relationship with a moving personality. Behavioral consistency is what makes an agent predictable enough to trust even while its surface is fluid — and it's what model upgrades most often silently destroy.