Design Principles for Agentic Experiences

Design delegation as a first-class experience, not a settings toggle

The moment a human grants authority to an agent is the most consequential design moment in the entire experience. It deserves the same attention as checkout in e-commerce or onboarding in SaaS. Map the delegation journey: what information does the human need, what choices must they make, what must they understand before authority is granted?

Graduate authority through demonstrated competence, not time elapsed

Introduce automation in phases - from recommendations to bounded actions to full autonomy - but tie each expansion to demonstrated agent performance, not arbitrary timelines. The human should feel that increased autonomy was earned, not assumed. The Autonomy Gradient framework governs this progression.

Make scope boundaries visible and enforceable, not implied

Every delegation must have explicit boundaries: what the agent may do, what it must not do, what requires specific conditions, and when the delegation expires. These boundaries must be structural (the agent cannot exceed them) not advisory (the agent should not exceed them). Ambiguous delegation is failed delegation.

Design revocation as instant and frictionless, not buried in settings

The human must be able to reduce or revoke agent authority at any moment, for any reason, without navigating through menus or waiting for confirmation. If revoking authority is harder than granting it, the delegation design has failed. Every grant of authority must have an equally accessible withdrawal.

Design trust as a measurable, trackable system state

Trust is not a feeling - it is a design variable with observable indicators. Track trust through behavioural signals: delegation scope changes, intervention frequency, override patterns, and re-engagement timing. The Trust Calibration framework provides the measurement architecture. When trust is quantified, it can be designed for.

Build trust through demonstrated reliability, not claimed capability

Never tell the human what the agent can do - show them. Confidence cues, accuracy histories, and performance records are more trustworthy than marketing language. The agent's track record is its trust credential. Design the system to accumulate and display this evidence naturally.

Design for trust recovery as a first-class experience, not an error state

Every agent will fail. The quality of the failure experience determines whether the relationship survives. Design the recovery protocol: acknowledge the failure transparently, explain what happened without deflecting, compensate for any harm, demonstrate that the failure mode has been addressed, and rebuild through supervised performance. Trust recovery is relationship repair.

Account for trust debt - the hidden cost of shortcuts and opacity

Every time the agent acts without adequate transparency, every time it exceeds expectations in ways the human did not authorise, every time it optimises for efficiency over legibility - it accumulates trust debt. Like technical debt, trust debt compounds. Design systems that pay down trust debt continuously rather than allowing it to accumulate until a catastrophic trust failure.

Design the absent state as the primary experience, not an edge case

Most agentic experiences will spend most of their time in the absent state - the agent acting autonomously while the human is elsewhere. This is not an edge case to handle; it is the core experience to design. The Absent-State Audit framework provides the methodology for evaluating how well your system performs when no one is watching.

Build autonomous failure containment, not just failure notification

When the agent fails during absence, it cannot wait for human intervention. Design autonomous failure response: detect the failure, stop the failing action, prevent cascade effects, contain the damage, preserve system state for investigation, and reduce autonomy level. The agent must be its own first responder. Human notification is the second step, not the first.

Design the return path - how the human re-engages after absence

When the human returns, they need to understand what happened while they were away. Design the re-engagement experience: summarise actions taken, highlight decisions made, surface any anomalies, present pending items requiring attention, and restore context. The return path is as important as the delegation path. The Orchestration & Visibility framework governs this design.

Implement continuous accountability that does not require human presence

Safety reviews, policy compliance, and ethical constraints must all function autonomously. Do not design systems that are only safe when someone is watching. Automated monitoring, anomaly self-reporting, and periodic summary generation ensure accountability persists through absence. The agent's audit trail is its accountability infrastructure.

Design for relationship memory, not just session state

The agent must remember not just what happened in this session but the full arc of the relationship: past delegations, trust levels over time, preference evolution, failure history, and recovery patterns. The Memory & Continuity framework provides the architecture. A relationship without memory is not a relationship - it is a series of disconnected transactions.

Evolve agent behaviour as the relationship matures

A new relationship and a mature relationship require fundamentally different agent behaviours. Early relationships need more explanation, more confirmation, more transparency. Mature relationships can operate with greater efficiency, less interruption, and higher autonomy. Design the agent's communication style, intervention frequency, and autonomy level to evolve with the relationship stage.

Track and respond to trust trajectory, not just trust level

A trust level of 7/10 that was 9/10 last month tells a different story than a trust level of 7/10 that was 5/10 last month. The direction of trust change matters as much as the absolute level. Design systems that detect trust trajectory - rising, stable, declining - and adapt behaviour accordingly. Declining trust should trigger proactive engagement, not wait for a crisis.

Design for relationship repair, not just error correction

When something goes wrong in a long-running relationship, the fix is not just correcting the error - it is repairing the relationship. This means acknowledging the history ('we know you trusted us with this for six months'), accepting responsibility proportional to the relationship depth, and rebuilding through demonstrated improvement over time. The Relational Arc governs this design.

Design for outcome specification, not step-by-step instruction

The human should specify what they want to achieve, not how the agent should achieve it. 'Keep my portfolio balanced within these risk parameters' is an outcome specification. 'Buy 50 shares of X when the price drops below Y' is a step-by-step instruction. AXD designs for the former - giving the agent the autonomy to determine the optimal path while the human retains authority over the destination.

Make constraints first-class citizens of the outcome specification

Outcomes without constraints are dangerous. Every outcome specification must include: what results are desired, what results are unacceptable, what methods are prohibited regardless of effectiveness, what conditions require human re-engagement, and what ethical boundaries must never be crossed. Constraints are not limitations on the agent - they are the human's expression of values within the delegation.

Design consent as continuous and contextual, not one-time and binary

Consent in AXD is not 'I agree to the terms of service.' It is an ongoing negotiation between the human's evolving preferences and the agent's expanding capabilities. Design consent to be revisitable (the human can change their mind), contextual (different situations may warrant different consent levels), and progressive (consent deepens as trust accumulates). The Consent Horizon governs this design.

Measure success by outcomes achieved, not interactions completed

The success metric for an agentic experience is not engagement, session duration, or click-through rate. It is: did the human get the outcome they specified, within the constraints they defined, at a trust cost they find acceptable? Design measurement systems that track outcome achievement, constraint compliance, and trust maintenance - not traditional interaction metrics that assume the user is present.