Browse the reference ⌄
Pattern published

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

Full source list ↓ Source index →

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 classes compare fixed code-selected steps with model-selected steps and place the bounded agent at class 3.

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:

PropertyModelApplicationAutomationAI agent
Decides?NoLimitedNo / limitedYes
Acts?NoYesYesYes
Has identity?NoYesYesYes
Uses tools?NoBuild-timeBuild-timeRuntime
Needs an envelope?NoPartlyPartlyYes

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).

Bounded agency: an agent governed at once by four boundaries: Mandate, Means, Memory and 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.

#QuestionWhat the answer sets in the envelope (this page’s mapping)
1What untrusted content will the agent ingest?Memory read sources and Means data classes; prompt-injection screening requirement
2What actions can it take, and on whose behalf?Mandate autonomy_ceiling; Means tool verbs and identity (agent identity or on-behalf-of)
3What is the blast radius if it is misaligned or hijacked?The risk tier, and therefore approvers, review cadence and suspension thresholds
4What 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 pointRuleFailure behaviourEvidence
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 absentFail closed; no agent processInstantiation refusal logged by the hook bundle
Model gatewayRefuses to forward a model call that does not carry an envelope ID in its headers; enforces Means (models, budgets, data classes) on every callRequest rejected at the wireGateway deny record with envelope ID and reason
SOC detectionA detection rule fires on any successful model call that carries no envelope referenceAlert to SOC; investigate as an unregistered agentSIEM 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.

PartFields (Book 1 Ch 2 §5.4)Owner / countersignatory (§5.1)
MandateScope · Outcome · Exclusions · Autonomy level · Human override · Owner (named wrangler)Business owner, countersigned by CIO/CTO delegate
MeansRuntime identity · Deployment identity (separate) · Tools with verbs and scopes · Data entitlements · Credential lifetime per credential class · Excluded systemsLead architect, countersigned by CISO
MemoryRead sources · Write targets · Per-session state · Persistent state with retention class · Sharing boundary · Data ceilingData owner, countersigned by DPO
MonitoringTrace fields (conforming to the audit evidence schema) · Evaluations with thresholds · Alert routes · Escalation (on-call wrangler and second line) · Audit-evidence referenceOperations 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)

FieldTypeReq.Records
envelope_idstringrequiredUnique, immutable registry identifier
use_case_classenumrequiredresearch_synthesis, regulatory_drafting, incident_summarisation, evidence_preparation, code_review, claims_triage, customer_correspondence, other
risk_tierenumrequiredT0 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_rolestringrequiredAccountable business-line owner and role at registration
wrangler_name, wrangler_rolestringrequiredNamed human accountable for the agent’s behaviour
named_approver_rolestringrequiredRole that approves Mandate amendments; second line for T2 and above
autonomy_ceilingenumrequiredrecommend, draft, execute_with_approval, execute_autonomously
fria_referencestringconditionalFundamental-rights impact assessment document ID and date, when the use case falls in a category that requires one (see the regulatory map)
usage_policy_alignmentobjectrequiredAlignment with the model provider’s usage policy; for provider high-risk categories, the human-in-the-loop control reference and AI-disclosure path
customer_facingbooleanrequiredWhether output reaches an identifiable customer
change_authority_refstringrequiredChange-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):

  1. autonomy_ceiling = execute_autonomously is valid only for T0 and T1.
  2. fria_reference must be a non-null document ID whenever the use-case trigger applies.
  3. wrangler_name must resolve to an active identity-provider principal (Entra ID, AWS IAM Identity Center or GCP Cloud Identity) at registration and at every review.
  4. usage_policy_alignment must 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.]
  5. autonomy_ceiling is 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 ladderBook 3 autonomy_ceilingResearch Paper 2 action scopeBook 09 Ch 12
Advisoryrecommend, draftread-only, draft (a human sends)Advise
Controlled executionexecute_with_approvalact with approvalAct with approval
Autonomous standard-changeexecute_autonomouslyact autonomously within a defined envelopeAct 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):

  1. Climb one rung at a time. Skipping controlled execution (“rung inflation”) is an anti-pattern.
  2. Earn each rung per agent, per runbook or task, per domain. Trust to restart a stuck queue is not trust to resize a database.
  3. Read the evidence for promotion from the audit spine — a track record at the rung below — not from a committee’s impression.
  4. Demote immediately on the first failure, back to advisory for that runbook, and re-earn the rung.
  5. 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.
  6. 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)

