Framework · Apr 2026

Designing Agentic User Experiences (AUX)

Most companies today are adding AI features, experimenting with copilots, and testing chat interfaces. But they are not designing agentic systems intentionally. There is currently no standard way to design agent behavior, trust boundaries, human-agent collaboration, or multi-step execution systems. Teams are improvising.

The Design Gap

Today, UX tools produce screens, API tools produce endpoints, and docs produce vague specs. What's missing is a design layer for agent behavior.

The companies that win will design how humans and agents work together — not just what AI can do.

AX: The Foundation

AX (Agentic Experience) is designing relationships, not interactions. Systems that remember, adapt, act, and improve over time. The shift is from stateless interactions and predefined flows to stateful systems, dynamic planning, and agent-driven execution.

The new design unit is no longer a screen or flow — it's a Scenario + Outcome + Trust Contract.

The AX Design Stack

We work across 4 layers:

  1. Intent Layer: What the user wants
  2. Agent Layer: How the system interprets and plans
  3. Execution Layer: Actions and tools
  4. Trust Layer: Control, transparency, escalation

Six Design Primitives

AUX is designed using six primitives:

  • Actors — Who participates (humans and agents as first-class actors)
  • Actions — What happens (every step is owned by an actor with an autonomy level: autonomous, confirm, or blocked)
  • Tools — Capabilities (CRM, APIs, databases, MCP servers)
  • Context Blocks — What the agent knows (memory, data access, session state)
  • Trust Gates — "Should this be allowed?" (approval paths, escalation, confidence thresholds)
  • Connections — Logic (sequential, conditional, parallel)

AX Interaction Patterns

Pattern 1 — Intent Handshake

Before acting, the agent must show understanding, propose a plan, and allow steering. Not confirmation — alignment.

Pattern 2 — Transparency Modes

The agent can show reasoning, show sources, and show confidence. Transparency must be designed, not default.

Pattern 3 — Adaptive Interface

The UI changes based on context, user state, and task. The interface becomes a dynamic system.

Pattern 4 — Invisible UI

Sometimes the best UX is no UI at all: background execution, notifications, outcome delivery.

Trust as the Core Metric

Success is not speed or UI polish. It's how much autonomy users are willing to give. Trust is the core metric of AX.

Three Implementation Approaches

  1. Feature Layer: Add AI features, copilots, assistive UX. Low impact, fast.
  2. Workflow Agents: Automate tasks, add decision logic, introduce trust gates. Medium complexity.
  3. Agent-Native System: Outcome-driven, multi-agent, adaptive, deeply integrated. High leverage.

The Four-Step Process

  1. System Mapping: Org map, processes, tools, opportunities.
  2. Agent Identification: Where agents add value, prioritisation, impact mapping.
  3. AUX Design: Define actors, map flows, design trust.
  4. Spec to Build: Export system, handoff to engineering, iterate.

What Makes This Hard

Common failures include AI without system design, no trust modelling, no context architecture, and no visibility. The hard parts: defining autonomy, handling ambiguity, designing escalation, and managing memory.

The future is not users interacting with software. It's software working on behalf of users.