Framework 02 of 12 · Delegation Phase · Authority architecture
Delegation Design Framework
The grammar of giving authority to autonomous agents
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.
Delegation Design Framework: Core Principles
Authority Is Designed, Not Assumed
In agentic systems, the agent has no inherent authority. Every capability it exercises must be explicitly granted through a designed delegation act. This principle rejects the pattern of broad, implicit permissions that characterise many AI deployments. Instead, Delegation Design requires that each authority - to spend, to commit, to communicate on behalf of the user - is individually specified, bounded, and revocable. The delegation is the contract.
Scope Must Be Explicit and Bounded
Every delegation must define its scope - the boundaries within which the agent may act. Scope includes what the agent may do, what it must not do, what resources it may access, and what commitments it may make. Unbounded delegation is not delegation; it is abdication. The framework provides patterns for expressing scope in machine-readable formats that the agent references throughout execution.
Consent Is Ongoing, Not One-Time
Delegation is not a single consent event. It is an ongoing relationship that the human can modify, narrow, expand, or revoke at any point. The framework designs for consent as a continuous state rather than a checkbox. This includes patterns for time-limited delegations, conditional authorities, and automatic scope reduction when trust signals degrade.
Revocation Must Be Immediate and Complete
When a human revokes delegation, the system must stop. Not after the current task completes. Not after a graceful wind-down period. Immediately. Revocation is the ultimate expression of human authority over the agent, and any delay or partial compliance undermines the trust architecture that delegation depends on. The framework defines revocation patterns that are technically immediate and experientially clear.
Progressive Delegation Builds Trust
Users should not be asked to grant maximum authority on first interaction. Progressive delegation starts with narrow, low-consequence authorities and expands as the agent demonstrates competence and the human builds confidence. This mirrors how trust develops in human relationships - through demonstrated reliability over time, not through upfront promises.
Standing Orders Require Special Governance
A standing delegation - authority that persists across sessions and applies to recurring situations - carries different risk than a one-time mandate. Standing orders accumulate authority over time and can drift from the user's current preferences. The framework requires periodic review, automatic expiry, and explicit renewal for standing delegations.
Delegation is not a permission slip. It is a contract between a human who wants something done and an agent that will do it. The quality of that contract determines whether the outcome is what the human intended or merely what the agent interpreted.
Delegation Design Framework: Implementation Patterns
Scope Definition Patterns
Structured templates for expressing what the agent may and may not do within a delegation. Includes domain-specific scope vocabularies for financial services, healthcare, and commerce that translate human-readable boundaries into machine-enforceable constraints.
When to use: When defining the boundaries of any new delegation, especially in regulated domains.
Consent Architecture
A multi-layered consent system that distinguishes between initial consent, ongoing consent, and consent modification. Includes patterns for informed consent (the user understands what they are granting), graduated consent (authority increases with demonstrated competence), and contextual consent (different authorities for different situations).
When to use: When designing the delegation flow for any agentic system that acts with real-world consequences.
Revocation Mechanisms
Technical and experiential patterns for stopping agent action immediately. Includes emergency stop patterns, graceful pause patterns, and scope reduction patterns. Each mechanism is designed to be accessible from any state the user might be in - including absent states where the user is not actively monitoring.
When to use: As a required safety mechanism in every delegation, regardless of consequence level.
Progressive Delegation Pathways
Staged authority expansion patterns that start with suggestion-only mode and progress through confirmation-required, notification-only, and fully autonomous operation. Each stage has clear entry criteria, exit criteria, and rollback triggers.
When to use: During onboarding and early relationship phases between human and agent.
Standing Order Governance
Lifecycle management patterns for persistent delegations including automatic expiry, periodic review prompts, drift detection, and renewal workflows. Standing orders include metadata about when they were created, what prompted them, and how often they have been exercised.
When to use: For any delegation that persists beyond a single session or applies to recurring situations.
Delegation Design Framework: Commerce Applications
Spending Authority Design
In agentic commerce, the machine customer needs explicit spending authority. Delegation Design defines how consumers set budget ceilings, per-transaction limits, category restrictions, and vendor preferences. A consumer might delegate 'buy my weekly groceries' with a £100 ceiling, approved retailers only, and organic preference where price difference is less than 20%. Each parameter is a delegation boundary the agent must respect.
Subscription Management Authority
Agents managing subscriptions on behalf of users need carefully scoped authority - permission to cancel, downgrade, negotiate, or switch providers within defined parameters. The delegation must specify which subscriptions the agent may touch, what actions it may take, and what cost thresholds require human approval before proceeding.
Negotiation Mandates
When agents negotiate on behalf of humans in agentic commerce - whether for insurance quotes, service contracts, or bulk purchases - the delegation must define negotiation boundaries: acceptable price ranges, non-negotiable terms, walk-away conditions, and commitment authority. The agent negotiates within the mandate; anything outside requires escalation.
Return and Dispute Authority
Post-purchase delegation for returns, exchanges, and dispute resolution. The agent needs authority to initiate returns, accept replacement offers, or escalate to human review. Each action type has its own delegation scope - the agent might be authorised to accept a full refund but not a store credit, or to negotiate a partial refund above a minimum threshold.
The most dangerous delegation is the one that feels complete but is not. When a human says 'handle my finances,' they mean something specific. Delegation Design ensures that specificity is captured, encoded, and enforced.
Delegation Design Framework: Guidance for Teams
Start With
- -Map every authority your agent will need to exercise
- -Define scope templates for your top 5 delegation types
- -Build a revocation mechanism that works from any user state
- -Create progressive delegation pathways for new users
Build Toward
- -Adaptive scope that learns from user modification patterns
- -Cross-agent delegation chains for multi-agent systems
- -Delegation inheritance for organisational hierarchies
- -Automated scope drift detection and correction
Measure By
- -Scope violation rate - how often does the agent exceed its authority?
- -Revocation response time - how quickly does the system stop when asked?
- -Progressive delegation velocity - how quickly do users expand agent authority?
- -Standing order review compliance - are persistent delegations reviewed on schedule?
Delegation Design Framework: Lifecycle Connections
Framework 01
Intent Architecture Framework
Intent Architecture defines what the human wants; Delegation Design defines the authority granted to pursue it. Intent precedes delegation.
Explore frameworkFramework 03
Autonomy Gradient Design System
Delegation sets the boundaries; Autonomy Gradient determines how much freedom the agent exercises within those boundaries.
Explore frameworkFramework 10
Failure Architecture Blueprint
When delegation boundaries are breached, Failure Architecture governs how the system detects, communicates, and recovers from the violation.
Explore frameworkDelegation Design Framework: What Comes Next
Delegation Design defines the boundaries. The next framework - Autonomy Gradient - determines how much freedom the agent exercises within those boundaries, calibrated to consequence, confidence, and familiarity.
Delegation Design Framework: The Framework Ecosystem
Navigate the complete lifecycle of Agentic Experience Design. Each framework addresses a distinct phase of the human-agent relationship.