FieldTypeReq.Records
deployment_routeenumrequireddirect_api_apim, foundry, bedrock, claude_platform_aws, vertex; drives the data-processor relationship
model_idstringrequiredPinned model ID
model_fallbackstring/nullrequiredNamed alternate for wrangler-approved override, or null
mcp_servers_allowedarrayrequiredBroker IDs; must be a subset of the connector broker manifest
built_in_toolsarray of enumrequiredSubset of Read, Write, Edit, Bash, Glob, Grep, WebSearch, WebFetch, Monitor, AskUserQuestion; Bash and Write usually disabled outside development zones
cost_ceiling_usd_per_daynumberrequiredDaily cap per user, enforced at the gateway
cost_ceiling_usd_per_monthnumberrequiredMonthly aggregate cap
extended_thinking_budget_tokensintegerrequiredPer-session maximum; 0 disables extended thinking
data_classes_permittedarray of enumrequiredFrom the data dictionary
data_classes_explicitly_excludedarray of enumrequiredClasses the agent must never receive, even inside a tool response
network_egress_allow_listarrayrequiredDomains and IP ranges reachable through web tools
gateway_route_refstringrequiredGateway 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):

  1. model_id is 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, use claude-sonnet-4-6 and claude-opus-4-7. [FACT-CHECK: confirm current Claude model IDs and deprecation dates against Anthropic’s models and deprecations documentation.]
  2. 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.
  3. data_classes_permitted ∩ data_classes_explicitly_excluded = ∅; any intersection is a registration error.
  4. cost_ceiling_usd_per_day = 0 is 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:

  1. 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.
  2. Map each grant to a Mandate line that requires it (scope + outcome).
  3. Remove every grant without a Mandate line. Removal is the default; retention needs the wrangler’s argument (App D §6).
  4. Remove tools unused for 90 days unless the wrangler records a seasonal reason (Book 1 Ch 12 §6 composite).
  5. 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):

RouteTrustMinimum controls
Pre-authored tool codeTrusted as production softwareNormal 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 defaultEphemeral 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 deploymentUntrusted until reviewedPull 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:

QuestionDeclareTypical failure
ReadRetrieval indexes, databases, connected applications, web sources — each with its classificationRetrieval added “for grounding” with no classification
WriteConversation log, vector memory, session cache, per-user long-term memory, shared multi-agent memoryVector memory added “for personalisation”
RetainRetention class, period and deletion guarantee for each storeContext grows for the lifetime of the process
ShareWhich other agents can read the same memory, under which boundaryShared 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)

FieldTypeReq.Records
conversation_memoryenumrequirednone, per_turn, per_session, cross_session; cross_session only for T0 and T1
retrieval_scopearrayrequiredNamed indices and vector stores; each resolves to a registry record with classification and retention
vector_store_accessobjectrequired{enabled, named_indices}; enabled indices must be on the curated index list with quarterly review
prompt_cache_ttlenumrequired5m, 1h, disabled
persistent_storageenumrequirednone, files_api_on, specific_class
memory_eviction_rulesstringrequiredNamed trigger, e.g. evict_on_session_end, evict_after_24h, evict_on_event:<event_name>, evict_on_wrangler_override
memory_audit_obligationbooleanrequiredEvery persistent write emits an audit record; always true for T2+
cross_conversation_retentionbooleanrequiredDefaults 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):

  1. 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.
  2. memory_eviction_rules of manual or null is rejected.
  3. vector_store_access.enabled = true with an empty named_indices is a registration error.
  4. cross_conversation_retention = true requires a time-bound eviction trigger and a sensitive-disclosure handling clause.
  5. persistent_storage = files_api_on flags 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.]
  6. Book 3 notes 1-hour cache writes cost 2× input and reads 0.1×; pin 1h only 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):

  1. Trace — events the agent emits as it reasons, retrieves, calls tools and responds, conforming to the audit evidence schema.
  2. 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.
  3. 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)

FieldTypeReq.Records
hook_bundle_refstringrequiredHook bundle (workstation bundle extended with SubagentStart / SubagentStop for SDK agents)
evaluation_suite_refstringrequiredNamed test set and acceptance threshold; re-run on every model upgrade and envelope change
soc_detection_rulesarrayrequiredSIEM rule IDs
evidence_capture_refstringrequiredAudit evidence schema reference; the nine fields are emitted on every material action
review_cadenceenumrequiredweekly (T3+), monthly (T2), quarterly (T0/T1)
review_owner_rolestringrequiredWrangler’s role; the wrangler signs the review
incident_playbook_refstringrequiredIncident shape plus agent-specific playbook
suspension_contact_rolestringrequiredRole the SOC pages out of hours
suspension_contact_phonestringrequiredHotline reference, tested quarterly
model_upgrade_clauseobjectrequiredWhat 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):

  1. soc_detection_rules includes at least one denial-rate rule and at least one cost rule.
  2. evaluation_suite_ref resolves to a registered test set with a documented sample size and acceptance threshold.
  3. suspension_contact_phone is tested at every quarterly review and the test is logged in the registry. A failed hotline test sets the review status to failed and the agent’s operational status to suspended until 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.

