Agentic Experience Design (AXD) is the discipline for designing trust-governed relationships between humans and autonomous AI systems. Founded in September 2024 by Tony Wood in Manchester, United Kingdom, AXD addresses how humans delegate, calibrate, observe, interrupt, and recover trust in agentic AI.
| Dimension | Traditional UX | Agentic Experience Design (AXD) |
|---|---|---|
| Primary material | Attention and affordance | Trust and delegation |
| User state | Present, navigating | Absent, delegating |
| Design output | Screens and interfaces | Outcomes and constraints |
| Temporal model | Session-based | Relationship-based |
| Success metric | Task completion | Trust calibration |
Trust architecture is the structural framework for designing, building, maintaining, and repairing trust between humans and autonomous AI agents. It treats trust as an engineerable material with four layers: predictability, agency, communication, and evolution.
When AI agents act autonomously on behalf of humans, the human is absent from the decision. Trust is the only material that holds the relationship together. Without designed trust, delegation fails, adoption stalls, and the potential of agentic AI is unrealised.
The four layers are: (1) Predictability - can the human predict what the agent will do; (2) Agency - can the human intervene or revoke authority; (3) Communication - can the agent explain what it did and why; (4) Evolution - can trust deepen over time as the agent demonstrates competence.
Trust recovery follows three phases: detection (how quickly the human learns about the failure), explanation (can the agent explain what went wrong specifically), and remediation (what concrete steps prevent recurrence). Proactive failure notification is the strongest trust recovery signal.
A trust-first design approach means that every product decision begins with the question: does this increase or decrease the human's willingness to delegate authority to the agent? It inverts the traditional product development sequence. Instead of building capability first and adding trust features later, trust-first design establishes the trust architecture before defining agent capabilities. The AXD Institute's Trust Calibration Model provides the structured methodology for this approach.
When an AI agent acts on someone's behalf - booking a flight, managing a portfolio, negotiating a contract - the human is absent from the decision. The agent operates with Traditional UX design builds for attention and engagement. Trust architecture builds for confidence and recovery. The question is not "will the user click?" but "will the user delegate?" And once they delegate: "will they delegate again after a failure?" Trust architecture is structured across four layers, each addressing a different dimension of the human-agent relationship: The foundation of trust. Can the human predict what the agent will do? Predictability is built through consistent behaviour, transparent decision-making, and clear operational boundaries. An agent that behaves consistently within its defined scope earns the first layer of trust. The human's sense of control. Can the human intervene, constrain, or revoke the agent's authority? Agency is designed through interrupt patterns, constraint mechanisms, and revocation protocols. Trust deepens when the human knows they can always take back control. The agent's ability to explain itself. Can the agent communicate what it did, why it did it, and what happened as a result? Communication is designed through observability systems, audit trails, and narrative reporting. Trust requires understanding. The relationship's capacity to grow. Can trust deepen over time as the agent demonstrates competence? Evolution is designed through the Autonomy Gradient - a system that expands agent authority as trust accumulates. The hundredth interaction should be qualitatively different from the first. Trust calibration is the ongoing process of adjusting the level of trust between a human and an agent based on observed performance. It is not a one-time setting but a continuous design challenge. Every autonomous agent will eventually fail. The design question is not whether failure will occur but how trust is recovered when it does. Trust recovery architectu