Bounded-Agent Pattern
A class 3 agent lets a model choose the next step, but only inside a registered, validated and enforced envelope of Mandate, Means, Memory and Monitoring.
- Version
- 0.2.0
- Owner
- DEIXEI
- Last reviewed
- Reading time
- 31 min
For Cto · Ai Architect · Platform Engineer · Security Engineer · Risk And Assurance · Agent Wrangler
Sources and details
- Section
- Patterns
- Source works
- Book 1 · Book 2 · Book 3 · Research Series · Book 09 · Whitepaper
- Source chapters
- 1, 2, 3, 9, 12, 13, 14, 20, 22, 23, 27
- Source appendices
- 02:C, 04:D
- Refresh trigger
- vendor release
Agency class: 3. The model chooses the next step inside one agent’s mandate. Every production agent runs inside a bounded-agency envelope with four parts — Mandate, Means, Memory, Monitoring — and that envelope is a registered, machine-readable record the platform enforces, not a document someone wrote once.

Agency class is a design-time property; operational authority is earned separately. Source: The AI Delivery Factory, Chapter 22, Figure 22.2.
This page is the reference for the envelope itself: what to declare, which fields are mandatory, how each field is validated and enforced, and how envelopes fail. How an agent is registered, signed off, zoned, reviewed, suspended and retired is on Operate the Agent Lifecycle.
Why an agent needs an envelope at all
An agent is a third class of actor beside people and conventional software (Book 1 Ch 1 §4.1). Book 1 separates the classes on five properties:
| Property | Model | Application | Automation | AI agent |
|---|---|---|---|---|
| Decides? | No | Limited | No / limited | Yes |
| Acts? | No | Yes | Yes | Yes |
| Has identity? | No | Yes | Yes | Yes |
| Uses tools? | No | Build-time | Build-time | Runtime |
| Needs an envelope? | No | Partly | Partly | Yes |
The two rows that matter are the last two. An application’s tools are wired in when it is built, so a least-privilege identity is most of the control it needs. An agent decides at run time which of its available means to use, so identity alone cannot express what it is allowed to do. The envelope supplies the missing parts: a declared purpose (Mandate), a technical surface (Means), a state boundary (Memory) and an observation and stop path (Monitoring).