#CheckPass conditionOn failure
1SchemaEvery required field populated; every conditional field populated when its trigger appliesReject the envelope, naming the missing field
2Cross-referenceData 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 listReject; name the unresolved reference
3Impact assessmentWhere the use case requires a fundamental-rights impact assessment, a non-null fria_reference exists and the document is on file with the DPOReject until attached
4Risk tier routingT0/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-offHold 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 elementExample setting
Goal and scopeInvestigate the team’s unmatched cash breaks and propose corrections
Allowed toolsRead: ledger, mailbox search, correspondent-bank statements. Write: one tool, which creates a correction proposal
Action scopeEvery write needs approval; payments and external email are out of scope
Data scopeThe requesting team’s accounts; C3 maximum
BudgetsAt most 30 tool calls and 10 minutes per run, plus a token cap
EscalationUnknown counterparty, amount above threshold, conflicting evidence
IdentityDedicated least-privilege agent identity; on-behalf-of for user-triggered runs
Accountable ownerNamed 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.

  1. A user or event triggers the agent with a goal.
  2. The agent drafts a plan; the plan is logged and, for higher-risk tasks, shown to the user.
  3. In the loop, every tool call passes the same policy check on tool, scope and budget.
  4. Reads execute directly. Writes create an approval task and wait. Denied calls escalate to the owner.
  5. Observations update the run state.
  6. 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-patternSignalRecovery
Mandate by wiki (Book 1)“What is this agent allowed to do?” gets different answers from different team membersWrite 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 againstEnforce 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 toRun 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 auditMandatory 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_rulesClassify 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 anotherMemory mandatory at registration
Monitoring after the fact (Book 1)Nobody can say, in flight, whether the agent is inside its envelope right nowSpecify 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 hoursMinimum 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 succeedsCeiling 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 gapMake 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 + domainDemote 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.]

PartMicrosoft AzureAWSGoogle Cloud
MandateAgent registration in Foundry Agent Service plus Azure Policy assignmentsAgent definition in Bedrock AgentCore with IAM and AgentCore PolicyAgent definition in Gemini Enterprise Agent Platform
MeansEntra Agent ID plus Foundry tool registrationsIAM role (action-resource-condition) gated by AgentCore IdentityAgent Identity bound to IAM; Apigee as MCP gateway
MemoryCosmos DB containers, Azure AI Search indexes, Foundry-managed memory; Purview for classificationAgentCore Memory plus stores under Lake FormationAgent Registry plus connected stores
MonitoringAzure Monitor, Application Insights, Foundry tracing; Sentinel for securityCloudWatch, X-Ray, AgentCore ObservabilityCloud 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_ceiling is 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

← All AI Delivery Factory guidance

On this page

  1. Why an agent needs an envelope at all
  2. Decide whether a bounded agent is the right shape
    1. The four intake questions
  3. The rule: no envelope, no production
  4. Two views of one record
    1. The one-page template
  5. Mandate: what the agent may do, for whom
    1. Mandate schema fields (Book 3 Appendix D §2.1)
  6. Autonomy: a registered ceiling and an earned rung
  7. Means: the technical surface, at verb level
    1. Means schema fields (Book 3 Appendix D §2.2)
    2. Reconcile grants to the Mandate
    3. How agent code reaches execution
  8. Memory: read, write, retain, share
    1. Memory schema fields (Book 3 Appendix D §2.3)
    2. Composite example: a Memory failure inside a good envelope
  9. Monitoring: trace, evaluate, escalate
    1. Monitoring schema fields (Book 3 Appendix D §2.4)
  10. Validate before an envelope_id is issued
  11. A skeleton record
  12. Worked example: a bounded task agent with approval before write
  13. Controls to put outside the model
  14. Detect drift and recognise the anti-patterns
  15. Move work across agency classes: translocation
  16. Reject or defer when
  17. Platform implementation notes
  18. Acceptance checks
  19. Provenance and source differences

All pages in Patterns →