Trust as Material

For three decades, digital design has worked in a single material: attention. The entire discipline of UX was built on the assumption that the designer's job is to capture, direct, and sustain human attention through screen-based interfaces. Every pattern library, every A/B test, every engagement metric serves this fundamental material.

Agentic AI invalidates this assumption. When an autonomous agent acts on behalf of a human - negotiating a contract, managing a portfolio, purchasing goods - the human is absent. There is no screen to attend to, no interface to navigate, no attention to capture. The agent operates in a state of delegated authority, executing decisions in the world without moment-to-moment human oversight.

In this condition, attention is irrelevant. The only material that holds the relationship together is trust. Trust determines whether the human delegates in the first place. Trust determines how much authority the agent receives. Trust determines whether the human delegates again after a failure. Trust is not one consideration among many - it is the foundational material of the entire design discipline.

This is why AXD exists as a parallel discipline to UX, not a specialisation within it. UX works in attention. AXD works in trust. The materials are different, and therefore the methods, the metrics, and the design patterns must be different too.

If trust is a material, it has properties - just as steel has tensile strength and concrete has compressive resistance. Understanding these properties is the first task of the AXD designer.

Trust is asymmetric. It is slow to build and fast to destroy. A hundred successful transactions build a certain level of trust; a single catastrophic failure can collapse it entirely. This asymmetry means that trust architecture must be biased toward preservation - the cost of losing trust always exceeds the cost of building it.

Trust is contextual. A human may trust an agent to book a restaurant but not to negotiate a mortgage. Trust is not a global property of the agent; it is specific to the domain, the consequence level, and the history of the relationship within that domain. AXD designers must design trust architectures that are domain-aware and consequence-sensitive.

Trust is temporal. It accumulates over time through repeated interaction. The first delegation is qualitatively different from the hundredth. Trust has a history, a trajectory, and a momentum. Systems that treat every interaction as the first - resetting trust to zero - waste the most valuable asset in the relationship.

Trust is fragile under opacity. When the human cannot observe what the agent did, why it did it, and what happened as a result, trust erodes even when the agent performs well. Opacity is the enemy of trust. Observability - the agent's capacity to make its actions legible - is a structural requirement, not a nice-to-have.

Trust is recoverable. Unlike some materials, trust can be repaired after failure - but only through designed recovery mechanisms. Spontaneous trust recovery is rare. Designed trust recovery - through proactive failure disclosure, honest explanation, and demonstrated improvement - is the hallmark of mature trust architecture.

Trust architecture in AXD is structured across four layers, each addressing a different dimension of the human-agent relationship:

Layer 1: Predictability. The foundation. 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. Without predictability, no higher layer can form.

Layer 2: Agency. The human's sense of control. Can the human intervene, constrain, or revoke the agent's authority at any point? Agency is designed through interrupt patterns, constraint mechanisms, and revocation protocols. Trust deepens when the human knows they can always take back control - even if they rarely exercise that right.

Layer 3: Communication. The agent's capacity 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 - not of every technical detail, but of the agent's reasoning and outcomes.

Layer 4: Evolution. 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. Without evolution, the relationship stagnates.

A critical distinction in AXD: trust is not confidence. Confidence is a momentary psychological state - a snapshot of how the user feels about the agent right now. Trust is a structural property - the accumulated architecture of competence, consistency, and recovery that determines whether the user will delegate again tomorrow.

Traditional software design optimises for confidence: reassuring messages, progress indicators, success confirmations. These are surface-level signals that address the user's immediate emotional state. They are necessary but insufficient for agentic systems.

AXD optimises for trust: the deep structural relationship that persists across sessions, survives failures, and evolves over time. Trust is what allows a human to delegate authority to an agent and then walk away - knowing that the agent will act within its boundaries, report honestly on its outcomes, and recover gracefully from its failures.

The distinction matters because confidence can be manufactured through persuasion. Trust cannot. Trust must be earned through demonstrated competence, maintained through consistent behaviour, and recovered through honest failure management. There are no shortcuts.

To say that AXD designers "work in trust" is not a metaphor. It is a statement about the fundamental material of the discipline. Just as a structural engineer must understand the load-bearing properties of steel before designing a bridge, the AXD designer must understand the load-bearing properties of trust before designing an agentic system.

This means asking different questions than traditional UX. Not "will the user click?" but "will the user delegate?" Not "is the interface intuitive?" but "is the trust architecture sound?" Not "did the user complete the task?" but "will the user delegate again after a failure?"

It means measuring different things. Not engagement time, but delegation frequency. Not task completion rate, but trust calibration accuracy. Not user satisfaction scores, but trust recovery speed after failure.

And it means designing different artefacts. Not wireframes and prototypes, but trust architectures - structural blueprints that specify how trust is formed, maintained, calibrated, eroded, and recovered across the full lifecycle of the human-agent relationship.

This is the founding claim of AXD: that the design of human-agent relationships requires a new discipline built on trust as the primary material. Everything else - the frameworks, the vocabulary, the practice - follows from this single structural fact.