One agent inside four boundaries at once: what it may do, what it can use, what it can keep and how it is observed. Source: Building Organizations for the Age of AI (Book 1).
The same four-part idea appears under other names. The Whitepaper (Part III §2) calls them Authority, Tools, State and Oversight; they map one-to-one onto Mandate, Means, Memory and Monitoring. This site uses the Book 1 names.
Decide whether a bounded agent is the right shape
Factory rule: least agency. Use the lowest agency class that meets the need (Research Paper 2, §2.2). If a workflow can do the job, start there. Escalate to class 3 only with evidence that the workflow is insufficient, and record the rejected lower classes in an ADR (see Choose the Shape of an AI Product).
Use a bounded agent when the next step depends on observations that cannot be enumerated in advance, and the agent still has one coherent responsibility, one owner and a tool set you can bound. Evaluate trajectories — the sequence of decisions and tool calls — and not only final answers.
The four intake questions
Book 3 (Ch 1, Ch 3 §2.4, Ch 14 §4.1) adopts four intake questions from Anthropic’s CISO guidance (published July 2026, per Book 3) and uses them to set the risk tier before any envelope is written. Ask them for every proposed agent. Book 3 Ch 14 §4.1 states only the broad mapping — question 1 sets the data-class boundary, question 2 the action-class boundary, question 3 the tier, question 4 whether the tier’s evidence is achievable; the field-level column below is this page’s elaboration.
| # | Question | What the answer sets in the envelope (this page’s mapping) |
|---|---|---|
| 1 | What untrusted content will the agent ingest? | Memory read sources and Means data classes; prompt-injection screening requirement |
| 2 | What actions can it take, and on whose behalf? | Mandate autonomy_ceiling; Means tool verbs and identity (agent identity or on-behalf-of) |
| 3 | What is the blast radius if it is misaligned or hijacked? | The risk tier, and therefore approvers, review cadence and suspension thresholds |
| 4 | What observability do we have? | Monitoring fields; if the honest answer is “not much”, the classification is not yet deployable |
The governing principle is to grant the narrowest capability that still completes the task, and to draw the boundary around access and actions rather than around the model’s instructions. Book 3 treats this as the provider’s restatement of the Mandate and Means sides of bounded agency. [FACT-CHECK: confirm the four questions and the least-agency wording against the current Anthropic publication before quoting it as vendor guidance.] The tier definitions themselves are on Risk Tiers.
The rule: no envelope, no production
Book 3 Appendix D §1 and §5.2 turn the envelope into a deployment precondition enforced at three independent points. Build all three; any one alone can be bypassed.
| Enforcement point | Rule | Failure behaviour | Evidence |
|---|---|---|---|
| Agent runtime (SDK process, Claude Code session, API-agent service) | Fetches the envelope by envelope_id at instantiation and refuses to start if the ID is missing or any required field is absent | Fail closed; no agent process | Instantiation refusal logged by the hook bundle |
| Model gateway | Refuses to forward a model call that does not carry an envelope ID in its headers; enforces Means (models, budgets, data classes) on every call | Request rejected at the wire | Gateway deny record with envelope ID and reason |
| SOC detection | A detection rule fires on any successful model call that carries no envelope reference | Alert to SOC; investigate as an unregistered agent | SIEM alert and case |
The failure behaviour and evidence columns combine Book 3 App D §1, §5.2 and Ch 9 §9; the evidence named for the runtime row is this page’s recommendation. Every evidence emission carries the envelope_id as its correlation key, so reconstructing a trajectory is a one-key query (App D §5.2). Implementation of the header check sits on the model gateway; the registry and policy decision point are on the enterprise agent control plane. Research Paper 1 names the same idea as an executable control: unregistered models, agents or tools cannot obtain credentials or routes (§5.5, TR-EXEC-REG).
Agents without a registered envelope are either sandbox experiments or policy breaches; Book 3 Ch 3 allows no third category.
Two views of one record
The books give the envelope at two levels of detail. They are layers of the same artefact, not competing templates.
- The one-page envelope (Book 1 Ch 2 §5.1, §5.4) is the human-readable view that signatories, the CRO, the CISO and audit read. It fits on one side of A4 and has the same structure for every agent.
- The machine schema (Book 3 Appendix D §2, Ch 9 PR-2) is the registry record the runtime, gateway and SOC read. It carries enumerated fields and validation rules.
Generate the one-page view from the registry record; never maintain them separately. Store the record in the agent registry (Book 3 names a Cosmos DB collection on Azure, a DynamoDB item on AWS or a Firestore document on GCP — pick one and standardise), version-controlled, never as a Word file.
The one-page template
Head every envelope with agent name, version and date, then fill every field. An empty section is a refusal to govern that section.
| Part | Fields (Book 1 Ch 2 §5.4) | Owner / countersignatory (§5.1) |
|---|---|---|
| Mandate | Scope · Outcome · Exclusions · Autonomy level · Human override · Owner (named wrangler) | Business owner, countersigned by CIO/CTO delegate |
| Means | Runtime identity · Deployment identity (separate) · Tools with verbs and scopes · Data entitlements · Credential lifetime per credential class · Excluded systems | Lead architect, countersigned by CISO |
| Memory | Read sources · Write targets · Per-session state · Persistent state with retention class · Sharing boundary · Data ceiling | Data owner, countersigned by DPO |
| Monitoring | Trace fields (conforming to the audit evidence schema) · Evaluations with thresholds · Alert routes · Escalation (on-call wrangler and second line) · Audit-evidence reference | Operations lead, countersigned by Head of Audit |
Write Mandate in plain English, Means and Memory as structured fields, and Monitoring as terse trace and alert specifications: the CRO reads Mandate, the CISO reads Means and Memory, operations reads Monitoring, audit reads all four (Book 1 Ch 2 §7). How the four countersignatures route through existing approval bodies is on the lifecycle page.
Mandate: what the agent may do, for whom
Mandate is scope + outcome + exclusions, plus the autonomy ceiling and a usable human-override path (Book 1 Ch 2 §4.2).
- Scope — where in the business the agent operates: service, process step, customer segment.
- Outcome — what it may achieve: draft a reply, classify a break, propose a remediation.
- Exclusions — actions it must never take inside the scope, written down even when they feel obvious, because the next reader will not have the author’s context.
- Human override — how a named person stops, pauses or reverses the agent. The path must be exercised, not just written: Book 1 calls a clause nobody exercises non-compliant by operation. Test it at go-live and at every review (see the suspension rehearsal on the lifecycle page).
A system prompt is not a mandate. A prompt is a run-time hint to a model; a mandate is an organisational commitment about scope of authority. Treat prompt text as derivative of the registered Mandate. Book 3 (Ch 13 §4.2) adds the vendor-side distinction: the model may disregard guidance written in an instruction file such as CLAUDE.md, whereas hooks and managed settings execute deterministically. Treat only the latter as controls.
Mandate schema fields (Book 3 Appendix D §2.1)
| Field | Type | Req. | Records |
|---|---|---|---|
envelope_id | string | required | Unique, immutable registry identifier |
use_case_class | enum | required | research_synthesis, regulatory_drafting, incident_summarisation, evidence_preparation, code_review, claims_triage, customer_correspondence, other |
risk_tier | enum | required | T0 sandbox · T1 internal, low impact · T2 regulated process support, no autonomous customer impact · T3 customer-affecting · T4 prohibited unless executive exception |
business_owner_name, business_owner_role | string | required | Accountable business-line owner and role at registration |
wrangler_name, wrangler_role | string | required | Named human accountable for the agent’s behaviour |
named_approver_role | string | required | Role that approves Mandate amendments; second line for T2 and above |
autonomy_ceiling | enum | required | recommend, draft, execute_with_approval, execute_autonomously |
fria_reference | string | conditional | Fundamental-rights impact assessment document ID and date, when the use case falls in a category that requires one (see the regulatory map) |
usage_policy_alignment | object | required | Alignment with the model provider’s usage policy; for provider high-risk categories, the human-in-the-loop control reference and AI-disclosure path |
customer_facing | boolean | required | Whether output reaches an identifiable customer |
change_authority_ref | string | required | Change-authority (Virtual CAB) minutes reference for the registration approval |
Book 3 Ch 9 PR-2 lists further Mandate fields for API agents — allowed user populations, allowed workspaces, allowed time windows, allowed initiating channels and a free-text rationale (not enforceable). Add them where the runtime can enforce them.
Validation rules (App D §2.1):
autonomy_ceiling = execute_autonomouslyis valid only forT0andT1.fria_referencemust be a non-null document ID whenever the use-case trigger applies.wrangler_namemust resolve to an active identity-provider principal (Entra ID, AWS IAM Identity Center or GCP Cloud Identity) at registration and at every review.usage_policy_alignmentmust declare disclosure where the provider’s policy requires it. Book 3 anchors this to the Anthropic Usage Policy refresh of 15 September 2025. [FACT-CHECK: confirm the current Anthropic Usage Policy version and its high-risk category list before relying on this field’s values.]autonomy_ceilingis immutable without a change-authority decision (see change governance).
The runtime refuses any request outside Mandate before any tool call happens.
Autonomy: a registered ceiling and an earned rung
Two different things are called “autonomy” in the sources. Keep them apart.
- The autonomy ceiling is a Mandate field: the most the agent may ever do. It is set at registration and changes only through the change authority.
- The current rung on the autonomy ladder is the authority the agent has earned for a specific runbook or task in a specific domain. It sits at or below the ceiling and moves on evidence.
The four sources use different vocabularies. The mapping below is this page’s synthesis, not a table from any one book:
| Book 1 Ch 2 / Book 2 Ch 20 ladder | Book 3 autonomy_ceiling | Research Paper 2 action scope | Book 09 Ch 12 |
|---|---|---|---|
| Advisory | recommend, draft | read-only, draft (a human sends) | Advise |
| Controlled execution | execute_with_approval | act with approval | Act with approval |
| Autonomous standard-change | execute_autonomously | act autonomously within a defined envelope | Act alone on standard changes |
Agency class and action scope are independent (Research Paper 2 §2.2): a class 3 design can run at the advisory rung while it is evaluated, and a multi-agent research crew can be read-only.
Ladder rules (Book 2 Ch 20 §5.3 and §8, Ch 27 §5.5; Book 09 Ch 12):
- Climb one rung at a time. Skipping controlled execution (“rung inflation”) is an anti-pattern.
- Earn each rung per agent, per runbook or task, per domain. Trust to restart a stuck queue is not trust to resize a database.
- Read the evidence for promotion from the audit spine — a track record at the rung below — not from a committee’s impression.
- Demote immediately on the first failure, back to advisory for that runbook, and re-earn the rung.
- Freeze promotions when the control budget is spent: when change arrives faster than the firm can evidence and understand it, intake throttles and no agent gains autonomy until it recovers; demotion on first failure still applies. See Running the Factory.
- Book 09’s composite firm fixes control values (tolerances, thresholds, limits) at advise, always routed to a person. Treat that as a sensible default for any parameter that changes what a control lets through.
Where the books differ. Book 3 permits an execute_autonomously ceiling only at T0 and T1. Book 2 lets an agent earn autonomous standard-change for a specific, reversible runbook. This page follows Book 3 for the ceiling: it is the hard maximum. Recommendation: if the firm wants autonomous standard-change at T2 or above, change the tier rule itself through the change authority with second-line co-signature; do not widen a single envelope to get there.
Means: the technical surface, at verb level
Means is the Mandate made enforceable: runtime identity, entitlements and tool list (Book 1 Ch 2 §4.3). Record each tool with its verb and scope, not just its name. Book 1’s example: a reconciliation assistant may call the case-management API with POST on breaks/draft under identity agent-recon-assistant-001, and holds no permission for breaks/close or breaks/amend. Give the smallest tool set, the narrowest identity scope and the shortest credential lifetime that discharges the Mandate.
Means schema fields (Book 3 Appendix D §2.2)
| Field | Type | Req. | Records |
|---|---|---|---|
deployment_route | enum | required | direct_api_apim, foundry, bedrock, claude_platform_aws, vertex; drives the data-processor relationship |
model_id | string | required | Pinned model ID |
model_fallback | string/null | required | Named alternate for wrangler-approved override, or null |
mcp_servers_allowed | array | required | Broker IDs; must be a subset of the connector broker manifest |
built_in_tools | array of enum | required | Subset of Read, Write, Edit, Bash, Glob, Grep, WebSearch, WebFetch, Monitor, AskUserQuestion; Bash and Write usually disabled outside development zones |
cost_ceiling_usd_per_day | number | required | Daily cap per user, enforced at the gateway |
cost_ceiling_usd_per_month | number | required | Monthly aggregate cap |
extended_thinking_budget_tokens | integer | required | Per-session maximum; 0 disables extended thinking |
data_classes_permitted | array of enum | required | From the data dictionary |
data_classes_explicitly_excluded | array of enum | required | Classes the agent must never receive, even inside a tool response |
network_egress_allow_list | array | required | Domains and IP ranges reachable through web tools |
gateway_route_ref | string | required | Gateway route; resolves to the workspace identity and policy decision point |
PR-2 adds a tool-call rate limit, gateway subscription key reference, workload identity reference and a data-classification ceiling. Book 1’s template adds a separate deployment identity and excluded systems; keep both.
Validation rules (App D §2.2):
model_idis on the provider’s current published model list at instantiation (cross-checked against the provider’s deprecation schedule). Book 3’s examples, as of May 2026, useclaude-sonnet-4-6andclaude-opus-4-7. [FACT-CHECK: confirm current Claude model IDs and deprecation dates against Anthropic’s models and deprecations documentation.]mcp_servers_allowed⊆ broker manifest; the runtime cross-checks on every instantiation and refuses if the envelope lists a server the broker has deprecated. The envelope subscribes to the manifest, never the reverse.data_classes_permitted∩data_classes_explicitly_excluded= ∅; any intersection is a registration error.cost_ceiling_usd_per_day = 0is invalid. An envelope without a budget is not a production envelope.
Reconcile grants to the Mandate
Means drifts by “IAM accident”: each grant was locally rational and nobody reviewed the union (Book 1 Ch 2 §8). Run this reconciliation at registration, at every periodic review, and after any incident:
- Enumerate the effective surface — every identity role, access package, gateway route, MCP method and built-in tool the agent can actually reach. Use the effective write surface, not the declared one; a tool named
get_…can still write. - Map each grant to a Mandate line that requires it (scope + outcome).
- Remove every grant without a Mandate line. Removal is the default; retention needs the wrangler’s argument (App D §6).
- Remove tools unused for 90 days unless the wrangler records a seasonal reason (Book 1 Ch 12 §6 composite).
- Record the diff as review evidence.
Acceptance check: on demand, the platform team can produce the complete list of systems the agent can write to, and every entry traces to a Mandate line.
How agent code reaches execution
Some bounded agents run code. Research Paper 2 (§3) separates three routes, each with its own regime (a design proposal in the paper):
| Route | Trust | Minimum controls |
|---|---|---|
| Pre-authored tool code | Trusted as production software | Normal change management, typed parameters, input validation, least-privilege service identity, a log entry per call |
| Agent-generated runtime code (a script written and run mid-task) | Untrusted by default | Ephemeral sandbox; no egress unless allow-listed; CPU, memory and time limits; read-only data mounts limited to the task’s data class; no secrets; code and output kept as evidence; result validated before use |
| Agent-authored code for deployment | Untrusted until reviewed | Pull request with human review, tests and security scans; agent identity recorded as author; no direct push to protected branches |
Two rules follow: a script the agent wrote and ran mid-task reaches a schedule or production only by going through the third route (review, tests, scans), and browser or computer-use actions are treated like generated runtime code (sandboxed session, allow-listed sites, no stored credentials). See the SDLC at agent speed.
Memory: read, write, retain, share
Memory answers four questions (Book 1 Ch 2 §4.4). Each needs an explicit answer and an owner:
| Question | Declare | Typical failure |
|---|---|---|
| Read | Retrieval indexes, databases, connected applications, web sources — each with its classification | Retrieval added “for grounding” with no classification |
| Write | Conversation log, vector memory, session cache, per-user long-term memory, shared multi-agent memory | Vector memory added “for personalisation” |
| Retain | Retention class, period and deletion guarantee for each store | Context grows for the lifetime of the process |
| Share | Which other agents can read the same memory, under which boundary | Shared memory added “to reduce duplication”; one poisoned agent contaminates others |
Set a data-classification ceiling — the highest class the agent may hold — and separate per-session state from persistent state. Memory is the side that grows quietly; it must also answer, weeks later, what the agent retrieved, wrote and shared in a given window, or incident response cannot reconstruct events. Logging and retention obligations are summarised on the regulatory map.
Memory schema fields (Book 3 Appendix D §2.3)
| Field | Type | Req. | Records |
|---|---|---|---|
conversation_memory | enum | required | none, per_turn, per_session, cross_session; cross_session only for T0 and T1 |
retrieval_scope | array | required | Named indices and vector stores; each resolves to a registry record with classification and retention |
vector_store_access | object | required | {enabled, named_indices}; enabled indices must be on the curated index list with quarterly review |
prompt_cache_ttl | enum | required | 5m, 1h, disabled |
persistent_storage | enum | required | none, files_api_on, specific_class |
memory_eviction_rules | string | required | Named trigger, e.g. evict_on_session_end, evict_after_24h, evict_on_event:<event_name>, evict_on_wrangler_override |
memory_audit_obligation | boolean | required | Every persistent write emits an audit record; always true for T2+ |
cross_conversation_retention | boolean | required | Defaults to false; true at T2+ needs second-line co-signature |
PR-2 adds per-user retention TTL, sensitive-disclosure handling, context-window ceiling, subagent context isolation policy and an append-only log destination.
Validation rules (App D §2.3, §6; Ch 9 §9):
- Memory is mandatory. The registry refuses an envelope with no Memory rule, even if the rule is “ephemeral, evict at session end”. Permissive is allowed; absent is not.
memory_eviction_rulesofmanualor null is rejected.vector_store_access.enabled = truewith an emptynamed_indicesis a registration error.cross_conversation_retention = truerequires a time-bound eviction trigger and a sensitive-disclosure handling clause.persistent_storage = files_api_onflags the envelope for second-line review and records a deliberate non-zero-data-retention posture. As of May 2026, Book 3 states the Anthropic Files API is not eligible for zero data retention. [FACT-CHECK: confirm current ZDR eligibility of the Files API and other endpoints against Anthropic documentation.]- Book 3 notes 1-hour cache writes cost 2× input and reads 0.1×; pin
1honly where a large system prompt is reused within the hour. [FACT-CHECK: confirm current Anthropic prompt-caching TTLs and price multipliers.]
Composite example: a Memory failure inside a good envelope
Composite scene from Book 1 Ch 3 §6 (“Bank A”, 2024); it describes no real firm. A customer-onboarding agent proposed KYC categorisations for human approval. It was advisory, its Mandate forbade autonomous action, its Monitoring was strong. Its Memory included the customer entity — and that entity had been extended for newer beneficial-ownership guidance without migrating historical records. Legacy customer_type values silently implied an unknown beneficial-ownership status, and the rule that made that combination require enhanced due diligence lived in a catalogue document the schema did not point at. The agent saw a value, not the rule. After a hundred clean approvals, it proposed low-risk corporate for a restructured corporate client; the reviewer approved; weeks later the financial-intelligence unit flagged a wire that onboarding should have blocked.
The fix was to instrument Memory, not to change the model: a known-limitations register attached to the entity, an effective-from-version field on every record, and a guardrail that read the register first and refused to propose low-risk for records defined under an older guideline version.
Lesson for the envelope: a Memory read source is not bounded until its known limitations are declared alongside it. For every entry in retrieval_scope or the read-source list, record the data product’s known-limitations reference and definition version, and make the agent read them. Data-product practice is on data, API and integration.
Monitoring: trace, evaluate, escalate
Monitoring has three layers (Book 1 Ch 2 §4.5):
- Trace — events the agent emits as it reasons, retrieves, calls tools and responds, conforming to the audit evidence schema.
- Evaluation — continuous and periodic checks against criteria declared in the envelope: factuality, policy adherence, refusal correctness, latency, cost and Mandate conformance, each with a threshold set before deployment.
- Escalation — the named wrangler and team paged when trace or evaluation shows a deviation the platform cannot resolve.
Without Monitoring the other three parts are aspirational: it is what makes suspension possible.
Monitoring schema fields (Book 3 Appendix D §2.4)
| Field | Type | Req. | Records |
|---|---|---|---|
hook_bundle_ref | string | required | Hook bundle (workstation bundle extended with SubagentStart / SubagentStop for SDK agents) |
evaluation_suite_ref | string | required | Named test set and acceptance threshold; re-run on every model upgrade and envelope change |
soc_detection_rules | array | required | SIEM rule IDs |
evidence_capture_ref | string | required | Audit evidence schema reference; the nine fields are emitted on every material action |
review_cadence | enum | required | weekly (T3+), monthly (T2), quarterly (T0/T1) |
review_owner_role | string | required | Wrangler’s role; the wrangler signs the review |
incident_playbook_ref | string | required | Incident shape plus agent-specific playbook |
suspension_contact_role | string | required | Role the SOC pages out of hours |
suspension_contact_phone | string | required | Hotline reference, tested quarterly |
model_upgrade_clause | object | required | What fires on a model upgrade: typically re-run the evaluation suite, wrangler attests, change authority notified within five working days |
PR-2 adds threshold parameters per rule, red-team test cadence, drift-detection metric set, quarterly attestation owner and compliance-export configuration.
Minimum SOC rule set (App D §2.4; Ch 9 §9): token-spend delta, denial-rate spike, off-allow-list MCP attempt, cross-class data retrieval and subagent recursion depth. Book 3 Ch 9 adds tool-call rate anomalies, configuration changes from non-policy sources, and an alert on evidence-mirror errors — a silent session-store outage can drop evidence batches while the agent keeps running. Tune thresholds quarterly.
Validation rules (App D §2.4):
soc_detection_rulesincludes at least one denial-rate rule and at least one cost rule.evaluation_suite_refresolves to a registered test set with a documented sample size and acceptance threshold.suspension_contact_phoneis tested at every quarterly review and the test is logged in the registry. A failed hotline test sets the review status tofailedand the agent’s operational status tosuspendeduntil it passes.
Book 3 App D’s composite research-synthesis envelope (ASMX-RES-SYN-001) illustrates values: a 200-sample evaluation set with a 92% match threshold, token-spend spike above 200% of baseline, subagent recursion depth above 3, and an upgrade clause of re-run within 24 hours, wrangler attestation within 2 working days and change-authority notice within 5. Treat these as illustrative, not as recommended thresholds.
Cadence discrepancy. Book 3 Ch 9 §6.4 gives review cadences as quarterly for T2, monthly for T3 and weekly for T4, which disagrees with Appendix D. This page follows Appendix D (the schema), and Book 1 sets a lower floor; the comparison is on the lifecycle page.
Validate before an envelope_id is issued
At registration the registry runs four checks before it issues an envelope_id (Book 3 Appendix D §5.1). Automate all four; a manual reviewer cannot do the cross-referencing reliably.
| # | Check | Pass condition | On failure |
|---|---|---|---|
| 1 | Schema | Every required field populated; every conditional field populated when its trigger applies | Reject the envelope, naming the missing field |
| 2 | Cross-reference | Data classes exist in the data dictionary; MCP servers exist in the broker manifest; wrangler_name resolves to an active identity; model_id is on the provider’s current list | Reject; name the unresolved reference |
| 3 | Impact assessment | Where the use case requires a fundamental-rights impact assessment, a non-null fria_reference exists and the document is on file with the DPO | Reject until attached |
| 4 | Risk tier routing | T0/T1: default-approval lane · T2: second-line co-signature · T3: second line plus Agent Control Board · T4: prohibited unless executive exception with management-body sign-off | Hold in the approval queue for the named approvers |
Output: envelope_id issued, envelope status registered, and a notification to the change-authority queue. Who signs, and in which body, is on the lifecycle page. Book 3 Ch 13 adds a fifth gate: an envelope without a certified wrangler does not pass registration validation.
A skeleton record
The skeleton below uses only Book 3 Appendix D field names, with placeholders instead of values. It is a starting structure, not a validated template.
envelope_id: <immutable-id>
status: registered # registered | production | suspended | retired
mandate:
use_case_class: <enum>
risk_tier: <T0..T4>
business_owner_name: <name>
business_owner_role: <role>
wrangler_name: <name> # must resolve to an active IdP principal
wrangler_role: <role>
named_approver_role: <role> # second line for T2+
autonomy_ceiling: <recommend|draft|execute_with_approval|execute_autonomously>
fria_reference: <doc-id or null>
usage_policy_alignment: { ... }
customer_facing: <true|false>
change_authority_ref: <minutes-ref>
means:
deployment_route: <enum>
model_id: <pinned-id>
model_fallback: <id or null>
mcp_servers_allowed: [<broker-id>, ...] # subset of broker manifest
built_in_tools: [<tool>, ...]
cost_ceiling_usd_per_day: <number > 0>
cost_ceiling_usd_per_month: <number>
extended_thinking_budget_tokens: <integer>
data_classes_permitted: [<class>, ...]
data_classes_explicitly_excluded: [<class>, ...] # disjoint from permitted
network_egress_allow_list: [<domain>, ...]
gateway_route_ref: <route>
memory:
conversation_memory: <none|per_turn|per_session|cross_session>
retrieval_scope: [<index>, ...]
vector_store_access: { enabled: <bool>, named_indices: [<index>, ...] }
prompt_cache_ttl: <5m|1h|disabled>
persistent_storage: <none|files_api_on|specific_class>
memory_eviction_rules: <named-trigger> # never manual or null
memory_audit_obligation: <bool> # true for T2+
cross_conversation_retention: <bool>
monitoring:
hook_bundle_ref: <ref>
evaluation_suite_ref: <ref>
soc_detection_rules: [<rule-id>, ...] # >=1 denial-rate, >=1 cost
evidence_capture_ref: <ref>
review_cadence: <weekly|monthly|quarterly>
review_owner_role: <role>
incident_playbook_ref: <ref>
suspension_contact_role: <role>
suspension_contact_phone: <hotline-ref>
model_upgrade_clause: { ... }
Book 1 Ch 9 adds a zone field with exactly one of four values; see zone declaration.
Worked example: a bounded task agent with approval before write
Research Paper 2 (§5.8, Archetype 8) gives an envelope for a bank’s cash-reconciliation team. It is an illustration in the paper, not a deployment record.
| Envelope element | Example setting |
|---|---|
| Goal and scope | Investigate the team’s unmatched cash breaks and propose corrections |
| Allowed tools | Read: ledger, mailbox search, correspondent-bank statements. Write: one tool, which creates a correction proposal |
| Action scope | Every write needs approval; payments and external email are out of scope |
| Data scope | The requesting team’s accounts; C3 maximum |
| Budgets | At most 30 tool calls and 10 minutes per run, plus a token cap |
| Escalation | Unknown counterparty, amount above threshold, conflicting evidence |
| Identity | Dedicated least-privilege agent identity; on-behalf-of for user-triggered runs |
| Accountable owner | Named head of the operations team |
Book 2 Ch 23 §5.3 gives the same envelope as recipe Family 8 for a composite Asset Manager X reconciliations team, laid out by the four sides: Mandate fixes the goal, scope and ladder rung (controlled execution); Means splits read from write tools and sets ceilings on tool calls, wall-clock time and tokens per run; Memory keeps run state only, with no long-term memory above internal; Monitoring sends the full trajectory to the audit spine, names the escalation conditions and gives the wrangler a kill switch.
Run flow.
- A user or event triggers the agent with a goal.
- The agent drafts a plan; the plan is logged and, for higher-risk tasks, shown to the user.
- In the loop, every tool call passes the same policy check on tool, scope and budget.
- Reads execute directly. Writes create an approval task and wait. Denied calls escalate to the owner.
- Observations update the run state.
- The run ends on success, budget exhaustion or escalation, with a report, evidence and the full trace.
Widening rule. Side effects keep waiting for approval until replay testing against recorded cases justifies widening the envelope; autonomy is reserved for reversible, low-risk actions proven by replay. Evidence includes the logged plan, the full trajectory of tool calls and policy decisions, every approval task and its decider, and the final report. Anti-patterns: giving the agent a user’s full permissions, open-ended “do whatever it takes” goals, and approvals that people click through without information.
Controls to put outside the model
- Enforce tool authorisation and data entitlements at the tool broker or service boundary, not in the prompt.
- Set step, time and spend budgets outside the agent loop.
- Keep the agent identity scoped to its declared task; use separate identities where ownership or security boundaries differ.
- Screen tool outputs for prompt injection before they re-enter context.
- Retain enough trace and outcome evidence to reconstruct the trajectory, within the approved Memory and retention rules.
- Evaluate against representative and adverse cases before release, then monitor deviations in operation.
- Provide a stop path and a human escalation route for work outside the envelope, and prove both work.
Detect drift and recognise the anti-patterns
Quarterly drift report (App D §6). For every envelope, the registry produces the diff between current and registration state across Means, Memory and Monitoring, set against the autonomy_ceiling. A ceiling unchanged for twelve months while built_in_tools and mcp_servers_allowed have doubled is the leading indicator of autonomy creep. Review the report at the periodic review; any unexplained growth is a finding.
| Anti-pattern | Signal | Recovery |
|---|---|---|
| Mandate by wiki (Book 1) | “What is this agent allowed to do?” gets different answers from different team members | Write the Mandate section, ratify it with the business owner; the wiki becomes derivative |
| Mandate written as prose (Book 3) | Mandate is paragraphs the runtime cannot refuse, the gateway cannot match and the SOC cannot detect against | Enforce the structured Mandate schema; prose moves to the rationale field |
| Means by IAM accident (Book 1) | Nobody can produce, on demand, the list of systems the agent can write to | Run the grant-to-mandate reconciliation above |
| Means list that only grows (Book 3) | mcp_servers_allowed grows monotonically with no removals; entries nobody can defend in audit | Mandatory quarterly review; removal by default unless the wrangler argues retention |
| Memory unbounded / no eviction (both) | “Where does this agent’s memory end?” produces a long pause; rich Memory fields with empty or vague memory_eviction_rules | Classify every store, set retention, confirm or remove sharing; registry rejects manual or null eviction |
| Means without Memory (Book 3) | Rich Means fields, empty Memory section; SDK default retention leaks one session into another | Memory mandatory at registration |
| Monitoring after the fact (Book 1) | Nobody can say, in flight, whether the agent is inside its envelope right now | Specify trace schema, evaluation suite and thresholds before the next deployment; route escalation to the wrangler |
| Monitoring without thresholds or contact (Book 3) | Hooks emit, no rule references them; or rules fire and nobody is on the hook out of hours | Minimum rule set; required, tested suspension contact; failed hotline test suspends the agent |
| Autonomy creep, human and machine (Book 3) | Ceiling static while tools double; behaviour drifts between identical prompts with no change request; a revoked credential still succeeds | Ceiling bound to the change authority with second-line co-signature; manual review of any memory-curation process in a regulated function; treat credential revocation as session termination |
| Envelope theatre (Book 1) | A signed four-section document exists, but runtime behaviour does not match it and nothing flags the gap | Make the envelope policy-as-code read by runtime, gateway and SOC — or admit it is a memo |
| Rung inflation (Book 2) | An agent acts autonomously on a runbook it has no track record for; “trusted” is a property of the agent rather than agent + runbook + domain | Demote to advisory on that runbook and re-earn with evidence |
Every recovery has the same shape: rewrite the section, remove the implicit, make the platform enforce it, then verify with a real test.
Move work across agency classes: translocation
The shape of a process is not fixed once built (Book 2 Ch 20 §5.5; Research Paper 1 §5.2):
- Codify down. If the audit spine shows a stable hot path — the same tool sequence in most runs, sustained over time — rebuild that path as workflow steps or plain code, prove equivalence by replaying recorded cases, and leave only the residual cases with the agent.
- Delegate up. If a procedural system’s exception queue consumes skilled manual effort and the resolutions vary, route those exceptions to an agent that starts at the advisory rung behind a typed interface.
Both moves are evidence-led. A consequence: the share of work done by agents should not only rise. If it only ever climbs, nobody is codifying stable paths out of the agents.
Reject or defer when
Do not use this shape when the steps are known, when no named owner will accept the wrangler role, when the tool access cannot be bounded at verb level, when the firm cannot evaluate trajectories, or when the observability answer to intake question 4 is weak. A deferral names the evidence or capability that would trigger a review, rather than becoming an indefinite veto.
Platform implementation notes
The envelope is platform-neutral; its enforcement is not. Book 1 Ch 2 §5.5 maps the four parts onto the hyperscalers (per vendor documentation accessed May 2026). [FACT-CHECK: product names, GA status and capabilities below change frequently; confirm each against current Microsoft Learn, AWS and Google Cloud documentation.]
| Part | Microsoft Azure | AWS | Google Cloud |
|---|---|---|---|
| Mandate | Agent registration in Foundry Agent Service plus Azure Policy assignments | Agent definition in Bedrock AgentCore with IAM and AgentCore Policy | Agent definition in Gemini Enterprise Agent Platform |
| Means | Entra Agent ID plus Foundry tool registrations | IAM role (action-resource-condition) gated by AgentCore Identity | Agent Identity bound to IAM; Apigee as MCP gateway |
| Memory | Cosmos DB containers, Azure AI Search indexes, Foundry-managed memory; Purview for classification | AgentCore Memory plus stores under Lake Formation | Agent Registry plus connected stores |
| Monitoring | Azure Monitor, Application Insights, Foundry tracing; Sentinel for security | CloudWatch, X-Ray, AgentCore Observability | Cloud Logging, Cloud Trace, Gemini Enterprise observability |
For Claude specifically (Book 3, as of mid-2026): the envelope is read by the Agent SDK options at instantiation, the gateway enforces Means at the wire, and hooks (PreToolUse, PostToolUse, UserPromptSubmit, ConfigChange, plus SubagentStart/SubagentStop for SDK agents) supply trace and deny events. Book 3 Ch 9 PR-3 has an SDK starter that loads the envelope from the registry and refuses to instantiate on a missing field. [FACT-CHECK: confirm current Claude Agent SDK hook event names and settings scopes against Anthropic documentation.]
Acceptance checks
- Every production agent has a registry record with an immutable
envelope_id; runtime, gateway and SOC each refuse or alert on calls without one, and each refusal path has been tested. - All four sections are populated; the one-page view is generated from the registry record.
- Mandate includes exclusions and a human-override path that has been exercised;
autonomy_ceilingis set and change-controlled. - Every tool in Means is recorded with verb and scope; the grant-to-mandate reconciliation shows no orphan grants; permitted and excluded data classes are disjoint; budgets are non-zero.
- Memory declares read, write, retain and share, a classification ceiling, and a non-manual eviction trigger; read sources carry known-limitations references.
- Monitoring has the minimum SOC rule set, a registered evaluation suite with a threshold, a tested suspension contact and a model-upgrade clause.
- The four pre-production checks run automatically and block on failure.
- The drift report is produced and reviewed at each periodic review.
Provenance and source differences
This page synthesises Book 1 Ch 1–3, Book 2 Ch 20, 22 and 27 with Appendix C, Book 3 Ch 1, 3, 9, 13 and 14 with Appendix D, Book 09 Ch 12, Research Papers 1 and 2, and the Whitepaper Part III. Field names, enums and thresholds are Book 3 Appendix D’s; the one-page template and countersignatories are Book 1’s. Where they differ:
- Autonomy vocabulary differs across four sources; the mapping table above is this page’s synthesis.
- Autonomous ceiling at T2+: Book 3 forbids it; Book 2 allows autonomous standard-change earned per runbook. This page follows Book 3 for the ceiling.
- Review cadence differs between Book 3 Appendix D and Book 3 Ch 9, and from Book 1; see the lifecycle page.
- Composite material (“Bank A”, “Asset Manager X”,
ASMX-RES-SYN-001) is illustrative and describes no real firm.
Review trigger: a change to the Book 3 envelope schema, the provider’s model list or usage policy, the connector broker manifest format, or the risk-tier definitions.
Source material
- Book 1, Chapter 1, The Adoption Gap (§4.1 agents as a class of actor)
- Book 1, Chapter 2, The Bounded Agency Thesis (§4.2–4.5, §5.1, §5.4, §5.5, §7, §8)
- Book 1, Chapter 3, Software as an Abstraction of Reality (§6 KYC worked example)
- Book 2, Chapter 20, Agent-Driven Departments (§5.3 autonomy ladder, §5.5 translocation, §8)
- Book 2, Chapter 22, The Shape of an AI Product, and Appendix C, section C.7: Single-agent patterns
- Book 2, Chapter 23, The Ten Recipe Families (§5.3 Family 8, bounded task agent)
- Book 2, Chapter 27, The Eighteen-Month Roadmap (§5.5 autonomy ladder and control budget)
- Book 3, Chapters 1 and 3, least agency and the provider's reading of the boundary
- Book 3, Chapter 9, The Anthropic API and Agent SDK (§6, §9, PR-2)
- Book 3, Chapter 13, Wranglers, Product Teams and RACI (§4.1 certification gate, §4.2 prompts and hooks as artefacts)
- Book 3, Chapter 14, Risk Tiers and the Use-Case Taxonomy (§4.1 intake questions)
- Book 3, Appendix D, Bounded-Agency Envelope Template (Claude Variant)
- Book 09, Chapter 12, Who Holds the Dial (autonomy per task)
- Research Paper 1, Taxonomy for a Reuse-Driven AI Factory (§5.2 translocation, §5.5 controls that execute)
- Research Paper 2, Ten Solution Archetypes for Regulated Finance (§2.2, §3, §5.8)
- Whitepaper, The Age of AI, Part III §2, The four boundaries of an agent in production
Related guidance
-
Choose the Shape of an AI ProductA least-agency decision sequence for choosing a product design: agency classes and their trade-offs, the eight questions, evidence for every step up, the consequence matrix that caps action scope, the cut-set review for agents, the other selection dimensions, and the design record. -
Workflow PatternUse a workflow when code can determine the next step, even when some steps call a model: the eight workflow patterns with their forces and factory notes, why class 2 is the default, how code-orchestrated multi-agent flows stay workflows, how to codify a stable agent path down or delegate exceptions up, and a composite service-desk triage example read across frameworks and cloud pillars. -
Operate the Agent LifecycleInventory, register, sign, zone, review, suspend, recover and retire agents through a six-stage lifecycle with named human ownership, zone-specific authority and evidence at every transition. -
Classify Use Cases into Risk TiersThe T0–T4 use-case taxonomy as a working decision reference: the prohibited-use gate, four intake questions, data and action boundaries per tier, the twelve-area control matrix, retention and payload rules, runtime enforcement, approval gates, regulatory routing and re-tiering. -
The Enterprise Agent Control PlaneThe firm-owned services that make every agent action identifiable, decidable, approvable and reconstructable: the ownership boundary, six planes and their contracts, the Policy Decision API with its latency budget, the persistence schema, the build sequence and the tests that show it works. -
Design and Operate the Model GatewayBuild the model gateway as the governed edge for every model call: per-client identity, per-request highest-class routing, tokenisation, pinned models, a conformant wire contract, a correlated evidence record, a tested concentration answer, and day-two cost, latency and reliability operations across two estates and three meters. -
Govern MCP Connectors Through a BrokerAdmit, tier, pin and enforce every MCP server through one registry and two enforcement points, keep tokens audience-bound, govern A2A delegation through its own registry and gateway, and expose client-facing agent channels only through the same policy layer. -
Identity, Secrets and Configuration for Agent WorkloadsGive every actor one owned identity, size its authority for the worst case, separate runtime from deployment, federate instead of holding keys, refuse impersonation and silent fallback, govern configuration by class, and audit the estate until flagged identities decline. -
The Audit Spine and the Evidence RecordHow to capture, join, protect, retain and prove per-action evidence: the AES v0.1.0 record contract, three capture points and one correlation ID, tiered immutable storage, retention and legal hold, replay rehearsal, the route-approval evidence gate, and the Claude-specific ways evidence goes missing. -
Change Governance for Agent-Enabled DeliveryRoute agent-speed change by risk without losing the approver: control values that always reach a person, a routing gate that reads the right signals, autonomy earned per change family, a Virtual CAB that prepares a complete dossier, and three bodies with defined escalation.