The Practice
12 Frameworks for the
Agentic Experience Lifecycle
AXD is not just a theory - it is a practice. The twelve frameworks below constitute the complete definitive suite for designing human agent interaction across every major phase of the agentic experience lifecycle. From pre-delegation intent to constitutional ethics, they cover the full arc of how humans and autonomous agents build, maintain, and govern their working relationships through trust architecture and delegation design.
Each framework has been developed from the founding principles and stress-tested against real-world agentic design challenges in financial services, healthcare, enterprise technology, and government.
The twelve frameworks map to distinct phases of the agentic experience lifecycle. Each addresses a specific design challenge that emerges as humans and agents move through delegation, operation, and governance.
| # | Framework |
|---|---|
| 01 | Intent Architecture Framework |
| 02 | Delegation Design Framework |
| 03 | Autonomy Gradient Design System |
| 04 | Trust Calibration Model |
| 05 | Interrupt Pattern Library |
| 06 | Multi-Agent Orchestration Visibility Model |
| 07 | Agent Memory & Context Continuity Framework |
| 08 | Absent-State Audit |
| 09 | Explainability & Observability Design Standard |
| 10 | Failure Architecture Blueprint |
| 11 | Onboarding & Capability Discovery Framework |
| 12 | Ethical Constraint & Value Alignment Architecture |
Intent Architecture Framework
Pre-delegation · Mission quality
Commerce: Purchase goal specification
The framework that sits before delegation. Agentic AI replaces the traditional input-response loop with delegation - users now express intentions rather than give instructions. But autonomy without context invites misinterpretation. This framework covers the design of the pre-execution contract between human and agent: how users articulate goals versus mere instructions, how systems help users specify success criteria, constraints, exceptions, and what must never happen.
Framework covers:
- -Goal elicitation design
- -Ambiguity negotiation interfaces
- -Constraint encoding (scope, budget, reversibility)
- -Success criteria specification
- -Plan Preview as a standard pre-execution artefact
Delegation Design Framework
Delegation · Authority architecture
Commerce: Spending authority and scope
A structured approach to designing how humans grant, modify, and revoke authority in agentic systems. Covers scope definition, consent architecture, and revocation mechanisms. The grammar of giving authority - from standing orders to one-time mandates.
Framework covers:
- -Scope definition and boundaries
- -Consent architecture
- -Revocation mechanisms
- -Progressive delegation pathways
- -Standing order precedent
Autonomy Gradient Design System
Active operation · Autonomy calibration
Commerce: Transaction approval levels
Trust is not a binary switch - it is a spectrum. This dynamic, user-adjustable system answers how much autonomous decision-making the agent should exercise, across which task types, and who controls that dial. It operates across three axes: consequence (cost of mistake), confidence (agent certainty), and familiarity (how well the agent knows this user's preferences).
Framework covers:
- -Autonomy level taxonomy (suggest / confirm / notify / act silently)
- -Risk-consequence mapping
- -Real-time recalibration triggers
- -User-facing autonomy controls
- -Progressive autonomy expansion pathways
Trust Calibration Model
Active operation · Trust dynamics
Commerce: Provider reliability scoring
A model for understanding and designing the ongoing negotiation between human confidence and agent reliability. Includes trust formation, maintenance, erosion, and recovery pathways. The architecture of earned confidence.
Framework covers:
- -Trust formation signals
- -Maintenance patterns
- -Erosion detection
- -Recovery pathways
- -Calibration bias mitigation
Interrupt Pattern Library
Active operation · Oversight triggers
Commerce: Exception escalation triggers
A catalogue of interrupt patterns for agentic systems - when to surface decisions to humans, how to present them, and how to calibrate frequency against consequence. The art of knowing when to speak and when to stay silent.
Framework covers:
- -Interrupt taxonomy by consequence
- -Presentation modalities
- -Frequency calibration
- -Context-preserving interrupts
- -Batch vs. real-time patterns
Multi-Agent Orchestration Visibility Model
Active operation · Ecosystem legibility
Commerce: Supply chain coordination
The architectural reality of enterprise agentic deployment: multiple agents collaborate, hand off tasks, and coordinate toward shared goals. This framework addresses the human experience of agent ecosystems - making the invisible choreography of multi-agent systems legible without overwhelming the user.
Framework covers:
- -Agent identity and role transparency
- -Task distribution visualisation
- -Context-preserving handoff protocols
- -Responsibility attribution
- -Mission control interface patterns
Agent Memory & Context Continuity Framework
Cross-session · Longitudinal intelligence
Commerce: Purchase history and preferences
The design of what the agent knows about you over time - how that knowledge is encoded, persists across sessions and channels, how users can inspect and correct it, and how it is governed under data protection regulation. The personalisation and continuity layer.
Framework covers:
- -Memory taxonomy (ephemeral, session, persistent, cross-channel)
- -Memory inspection and editing interfaces
- -Consent architecture for memory formation
- -GDPR-aligned data minimisation
- -Cross-session context continuity
- -Memory reset and erasure pathways
Absent-State Audit
Post-execution · Quality evaluation
Commerce: Transaction review and reconciliation
A methodology for evaluating the quality of agentic experiences that unfold without human presence. Assesses integrity, outcome alignment, and return-state design. The discipline of judging what happened while you were away.
Framework covers:
- -Integrity assessment
- -Outcome alignment scoring
- -Return-state design
- -Absent-state quality metrics
- -Audit trail architecture
Explainability & Observability Design Standard
Continuous · Decision legibility
Commerce: Decision rationale for regulators
Making agent reasoning, decisions, and actions legible to humans in normal operation - not just at failure. The 'why did you do that?' layer. In regulated industries, this is not optional. Users must understand not just what the system did, but why it did it.
Framework covers:
- -Real-time decision rationale design
- -Action log architecture
- -Confidence communication standards
- -Source attribution patterns
- -Retrospective audit trail design
- -Regulatory compliance interface
Failure Architecture Blueprint
Recovery · Graceful degradation
Commerce: Transaction reversal and dispute
A design template for how agentic systems fail gracefully - including detection, communication, containment, recovery, and trust restoration. The kintsugi principle: failures repaired visibly become sources of deeper trust.
Framework covers:
- -Failure detection patterns
- -Communication protocols
- -Containment architecture
- -Recovery pathways
- -Trust restoration design
Onboarding & Capability Discovery Framework
Entry · Mental model formation
Commerce: Agent capability calibration
Traditional product onboarding teaches users how to navigate. Agentic onboarding must teach something fundamentally different: how to delegate. Users must form accurate mental models of agent capability, understand what kinds of goals the agent can pursue, and calibrate expectations before experiencing disappointment or misplaced trust.
Framework covers:
- -Capability disclosure design
- -Progressive delegation introduction
- -Expectation-setting contracts
- -First-delegation experience design
- -Competence signal design
- -Mental model validation tests
Ethical Constraint & Value Alignment Architecture
Constitutional · Moral character
Commerce: Fair trading and value alignment
The design of what the system should never do even when functioning perfectly - the encoding of organisational values, regulatory obligations, and ethical commitments into agentic behaviour as first-class design artefacts. Unlike failure architecture, which is reactive, this framework is constitutive. It defines the moral character of the agent system from the ground up.
Framework covers:
- -Value taxonomy and translation
- -Regulatory obligation mapping
- -Harm boundary design
- -Ethical constraint transparency
- -Regulatory audit architecture
What AXD Requires in Practice
AXD requires fluency in domains designers have not traditionally needed to master. These are the core competencies of the emerging discipline - spanning intent design, trust psychology, orchestration, memory governance, and ethical constraint architecture.
Intent Design
Designing goal elicitation, ambiguity negotiation, and pre-execution contracts between humans and agents
Consent Architecture
Designing graduated, contextual, and revocable permission systems for delegation and memory
Related essay →Trust Psychology
Understanding risk perception, calibration bias, autonomy gradients, and trust recovery dynamics
Related essay →Agent Observability
Making autonomous decisions legible without overwhelming the human - explainability as design
Related essay →Orchestration Design
Designing human experiences of multi-agent ecosystems, handoffs, and responsibility attribution
Memory & Continuity
Designing longitudinal agent knowledge, inspection interfaces, and GDPR-aligned memory governance
Ethical Design
Encoding organisational values, regulatory obligations, and harm boundaries into agent behaviour
Related essay →Failure & Recovery
Designing systems that fail gracefully, communicate honestly, and recover trust systematically
Related essay →Outcome Specification
Defining results, constraints, and re-engagement conditions instead of step-by-step interfaces
Related essay →AXD draws from the organisations defining the infrastructure of agentic commerce. These are the reference points that inform the discipline's standards.
Universal Commerce Protocol (UCP), Agent-to-Agent Protocol (A2A), and Agent Platform Protocol (AP2). Defining the interoperability layer for agentic commerce at planetary scale.
Shopify
Agentic commerce infrastructure for merchants. Sidekick AI assistant, Shop app agent integration, and autonomous storefront management redefining what it means to serve the machine customer.
Stripe
The Five Levels of Agentic Commerce, x402 payment protocol, and agent-native checkout. Building the financial rails that autonomous agents will transact upon.
OpenAI
Agent Communication Protocol (ACP), ChatGPT Plugins, and the Operator agent. Establishing the foundational capabilities that make agentic commerce possible.
Anthropic
Model Context Protocol (MCP) - the open standard for connecting AI agents to tools, data sources, and enterprise systems. Defining how agents discover and interact with the world beyond their training data.
IBM
Enterprise agentic AI with watsonx Orchestrate, multi-agent orchestration, and autonomous business process automation. The enterprise reference for trust-governed agent deployment at scale.
McKinsey Global Institute
The gold standard for structured authority on agentic AI's economic impact. The template for commissioned research on how autonomous agents will reshape industries.
Three protocols form the emerging communication infrastructure of the agentic age. They are complementary layers - each solving a different coordination problem in the agentic stack.
MCP Answers
"What tools can this agent use?"
A2A Answers
"Which agent should handle this task?"
ACP Answers
"What content did this agent produce?"
These protocols are complementary, not competing. In a typical agentic commerce workflow, all three are active simultaneously: a shopping agent uses MCP to access a product database, A2A to delegate price comparison to a specialist agent, and ACP to receive a rich comparison report with images and structured data. All three have been donated to the Linux Foundation, signalling a shared commitment to open governance. Read the full essay →
Coming in Phase 2
The AXD Academy will offer structured learning paths for designers, product leaders, and organisations transitioning to agentic design. Courses, certifications, and cohort-based programmes - built to the same standard of rigour as the rest of the Institute.
About the Practice
Key questions about the 12 AXD frameworks, their application to agentic commerce, trust architecture, delegation design, and how they differ from traditional UX methods.