Glossary and Vocabulary Crosswalk
The controlled vocabulary of the AI Delivery Factory reference, with a crosswalk for the places where the books, working papers and specifications use different words for the same thing.
- Version
- 0.2.0
- Owner
- DEIXEI
- Last reviewed
- Reading time
- 55 min
For Cto · Ai Architect · Platform Engineer · Product Leader · Risk And Assurance · Internal Audit
Sources and details
- Section
- Reference
- Source works
- Book 1 · Book 2 · Book 3 · Book 09 · Research Series · Supporting Tools · ADD proposal · Whitepaper
- Source chapters
- 1, 2, 3, 4, 5, 6, 8, 10, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 24, 25, 27
- Source appendices
- 01:B, 01:D, 02:A, 02:B, 02:C, 04:A, 04:E, 04:G, 04:H, 04:J
- Tool specifications
- audit_evidence_schema@0.1.0
- Refresh trigger
- source change
This page fixes what each term means on the AI Delivery Factory reference, so that an architecture review, a change dossier and an audit request use the same words for the same things. It has three parts:
- Vocabulary rules: the term this reference uses when the sources offer several.
- Crosswalks: side-by-side tables for the places where the books, the working papers and the specifications use different words or different scales. The point of the tables is that nobody blends two models without noticing.
- Glossary: definitions grouped by the decision they support. Each entry names its source and the reference page that treats the term in depth.
Definitions here are short restatements. Where a term is defined normatively elsewhere, such as a schema field or a legal concept, the definition here points to that place and does not replace it. Regulatory terms are defined only as far as a practitioner needs to find the right obligation. Their legal text and articles live on the regulatory map, their dates on the regulatory calendar, and the official texts behind both on primary sources.
Vocabulary rules this reference follows
| Concept | Term used on this reference | Also seen in the sources | Why this choice |
|---|---|---|---|
| Where a model request is processed | Hosting route (vendor API, private tenancy, controlled infrastructure) | Processing lane A, B, C (Research Papers 1, 2 and 9) | Book 2 is the reference’s backbone and reserves lane for the delivery lane. The exception is data classes and lanes, which implements Paper 9’s class × lane matrix and keeps Paper 9’s lane letters. There, processing lane and hosting route name the same thing. |
| The commercial and technical path by which Claude is reached | Deployment route (Anthropic API, Claude Platform on AWS, Amazon Bedrock, Claude on Google Cloud, Microsoft Foundry, plus the Microsoft 365 Copilot surface) | “Route” in Book 3 | A deployment route is not a hosting route. Each deployment route is assigned to a hosting route or lane per deployment, by who operates inference and who can see the data. See the crosswalk below and deployment routes. |
| Design-time shape of a product | Agency class 0–4 | A0–A4 (Research Papers 1, 2 and 9) | Same five classes, same definitions; only the notation differs. |
| Run-time, earned trust | Autonomy ladder (advisory, controlled execution, autonomous standard-change) | Action scope (read-only, draft, act with approval, act autonomously); Virtual CAB autonomy levels | See the crosswalk below. Action scope is kept as the design-time ceiling view of the same ladder. |
| Reusable, parameterised assembly | Recipe and recipe family | Governed blueprint (Paper 1), solution archetype (Paper 2) | Book 2 Appendix C states that the book’s terms win over the working paper’s. |
| Door for model calls | Model gateway | AI gateway (Book 1, Paper 1), LLM gateway (Book 3) | Book 2 term; the other two name the same control point. |
| Door for tool and MCP calls | Tool broker (MCP broker where the tools are MCP servers) | Connector broker (Book 3) | Book 2 term. The site page is titled for the broker pattern: MCP and connector broker. |
| Customer-facing classification of a use case | Risk tier (T0–T4 where the Book 3 taxonomy is adopted) | Tier 0–Tier 4; “the institution’s own” (Book 2, Paper 1) | Book 2 and Paper 1 leave the scale to the firm; Book 3 supplies a concrete five-tier scale. See risk tiers. |
| Data sensitivity | Data class C1–C4 with flags | Firm-specific labels; AES classification enum | Codes from Paper 9; map them to the firm’s existing scale rather than adding a second one. |
| The nine-question record | Audit Evidence Schema (AES), as published at /aes/v0.1.0/ | Book 3’s differently worded question set | The published schema is normative. Book 3 Appendix E itself says the specification wins where prose and specification disagree. |
Crosswalks
Where a request is processed: hosting route, lane and deployment route
| Book 2 hosting route | Research Paper 9 processing lane | Defining facts (Paper 9, section 4.1) | Book 3 deployment routes that usually fall here |
|---|---|---|---|
| Vendor API | Lane A: vendor API under an enterprise contract | The model vendor operates inference and can see prompts and outputs during processing and any contractual retention | Anthropic API; Claude Platform on AWS; Claude models on Google Cloud, Anthropic managed; Microsoft Foundry (Claude); the Anthropic models in Microsoft 365 Copilot. Anthropic processes the prompts and outputs on each: as processor per Anthropic’s documentation (read 15 November 2026) or Book 3 App A, and for Microsoft 365 Copilot as a Microsoft sub-processor. On four of the five, someone other than Anthropic bills |
| Private tenancy | Lane B: vendor model through the firm’s own cloud tenancy, approved region, private endpoints | The cloud provider operates inference; the model developer typically cannot see the data | Amazon Bedrock; Claude on Google Cloud, Google managed (Book 3 App A, as of August 2026, names AWS and Google as processors) [FACT-CHECK: re-derive the processor for Bedrock and the Google-managed offering from current vendor terms; they were not re-read on 15 November 2026] |
| Controlled infrastructure | Lane C: open-weight or licensed model on infrastructure the firm controls | The firm, or a provider acting solely on its instructions; no model vendor sees the data | Self-hosted floor (Book 2 Chapter 25); no Claude route |
Source difference on Foundry. Book 3 Appendix J (Glossary) and Appendix H place Foundry with the cloud-processed routes. Book 3 Appendix A (revised August 2026), Chapter 4, Research Paper 3 and Anthropic’s Foundry documentation (read 15 November 2026) name Anthropic as the processor on both Foundry hosting options. This reference follows the newer sources, and the lane assignment above is this page’s reading of Paper 9’s two defining facts against that processor statement. A firm may still treat a Foundry deployment hosted on Azure as meeting a Lane B control if its own legal review of the executed terms supports that; record the reasoning on the contracting-matrix row. The full comparison is on deployment routes.
Rules that hold across all three vocabularies:
-
The route is chosen per request, by the highest data class among the request’s inputs (Book 2 Appendix A; Paper 9 section 5.2). It is not stored on the application. Paper 9 section 10 is explicit that the lane is derived by the gateway, not a field in the classification code.
-
The route is assigned per model deployment, not per vendor or console. The same model family can sit on different routes depending on how it is reached (Paper 9 section 4.2). Re-check the assignment when the model version changes.
-
“Lane” in Book 2 always means a delivery lane (the human lane and the agent lane of the two-speed SDLC). Do not use it for hosting on pages that cite Book 2.
-
The biller is not the processor. A cloud marketplace bill or login screen says nothing about who sees the data. Re-derive the processor per route from the vendor’s current text and the executed agreement.
The class × lane permission matrix that links data class to route is on data classes and lanes; the hosting estate is on cloud and hosting. Paper 9 holds the full matrix at /research/data-classes-processing-lanes-and-roles/#sec-5-1.
Design shape versus run-time trust: agency class, action scope and the autonomy ladder
| Agency class (Book 2 Ch 22) | Paper 1 notation | Who decides the next step | Unit of testing |
|---|---|---|---|
| 0: single call | A0 | Code | Output |
| 1: grounded answer | A1 | Code | Output (plus indirect-injection exposure through documents) |
| 2: workflow | A2 | Code | Output |
| 3: bounded agent | A3 | The model | Trajectory |
| 4: multi-agent | A4 | Models, code, or both; defined by separate owners and identities | Trajectory per agent, plus inter-agent controls |
The two sources agree on agency classes. They differ on action scope, and this reference keeps the difference visible:
| Action scope (Paper 1, section 4.4) | Autonomy ladder rung (Book 2 Ch 22 section 4.3) | Virtual CAB autonomy level (Book 1 App D) |
|---|---|---|
| Read-only | Advisory | Advisory: the CAB recommends, humans decide |
| Draft (a human sends) | Advisory | Advisory |
| Act with approval | Controlled execution | Controlled execution: executes in a narrow band, humans review |
| Act autonomously within a defined envelope | Autonomous standard-change | Autonomous standard-change: pre-approved changes with full AES enforcement and after-the-fact human review |
- Paper 1 treats action scope as its own field in the classification code.
- Book 2 says it is not a third scale but the autonomy ladder seen at design time, and its classification line has no action-scope field.
This reference follows Book 2 for the classification line and uses action scope only as the design-time ceiling on the ladder. That ceiling is what Paper 9’s permission matrix caps by data class: C4 data caps action at draft. Both sources agree that the class does not grant the scope. An agency-class-3 design can run at the advisory rung, and every widening is earned on recorded evidence and withdrawn on failure.
The classification line and the classification code
| Book 2 classification line (Ch 22 section 5.4) | Paper 1 classification code (section 4.5) |
|---|---|
| Anatomy tier | Layer, combined with pattern as layer / pattern |
| Pattern family | (inside the first field) |
| Agency class | Agency class |
| (no field; autonomy ladder) | Action scope |
| Risk tier | Risk tier |
| Data class | Data class |
| Reuse generation | Reuse generation |
Paper 1’s example code reads L3/WF-ROUTE | A2 | Draft | Tier-2 | C3 | G3. Paper 9 proposes writing the data class with flag suffixes (C3+P, C4+S) and says this notation is a suggestion, not established practice. Human roles (supervisor, annotator, feedback provider) sit beside the code in the manifest, not inside it (Paper 1). The reference records the six-value Book 2 line in the BOM; see BOM and recipes and choosing a product shape.
Data classes across four sources
| Paper 9 code | Book 2 (Asset Manager X example, Ch 22) | Book 3 data labels (Appendix G) | AES v0.1.0 data[].classification enum |
|---|---|---|---|
| C1 Public | Public | Public | public |
| C2 Internal | Internal | Internal | internal |
| C3 Confidential | Confidential | Confidential (non-customer, customer non-financial, customer financial) | confidential |
| C4 Strictly confidential | Strictly confidential | Restricted; Strictly Confidential | restricted? (see note) |
| (flag: regulated records) | (flag: statutory-retention records) | (none) | regulated |
Note on mapping. Paper 9 and Book 2 use the same four level names, so the first two columns align on source evidence. No source maps the Book 3 labels or the AES enum onto C1–C4. Book 3 uses Restricted and Strictly Confidential as two distinct levels. The AES enum has restricted and regulated but no strictly_confidential, and its regulated reads like a category rather than a confidentiality level. The question marks are therefore this page’s reading, not a source mapping. Recommendation: record the firm’s mapping from its own scale to the AES enum once, in the data catalogue, with the data owner’s sign-off. Do not let each producer choose. The AES example record labels every dataset regulated. The canonical treatment, including Book 1’s agent-readable data dictionary scale (data_classification: public, internal, confidential, restricted, with sensitivity tags) and the composite Bank A five-tier refresh, is on data classes and lanes. That page makes the same recommendation: map C1–C4 to the first four AES values and decide explicitly whether regulated carries the R flag.
| Flag | Paper 9 (five flags, suffix letter) | Book 2 Ch 22 (four flags) |
|---|---|---|
| Personal data | P | Personal data |
| Sensitive personal data | S (handled at least as C4) | not listed separately |
| Client-identifying data | K | Client-identifying data |
| Inside information | I | Material non-public information (MNPI) |
| Regulated records | R | Statutory-retention records |
A flag can tighten the handling of its class but never loosen it (Paper 9 section 3.2). Where a page needs sensitive personal data treated separately, it follows Paper 9’s five flags.
Risk tiers
Book 3 Appendix G gives the five-tier scale this reference uses when it needs concrete tiers. Book 2 and Paper 1 both say the risk tier is the institution’s own classification and do not fix the scale.
| Tier | Book 3 name | Approval body (Book 3 App G) |
|---|---|---|
| T0 | Personal productivity with public or low-sensitivity data | Line manager at on-boarding |
| T1 | Internal knowledge assistance | Agent Control Board notification |
| T2 | Controlled operational assistance; the first tier with a registered agent and a named wrangler | Agent Control Board full approval, with the envelope, evaluation-suite plan, confirmed identity pair and signed RACI |
| T3 | Regulated process support; every output crossing the agent’s boundary has a named human approver | Agent Control Board with a named second-line signatory; AI Steering Committee notification |
| T4 | Material autonomous action; out of scope, and Book 3’s default answer for the next twelve months is no | Executive committee with board notification and CRO and CEO sign-off, where an exception is pursued at all |
Risk tier is independent of data class. A credit model on pseudonymised data can be high-risk, and a summariser of strictly confidential board papers need not be (Paper 9 section 10). Control packages, re-tiering triggers and the tier-to-regulation mapping are on risk tiers.
Reuse generations, recipes and “blueprints”
| Paper 1 | Book 2 reuse generation | What the next consumer does |
|---|---|---|
| G0 | Ad hoc | Rebuilds it |
| G1 | Shared code | Imports it |
| G2 | Platform service | Calls it |
| G3 | Composable capability | Binds to it |
| G4 governed blueprint | Governed recipe | Fills in parameters and runs a pipeline |
Three different things are called “blueprint” in the sources, so keep them apart:
- A governed blueprint (G4, Paper 1) is what this reference calls a recipe.
- A solution archetype (Paper 2) is what this reference calls a recipe family: one of ten recurring product shapes.
- Azure Blueprints is a Microsoft product that Book 2 Appendix B records as being retired, with Deployment Stacks and Template Specs as the named successors. The retirement timeline was checked against Microsoft Learn on 14 November 2026 and is recorded on landing zone; see primary sources for the page read. A recipe that names a product in a slot should let that product be swapped without rewriting the recipe.
Neither Paper 1 nor Book 2 promotes an asset automatically. A second consumer or a third recurrence opens a judgement by the people who will own the result; it does not mint a platform service.
Gateways, brokers and planes
| This reference | Book 1 | Book 3 | Paper 1 | What it controls |
|---|---|---|---|---|
| Model gateway | AI gateway | LLM gateway (Azure API Management at the composite Bank A) | AI gateway | Every model call: identity per caller, routing by data class and pinned version, quotas, cost and prompt logs |
| Tool broker | (part of the AI gateway) | Connector broker | (integration patterns) | Every tool and MCP call: registration, allow-list, per-agent authorisation, audit |
| Agent gateway | none | none | none | Agent-to-agent delegation, mutual authentication, egress to partner agents (Book 2 Ch 26) |
| Enterprise agent control plane | Same, six planes | Same, six planes | none | Identity, registry, policy, observability, approval and evidence as one substrate |
Book 1’s AI gateway covers model calls, tool calls, MCP invocations and retrieval in one control point. Book 2 splits that into a model gateway, a tool broker and an agent gateway. These are layers of the same control, not competing designs. This reference describes them separately because they have different owners and failure modes.
The nine audit questions: specification versus Book 3
The published Audit Evidence Schema v0.1.0 and Book 1 Appendix B ask: who initiated; which agent executed; under what envelope; what action; on what data; with which model; approved by whom; when; with what outcome. Book 3 Appendix E words its nine questions differently and splits them in another place. This reference follows the specification. Book 3 Appendix E itself says the specification wins where the two disagree. The mapping below is this page’s reading of where each Book 3 question lands in the schema.
| Book 3 question (App E section 2) | Lands in AES v0.1.0 |
|---|---|
| Q1 Who or what initiated? | initiator |
| Q2 Which agent, model, prompt and tool chain? | executing_agent (including system_prompt_version, system_prompt_sha256), model[], envelope_snapshot.means.tools |
| Q3 What data sources? | data[] |
| Q4 What decision, recommendation or change? | action, outcome.output |
| Q5 Was human approval required? | approval.required |
| Q6 Who approved or rejected? | approval.approvers[] |
| Q7 Which policy checks passed or failed? | approval.policy_decision_id, approval.policy_version, approval.rationale |
| Q8 What evidence was stored, and where? | outcome.evidence_pointers[] |
| Q9 How can the action be reconstructed? | No field; a rehearsed procedure (Book 3 App E section 6) |
| (no Book 3 question) | envelope_snapshot (Mandate, Means, Memory, Monitoring at action time), time |
Two practical consequences follow. A Book 3 “approval queue record” feeds approval, not a separate schema. And when a Book 3 reconstruction drill asks for Q9, it is testing the query path and retention, which the schema cannot evidence alone. See audit evidence.
Book 09 plain language
Book 09 deliberately avoids the series’ coined terms. When a page cites it, read its phrases as follows. This crosswalk is this page’s interpretation.
| Book 09 phrase | Series term | Treated on |
|---|---|---|
| The named owner of each agent | Agent wrangler | Accountability |
| The architect who owns the standard designs and recipes | Pattern arbiter | Recipe catalogue |
| The operator of the agent fleet | The seventh of Book 2’s seven names (governs the fleet) | Running the factory |
| The seven seats | The seven names | Running the factory |
| The routing gate and its line | A scored change gate (Book 2’s Change Risk Index) and its auto-approval threshold | Change governance |
| The band; the limit on the pace of change | Control budget | Control budget |
| Control values | Every tolerance, threshold and limit that decides what a client sees, kept on one list that the second line signs as complete | Policy, audit and actuals |
| One evidence record | Audit Evidence Schema and audit spine | Audit evidence |
| A single door in front of every model call | Model gateway | Model gateway |
| A common starting point | Standard application foundation | Application foundation |
Book 1 chapter numbers cited from other books
Book 2 and Book 3 cite different Book 1 chapters as the origin of the same terms. Examples: the wrangler (Book 1 Ch 12 in Book 1 App D and Book 2; Ch 14 in Book 3), the Audit Evidence Schema (Ch 11 versus Ch 14), the Virtual CAB (Ch 17 versus Ch 20), the agent-readable data dictionary (Ch 16 versus Ch 19) and the model usage registry (Ch 14 versus Ch 16). The definitions agree; the chapter numbers reflect different manuscript drafts. This reference cites Book 1 chapter numbers as given in Book 1 Appendix D.
Glossary
The “Treated on” column links only to pages of this reference. A dash means no page treats the term in depth yet.
Accountability and governance bodies
| Term | Definition | Source | Treated on |
|---|---|---|---|
| Agent wrangler (wrangler) | The named, accountable human owner of one agent’s behaviour. Authors the mandate, approves means and memory rules, configures monitoring, signs the periodic attestation and the decommissioning record, and is reachable for suspension. An agent whose wrangler does not resolve to an active identity is not instantiated. Book 1 notes that Microsoft’s agent-sponsor workflow maps to the role [FACT-CHECK: current Entra ID Governance sponsor capability]. | Book 1 App D; Book 2 App A; Book 3 App J | Accountability, Agent lifecycle |
| Product team | Book 2: the durable, cross-functional team (business, security, development, operations, risk) accountable end to end for a product’s recipe, BOM, controls and evidence. Book 3: the line-of-business team that owns the workflow an agent serves, distinct from the wrangler and from platform engineering. The reference uses Book 2’s meaning and names the line-of-business owner explicitly where Book 3’s split matters. | Book 2 App A; Book 3 App J | Accountability |
| Pod | A working unit of seven to nine people operating an agent swarm inside a product team. The product team is the unit of accountability; the pod is the unit of work. | Book 2 App A | Running the factory |
| Seven names | The closed set of named owners a factory needs: a wrangler for every agent, a roadmap owner, a pattern arbiter, a named person behind each product’s intent, spec and operation, and an owner for the fleet. An empty seat means the firm is running a pilot. One person may hold two seats in a small firm if that is written down. | Book 2 App A; Book 09 closing | Running the factory |
| Pattern arbiter | The factory architect acting as sole owner of the taxonomy, the pattern catalogue and the recipe families. Records additions, retirements and trade-off changes in ADRs, and reviews them at least annually. A role, not a board. | Book 2 App A, App C | Recipe catalogue |
| Adoption lead | Reads usage telemetry after go-live and drives how a shipped solution changes to fit real use. | Book 2 App A | Running the factory |
| AI Platform Owner | First-line head of engineering for the Claude platform end to end: routes, gateway, MCP broker, workstation managed settings, embedded-agent runtime, classification integrations and evidence pipeline. | Book 3 App J | Factory model |
| Agent Control Board (ACB) | The working-level body that approves agents into production at T2 and above. Its evidence pack centres on the envelope, the tier classification, evaluation results and the human-oversight design. Book 3 sets a monthly cadence. | Book 3 App J | Change governance, Agent lifecycle |
| AI Steering Committee | The executive body owning risk appetite, the prohibited-use list, funding, the control-plane roadmap and executive exception approvals. Book 3 sets a quarterly cadence. | Book 3 App J | Accountability |
| Three lines of defence | First line operates the controls (business and platform); second line challenges (risk, compliance, model risk, DPO, CISO); third line, Internal Audit, tests design and operating effectiveness independently. | Book 3 App J, App F | Accountability |
| Named accountability | Accountability enforced at run time: the registry, gateway and detection rules refuse to work without a resolvable, current owner. | Book 3 App J | Accountability |
| Prohibited-use list | A short, executive-approved list of use cases declined whatever the controls. Settled before any use case is tiered. | Book 3 App J | Risk tiers |
Envelope, zones and autonomy
| Term | Definition | Source | Treated on |
|---|---|---|---|
| Bounded agency | The four-part envelope an agent operates under: Mandate (what it may do, and for whom), Means (tools, models, MCP servers and systems it may use), Memory (state it may read and write), Monitoring (how it is observed, evaluated and suspended). The four parts carry equal weight. Book 1 presents it as the operational form of OWASP’s Least Agency and Strong Observability. | Book 1 App D; Book 3 App J | Bounded agent |
| Envelope (agent envelope, bounded-agency envelope) | The registered, machine-readable record that instantiates bounded agency for one agent. The wrangler signs it at registration. It is snapshotted into every AES record (envelope_snapshot) and re-attested at review. The runtime reads it at start-up, the gateway on every call. | Book 1 App D; Book 3 App D, App J | Agent lifecycle |
| Envelope ID | The unique, immutable identifier of an envelope in the registry. Book 3’s runtime refuses to start, and its gateway refuses to forward, without it. | Book 3 App J | Agent lifecycle |
| Four-zone agent model | Agents are placed in one of four operating zones: development (no production data), diagnostic (read-only on production), remediation (controlled write in a bounded scope), privileged-incident (high-trust, time-bounded, narrow purpose). Zones are enforced through identity scoping and group membership. The AES executing_agent.zone enum uses exactly these four values. | Book 1 App D; Book 3 App J; AES v0.1.0 | Agent lifecycle, Identity and secrets |
| Agency class | A design-time property: who decides the next step. Classes 0 to 4; see the crosswalk above. | Book 2 Ch 22; Paper 1 | Choosing a product shape |
| Autonomy ladder | Run-time trust in three rungs (advisory, controlled execution, autonomous standard-change). It is granted per agent, per runbook and per domain on evidence from the audit spine, and withdrawn on first failure. Distinct from agency class. | Book 2 App A, Ch 22 | Agent lifecycle |
| Action scope | Paper 1’s four-value scale (read-only, draft, act with approval, act autonomously within an envelope). This reference uses it as the design-time ceiling on the autonomy ladder. | Paper 1 section 4.4 | Choosing a product shape |
| Least-agency rule | Choose the lowest agency class that meets the need. Justify every step up in an ADR that names the rejected lower classes. | Book 2 App A, Ch 22 | Choosing a product shape |
| Cut-set review | For class 3 and class 4 designs, the ADR question: can a single control failure let the agent act outside its mandate? A yes is a finding. | Book 2 App A | Bounded agent |
| Loop-escape condition | Every agent loop has a way out: a counter, a time limit, an operation limit, or a rule that routes faults code cannot fix to a human. | Book 2 App A | Bounded agent |
| Translocation | Moving work between agentic and procedural forms on evidence. A stable hot path is codified down into a workflow; exceptions are delegated up to an agent starting on the advisory rung. | Book 2 App A | Workflow |
| Suspension mechanism | Book 3’s three-layer containment: wrangler level (minutes), gateway level (seconds) and organisational (rehearsed). | Book 3 App J | Incident response, Evaluation and resilience |
Five words to keep apart
Book 2 Chapter 22 section 4.5 asks the firm to give five words one meaning each. Conflating them creates ownership disputes and contract errors.
| Word | What it does | Owner and record |
|---|---|---|
| Model | Computes: turns an input into an output. Stateless between calls; no tools, no memory; cannot act. | Platform model team; the model catalogue records that it exists, the model usage registry records its use over time. |
| Agent | Decides and acts: a model directs its own control flow inside an envelope, choosing tools, parameters and when to stop. Its parts are a model, instructions, tools, state, a runtime loop, an identity, an envelope and a named human. Not a legal person; accountability sits with the wrangler. | Wrangler; agent registry. |
| Tool | Executes: deterministic code behind a typed interface with real permissions. Classified by effect: read-only, draft, reversible write, irreversible action. | Owner of the system behind the tool. Where the tool is an MCP server, it is listed on the catalogue’s MCP-server shelf (Book 2 App A). |
| Vendor | Supplies. The developer of a model and the host of a model can be different parties. For an open-weight model the developer never sees the firm’s data. The split matters for the ICT third-party register and for outsourcing assessments. | Procurement and third-party risk; see regulatory map. |
| AI system | Everything around the model: prompts, retrieval, tools, guardrails, interface, logging. It is the unit the EU AI Act regulates and the unit put into production, never “the model”. | Product team; see regulatory map. |
The same section distinguishes three paths by which code reaches execution. A path says who wrote the code and how it came to run; a hosting route says where a request is processed.
| Path | Default trust | Minimum controls |
|---|---|---|
| Pre-authored tool code | Trusted as production software | Normal change management, typed parameters, input validation, least-privilege service identity, per-call logging |
| Agent-generated runtime code | Untrusted by default | Runs in an ephemeral sandbox with CPU, memory and time limits; egress only to allow-listed destinations; secrets never mounted; mounts read-only and restricted to the task’s data class; the code and its output retained as evidence; the result validated before anything uses it |
| Agent-authored code for deployment | Untrusted until reviewed | Human-reviewed pull request with tests, scans and contribution gates; the agent’s identity recorded as author; protected branches never pushed to directly |
Generated runtime code is promoted to a scheduled or production script only by way of the third path. Browser and computer-use actions count as the second path: a sandboxed session, allow-listed sites and no stored credentials.
Design, classification and composition
| Term | Definition | Source | Treated on |
|---|---|---|---|
| Application anatomy | The tiers one AI application is made of: infrastructure and hosting; data and knowledge; models; reasoning and orchestration; integration and interoperability; experience and channels. A trust-and-operations plane crosses all of them. | Book 2 App A, Ch 22 | Application anatomy |
| Pattern family | One of eight groups describing how a capability is built, with catalogue codes: model interaction (MI), knowledge and grounding (KN), model adaptation (AD), workflow (WF), agent (AG), multi-agent (MA), integration and interoperability (IN), and trust, governance and operations (TR). Try MI first, then KN, then AD. | Book 2 App A, App C; Paper 1 section 4.2 | Recipe catalogue |
| Classification line | The six values on a product’s BOM that give every asset an address: anatomy tier, pattern family, agency class, risk tier, data class, reuse generation. Search, policy-as-code and the pattern arbiter all read it. | Book 2 Ch 22 section 5.4 | BOM and recipes |
| Risk tier | The institution’s classification of a use case that selects its control package. T0–T4 where the Book 3 scale is adopted. | Book 3 App G, App J; Book 2 App A | Risk tiers |
| Data class | How much harm follows if information reaches the wrong party. C1–C4, plus flags that can only tighten handling. | Paper 9 section 3 | Data classes and lanes |
| Hosting route (processing lane) | Where a request may be processed, decided per request by the highest data class among its inputs. See the crosswalk. | Book 2 App A; Paper 9 section 4 | Data classes and lanes, Cloud and hosting |
| Reuse generation | A per-asset attribute recording how shareable an asset is (G0–G4). It is not an organisational maturity score. | Book 2 App A; Paper 1 section 4.3 | Recipe catalogue |
| Bill of material (BOM) | The structured record of what a product contains: dependencies, artefacts, identities, data classes, controls, configuration and vendor components. Evidence of composition. | Book 2 App A | BOM and recipes |
| Recipe | The structured record of how a product is assembled, governed, released and evidenced. A contract: the platform provides the components and the product team uses them. Evidence of assembly. | Book 2 App A | BOM and recipes |
| Recipe family | One of ten recurring AI product shapes, each a pattern composition with its policy pack, evaluation signals, templates and anti-patterns. A new request starts from the nearest family. Paper 2 calls these solution archetypes. | Book 2 App A; Paper 2 | Recipe catalogue |
| Release manifest | The BOM extension that pins what was tested together: model and version, parameters, prompt version, orchestration, retrieval and index versions, tool versions and evaluation results. The pinned combination is the unit of release. | Book 2 App A | Release engineering |
| Living spec | The BOM and recipe once agents consume them: a versioned, queryable record that can answer questions about its own history. | Book 2 App A | BOM and recipes |
| Policy pack | A pre-approved bundle of controls attached to a combination of agency class, risk tier and data class, and inherited by scope rather than attached per project. | Book 2 App A | Policy, audit and actuals |
| Standard application foundation | The governed baseline every new application receives before business logic: identity, secrets, configuration, telemetry, evidence and policy hooks. Teams may not edit it freely. Book 1 App D counts eighteen components; App F’s tables number fifteen components and eighteen shared capabilities (see the SDLC catalogue). | Book 1 App D; Book 2 App A | Application foundation |
| Foundation contract | For each foundation capability: what you get, what you may change, and what you must never bypass. Paired with the plumbing catalogue, the near-identical capabilities under business logic that the foundation provides once. | Book 2 App A | Application foundation |
| Paved road | An opinionated, supported, self-service path that teams choose because it is easier. Not published until its machine-readable form ships with it. | Book 2 App A | Landing zone |
| Promotion boundary | The crossing from prototype to production. The rule: promotion must be cheaper than evasion. | Book 2 App A | Application foundation |
| Readiness event horizon | The decay point past which agents cannot help repair a station, because it has no tests, no observability and no working build. | Book 2 App A | Agent readiness |
| Control inheritance rate | The share of a product’s required controls whose evidence comes from an inherited platform asset. | Book 2 App A | Running the factory |
Delivery artefacts
| Term | Definition | Source | Treated on |
|---|---|---|---|
| Two-speed SDLC | A loop measured in days and conversations (the human lane) and one measured in minutes and threads (the agent lane), joined at one committed artefact. | Book 2 App A | Agent-speed SDLC |
| Artefact chain | The committed artefacts that carry a change: intent.md, spec.md, plan.md, the diff and tests, the pull request and review findings, the release record and the monitoring record. The commit history is the audit trail. | Book 2 App A | Agent-speed SDLC |
Intent (intent.md) | The problem, outcome and constraints, in the originator’s words. Accepted or rejected by the product lead. | Book 2 App A | Agent-speed SDLC |
Spec (spec.md) | The testable requirements and design. It generates the tests that judge the build. | Book 2 App A | Agent-speed SDLC |
Plan (plan.md) | The implementation plan an agent writes read-only against the codebase. The wrangler approves it before code is written. | Book 2 App A | Agent-speed SDLC |
| Definition of ready (for an agent) | What a work item carries before an agent is dispatched: intent, runnable acceptance criteria, affected systems, data class, risk tier and approvals, constraints, and a named human approver. | Book 2 App A | Agent-speed SDLC |
| ADR and GIP | An Architectural Decision Record settles a decision. A Global Internal Practice is a direction teams stay within and may break deliberately. They are the two machine-readable governance instruments. | Book 2 App A | Agent-speed SDLC |
| Skills and hooks | A skill advises, making compliance likely. A hook, permission rule or pipeline check enforces, making a violation impossible. Anything that must be evidenced to a supervisor belongs in the enforcing layer. | Book 2 App A | Agent-speed SDLC |
| Automation factory | The engine that turns recipes into product skeletons and control evidence. Seven jobs: scaffold, provision, configure, register, publish, upgrade, and inject catalogue context. | Book 2 App A | Factory model |
| Controls that execute | Controls enforced by machinery at the moment of change: in the pipeline, at run time, at release and at registration. An unregistered model, agent or tool gets no credential and no route. | Book 2 App A | Control map |
| Golden record | A versioned, owned input–output pair verified by a subject-matter expert and classified like the data it holds. Used for examples, regression and trajectory evaluation. | Book 2 App A | Evaluation and resilience |
| Failure-mode register | A per-product file kept beside intent.md and spec.md. It scores each failure mode on severity, occurrence and detection, and is re-scored when the release manifest changes. | Book 2 App A | Release engineering |
Change and release
| Term | Definition | Source | Treated on |
|---|---|---|---|
| CAB | Change Advisory Board: the body or mechanism that decides go or no-go on a change. In the Supporting Tools its input and output are the cab_change and cab_decision schemas. | Book 2 App A; Supporting Tools | Change governance, Schemas and tools |
| Virtual CAB | Eleven specialist agents produce a seventeen-field Change Dossier per change; a named human chair reads it. Three autonomy levels (see the crosswalk). Book 3 also describes it as the cross-line body for changes to agents already in production (model upgrades, prompt revisions, MCP changes, autonomy and threshold changes), meeting weekly or on demand. | Book 1 App D; Book 2 App A; Book 3 App J | Change governance |
| Change Dossier | The seventeen-field structured input humans approve: description, risk class, evidence quality, reversibility, dependencies, approvals and rollback, plus the specialist-agent contributions. Carried by the CAB Decision Record schemas. | Book 1 App D; Book 2 App A | Change governance |
| CAB decision enum | go, go-with-conditions, no-go, needs-review, superseded. A chair’s refusal is a separate event kind, cab.refuse. | CAB Decision Record v0.1.0 | Schemas and tools |
| Change Risk Index (CRI) | A scored gate that routes a change to automatic approval, human review or escalation by predicted blast radius. Book 09’s “routing gate” is the same mechanism seen in operation. | Book 2 App A; Book 09 | Change governance |
| Control budget | An author proposal: a CRO-signed limit on how fast change may arrive relative to the firm’s capacity to understand it. Book 2 states it as a ratio of arrival to evidence-quality-weighted capacity; Book 09 operates it as a weekly per-domain share of arriving changes that left a full record, against a band the CRO signs, with the line owned and run by the CIO. Outside the band for two consecutive weeks: intake for that domain queues and no agent in it gains autonomy, without a meeting. Raw approvals per hour never count as capacity. Quarter-end widening is signed in advance, never self-granted. | Book 2 App A, Ch 24 §4.9; Book 09 Ch 12 | Control budget, Change governance |
| Control values | Every tolerance, threshold and limit that decides what a client sees, held on one list that the second line signs as complete. The gate’s line has one named first-line owner and a procedure for moving it. | Book 09 closing | Policy, audit and actuals |
| Model upgrade | A change in which the model identifier in an envelope’s Means changes. It runs through change control with an evaluation suite, a staged rollout and a rollback plan that keeps evidence portable. Book 3 Ch 16 runs it in four phases (see four-phase model upgrade below). | Book 3 App J | Model governance, Release engineering |
| Deployer Manifest | The schema that drives plan / preflight / apply / verify / rollback for one artefact. required_cab_decision is always present (null only with a cited exemption), health checks must be non-empty, and rollback verification is required. | Book 2 App A; Supporting Tools | Schemas and tools |
Evidence and the audit spine
| Term | Definition | Source | Treated on |
|---|---|---|---|
| Audit Evidence Schema (AES) | The nine-question record every material agent action emits, published as JSON Schema v0.1.0 at /aes/v0.1.0/audit_evidence_schema.json. Book 1 describes the nine questions as the smallest set whose answers cover the combined obligations on a regulated EU financial firm; that is an author claim. | Book 1 App B, App D; Supporting Tools | Audit evidence, Schemas and tools |
| Audit spine | Three normative records (AES, CAB Decision Record, Deployer Manifest), one wire format (the AES envelope) and two join keys (session_id, change_id). In the Supporting Tools documentation “the spine” also means the leaf, edge and centre topology. | Book 2 App A | Audit evidence |
| Leaf, edge, centre | Evidence is emitted and signed at the leaf (where the action runs), stamped and buffered per legal entity at the edge, and counter-signed and stored at the centre. | Supporting Tools; Book 2 App A | Enterprise control plane |
| Lake | The append-only, counter-signed, immutable system of record for the evidence stream. The SIEM consumes it for alerting but is not the record. | Book 2 App A | Audit evidence |
session_id / change_id | The two join keys. session_id groups one bounded unit of work; change_id groups every record belonging to one change. Both are required to reconstruct an action end to end. | AES v0.1.0; Book 2 App A | Audit evidence |
kind | The AES discriminator naming the record type, such as agent.action, cab.evaluate or deployer.apply. In v0.1.0 it is limited to two dot-separated segments; see the source inconsistencies on schemas and tools. | AES v0.1.0 | Schemas and tools |
| Correlation ID | Book 3’s single identifier issued at the gateway and carried end to end across gateway, hook, SDK and approval-queue records. Recommendation: map it to session_id, or carry it in initiator.session_ref, and record which choice was made in the producer profile. | Book 3 App E | Audit evidence |
| Policy / audit / actuals loop | The governance loop: policy states intent, actuals show reality, audit tests the gap. Automated wherever possible, human where judgement is needed. The audit spine makes the loop’s output queryable. | Book 2 App A | Policy, audit and actuals |
| Policy Decision API | The control-plane endpoint that returns an allow or deny decision with a rationale for a proposed action, citing the rule and policy version. This page reads AES approval.policy_decision_id as the identifier of such a decision; the schema itself does not name the API. | Book 1 App D | Enterprise control plane |
| Evidence dividend | The artefacts that make the factory operable double as the artefacts supervisors require: one investment, two returns. | Book 2 App A | Audit evidence |
| Evidence portability | An agent’s evidence stays queryable after a route change or vendor exit. Tested in the annual exit rehearsal by reconstructing sampled pre-migration correlation IDs, against a 15-item checklist. | Book 3 App J, App H | Vendor concentration and exit |
| Replay rehearsal | Book 3’s quarterly exercise to reconstruct a sampled action within the target time for its tier. It is the only evidence for its Q9. | Book 3 App E | Audit evidence |
Platform doors and registries
| Term | Definition | Source | Treated on |
|---|---|---|---|
| Model gateway | The single door for every model call: per-client identity instead of shared keys, quotas, routing by data class and pinned version, progressive delivery of prompt-and-model pairs, and the token, cost and prompt logs used for showback and audit. Run as a product with its own service levels. | Book 2 App A | Model gateway |
| Tool broker | The door between agents and tools. It authenticates, authorises each agent against the read-or-act line of each tool contract, enforces allow-lists and rate limits, and writes an audit record per call. It exchanges the agent’s identity for scoped access, so the agent never holds a system-of-record credential. It serves only catalogued tools. | Book 2 App A | MCP and connector broker |
| MCP server | A system of record or governed capability exposed to agents as tools under the Model Context Protocol. Rule: wrap once, at the right layer. One server per system, owned by the team closest to the system, reached only through the broker. | Book 2 App A; Book 3 App J | MCP and connector broker |
| Agent gateway and agent card | The agent gateway governs agent-to-agent delegation. An agent card is the A2A description of what an agent does and how to reach it. It describes capability, never permission, and is issued only for a registered agent with a wrangler. | Book 2 App A | MCP and connector broker |
| Grounding data API | The single door to grounding stores. It routes, applies tenant and user filters on every retrieval (including retrievals inside an agent loop), uses the caller’s identity and logs what was served. | Book 2 App A | Data, API and integration |
| Enterprise agent control plane | Identity, registry, policy, observability, approval and evidence integrated as one substrate in six planes. Book 1 names three primitives: a fourteen-collection persistence schema, the Policy Decision API and the AES. | Book 1 App D; Book 3 App J | Enterprise control plane |
| Model catalogue versus model usage registry | A catalogue (for example a cloud provider’s) records that a model exists. The firm’s model usage registry (eighteen fields in Book 1) records its use over time, per envelope and use case, and is the firm’s own documentation record. | Book 1 App D; Book 3 App J | Model governance, Model gateway |
| Agent-readable data dictionary | The seventeen-field record giving agents the meaning of data, not just its location, signed by the data steward. Field 8 names the master source that the Authority Process validates drafts against. | Book 1 App D | Data, API and integration, Authority process |
| Trust spine | Identity, secrets and configuration taken together; everything on the production line inherits their strength or weakness. | Book 2 App A | Identity and secrets |
| Agent identity, runtime identity, deployment identity | An agent has its own cryptographic principal, distinct from its wrangler, its workload and any developer. Runtime identity is what it uses to act. Deployment identity is what a pipeline uses to write to production. Keep all three separate. | Book 1 App D; Book 3 App J | Identity and secrets |
| Landing zone | The codified cloud foundation onto which workloads land. For agents it is extended with zone segmentation, gateway placement, a model platform and control-plane integration. Book 3 uses the term for its one-time build of eight components. | Book 1 App D; Book 3 App J | Landing zone |
Data handling and deployment routes
| Term | Definition | Source | Treated on |
|---|---|---|---|
| Processing lane | Paper 9’s name for a hosting route. It is fixed by two facts: who operates inference and who can see the data. Lane A is a vendor API, Lane B a vendor model in the firm’s cloud tenancy, Lane C controlled infrastructure. Assigned per model deployment and re-checked when the model version changes. The gateway derives the permitted lanes from class and flags; the lane is never stored on the application. | Paper 9 sections 4 and 10 | Data classes and lanes |
| Class × lane permission matrix | Paper 9’s default table joining each data class to the lanes it may use and to what may be done with it: prompts, indexes, agent memory, the action ceiling, sandboxed code, fine-tuning sets, log retention and development data. Enforced per request at the gateway. Risk and data owners sign the cell values; review them quarterly and on every class, route or vendor change. C4 is Lane C only (Lane B by explicit approval with customer-managed keys) and caps action at draft. | Paper 9 section 5.1 | Data classes and lanes |
| Derived-artefact rule | Embeddings, indexes, adapters and other artefacts built from data inherit the highest class among their sources, and may be served only where that class may go. | Paper 9 | Data classes and lanes |
| Zero data retention (ZDR) | A property of a configuration, not of a vendor: on each platform it holds only when a mode is set, a feature disabled or an approval granted, and some features take a call out of it. Keep a ZDR configuration record per deployment: route, organisation ID, enablement evidence, surfaces in and out, carve-outs, verification test, last verified date. | Paper 9 section 8.2; Book 3 Ch 4 | Data classes and lanes, Deployment routes |
| Tokenisation, masking, redaction, pseudonymisation, anonymisation | Five transforms to keep apart. Tokenisation can be reversed by whoever holds the map. It is a form of pseudonymisation, so the data stays personal data. Masking and redaction are not reversible in production. Only anonymisation takes data outside data-protection law. Book 1 puts a tokenisation gate in the path. It decides per invocation which fields go plain, tokenised or redacted, so there is no corporate default either way. | Book 1 Ch 13 | Data classes and lanes |
| Rehydration map | The table from tokens back to original values. It carries the class of the originals and is held inside firm-controlled infrastructure, never with the model vendor. | Book 1 Ch 13, as synthesised on the treating page | Data classes and lanes |
| Deployment route | One of the paths by which Claude reaches production: the Anthropic API, Claude Platform on AWS, Amazon Bedrock, Claude on Google Cloud (Google-managed or Anthropic-managed) and Microsoft Foundry, plus the Microsoft 365 Copilot surface, which arrives through an admin toggle rather than procurement. The route is a portfolio decision, taken per use-case class rather than once for the firm. | Book 3 Ch 4, App A; Anthropic documentation read 15 Nov 2026 | Deployment routes |
| Contracting matrix | One signed row per use-case class. It records the route; the operator, biller, data processor and contracting entity; residency; the ZDR and HIPAA position per feature; and the transfer basis. Procurement and the second line co-sign it, and it feeds the Register of Information row. | Book 3 Ch 4 (PR-2) | Deployment routes |
| Managed policy and lock flags (Claude Code) | One version-controlled managed settings document per surface, delivered to the device, plus managed hooks. The allowManaged*Only lock flags stop rules from lower scopes merging into it. As of November 2026, per Book 3 Ch 8; the key names are an open check on the treating page. | Book 3 Ch 8 | Coding-agent workstation |
| Guidance versus control | An instruction file or a skill guides, and the agent can ignore it. A permission rule, a command hook or a pipeline check controls. On the workstation, command hooks enforce and HTTP hooks only carry evidence. | Book 2 App A; Book 3 Ch 8 | Coding-agent workstation, Agent-speed SDLC |
Models, vendors and exit
| Term | Definition | Source | Treated on |
|---|---|---|---|
| Model usage registry row | Eighteen fields describing one use of one model in one business process. Three carry the weight. business_process (field 6) is what makes a model call a regulated usage, and it must be specific. regulatory_class (field 8) is assigned per usage and never inherited from the model. owning_wrangler (field 14) is a named person, not a team. Book 3 Ch 16 adds a second, upgrade-oriented row as a lifecycle layer. | Book 1 Ch 14; Book 3 Ch 16 | Model governance |
usage_id | The registry key. The policy decision point reads it to answer “may agent X invoke usage U now?”, and every model invocation logs it, so one log line serves AI Act traceability and DORA incident work. | Book 1 Ch 14 | Model governance |
| Four-phase model upgrade | Book 3’s lifecycle, anchored to the public release (Day 0). Watch and pre-evaluation: Day −14 to 0. Decision and staging: Day 0 to +30, Virtual CAB sign-off. Production observation: Day +30 to +90, with a Day +60 re-run and attestation. Retention or rollback: Day +90, Agent Control Board. Rollback runs on named numeric thresholds. | Book 3 Ch 16 | Model governance, Release engineering |
| Pinned model ID and alias drift | Production envelopes name the full model identifier. A short alias can resolve to different models on different routes and can change over time, so a call through an unpinned alias is an unrecorded model change. | Book 3 Ch 16, Ch 18 | Model governance |
| Concentration axes | Three separate measures, each with its own threshold and lever. Vendor concentration is the share by data processor, not by invoice. Model concentration is the share by model class and version. Substrate concentration is the share by region of inference. | Book 3 App H section 2 | Vendor concentration and exit |
| Concentration triggers (70% and 85%) | Author proposals. Above 70% on one data processor, measured on tokens, cost or envelope count, opens a discussion at the AI Steering Committee; above 85% it goes to the management body. Book 1’s multi-cloud theatre test is a different measure: a multi-cloud claim is theatre when more than 80% of criticality-weighted agent workload sits on one hyperscaler. The two are layers, not rival numbers. | Book 3 App H; Book 1 Ch 10 section 8 | Vendor concentration and exit |
| Contract-cleavage points | Eight things to record per route. Together they decide how cleanly the firm can suspend or leave it: contracting entity, termination notice, termination for cause, data return and deletion, sub-processor exit, suspension versus termination, designated-provider status, and the Register of Information fields an exit would change. The executed agreement is authoritative, not the public terms. | Book 3 App H section 3 | Vendor concentration and exit |
| Exit rehearsal | An annual, briefed exercise on one material use case, in seven steps: select, scope, brief, execute in non-production, evidence-portability check, operational-continuity check, close-out. Material means any of: Tier 2 or above, CIF support, more than 100 active users, or more than €100,000 annual run-rate. A full vendor change is rehearsed as a table-top exercise only. | Book 3 App H | Vendor concentration and exit |
Records, incidents and suspension
| Term | Definition | Source | Treated on |
|---|---|---|---|
| Draft versus record | Generative output is never an authoritative record. Book 1 gives eleven pairs: AI may produce the draft side, such as an explanation, but only the firm’s governance produces the record, such as the decision. Drafts are labelled and cite their sources. | Book 1 Ch 16 section 4.4 | Authority process |
| Authority Process | The single owned path, one per record class, that turns a draft into a record. It has eight steps: (1) validation against the master source; (2) business-rule checks; (3) data-quality checks; (4) reconciliation; (5) explicit approval by a named human with a written rationale; (6) immutable audit logging; (7) versioning and posting through a write API that only the process may call; (8) a separation-of-duties check that the approver is not the wrangler of the agent that drafted. Skipping a step is a control failure. | Book 1 Ch 16 | Authority process |
| Four incident shapes | Wrong answer used as fact; unauthorised action; data leak; unavailability. The shapes are mutually exclusive at first triage. Re-assess at each bridge, because one shape can turn into another. Each shape has its own first suspension layer and its own notification streams. | Book 3 Ch 17 | Incident response |
| Monday-morning test | The first triage question: was the agent inside its envelope? The on-call lead should be able to pull up the envelope and decide in under two minutes. | Book 1 Ch 2 section 7 | Incident response |
| One playbook, several cover sheets | Agent incidents run through the firm’s existing ICT incident process, not a parallel “AI incident” process. One detection, response and evidence path produces a separately templated, separately addressed report for each regime the incident triggers. | Book 1 Ch 6; Paper 2 section 5.10 | Incident response |
Measuring the factory
| Term | Definition | Source | Treated on |
|---|---|---|---|
| Seven-dimension scorecard | Flow, quality, resilience, security, evidence, developer experience and value. The first six describe how the factory runs, and they exist to explain the seventh. Each has a measure the agent era adds, such as review latency by team or evidence completeness for AI-assisted change. | Book 2 Ch 17 section 4 | Factory measurement |
| Served-request event | One event emitted whenever a shipped capability does its job, built into the standard foundation. It carries the capability, the caller, the caller type (a person, or another agent or system) and the model cost, plus the time and an agreed outcome proxy where one exists. Usage is the first gauge to move. | Book 2 Ch 17; Book 09 Ch 10 | Factory measurement |
| Evidence tier | The label every reported number carries: (1) independently attested; (2) institutionally measured by the firm’s own systems; (3) estimated with visible formulas; (4) vendor self-reported. Only tier 2 drives a decision. Tier 1 is citable. Tiers 3 and 4 never carry a budget decision. | Book 3 Ch 20 section 5.1 | Factory measurement |
| Shipped-unused balance and patience runway | Two author models. The balance is a standing line listing shipped capabilities that nobody uses. Each entry is decided as hold, fix or write down, with an owner and a date, and the line is run as an impairment review. The runway is the number of quarters of board patience left at current burn and demonstrated value. | Book 2 Ch 17 section 5 | Factory measurement |
| Validated-intent lead time and intent coverage ratio | The discovery-side pair. The lead time runs from a problem entering discovery to a complete bet card admitted to the agent lane, and it ends where intent-to-production lead time starts. The ratio is validated intent admitted per period over agent-lane capacity consumed per period, both in one unit. | Book 2 Ch 21 section 5 | Factory measurement |
| Two leading numbers of the control gap | Pulled weekly: the median wait of open pull requests for review, and the share of approvals on changes over twenty files that carry no review comment. | Book 09 Introduction and Closing | Factory measurement |
| Agent-to-wrangler ratio | The warning sign is agent count rising faster than wrangler count. Book 1’s sizing gives every agent one named wrangler, and no wrangler holds more than five to seven agents. | Book 1 Ch 1 | Factory measurement, Accountability |
Adoption, sourcing and the department
| Term | Definition | Source | Treated on |
|---|---|---|---|
| Portfolio threshold (8 / 24 / 3) | A written line, signed before the first platform hire: at least eight products over twenty-four months on at least three genuinely shared patterns, one of them shared data. Below the line, every build verdict becomes “buy, and buy better”. It is an author model, not an industry figure. | Book 09 Ch 3 and Closing; Book 2 Ch 27 | Build, configure, consume, Implementation roadmap |
| Four sourcing gates | Paper 7’s decision for one capability, taken in order: differentiation, agent-operability, ceilings and exit, honest return. The outcome is consume, keep at arm’s length, configure, or build as code. | Paper 7 section 9 | Build, configure, consume |
| Five sourcing dimensions | Book 2’s scoring for contested cases: data gravity, integration surface, regulatory posture, total cost of ownership and exit cost, with the last two weighted double. It is used inside the fourth gate and in the annual sort. | Book 2 Ch 25 | Build, configure, consume |
| Renewal book | The annual sort of every application the firm pays for per seat, into three lists. Stays bought. Flips: thin SaaS whose only moat was the old cost of building; a build candidate only above the threshold. Contested: score it, and often split it. | Book 2 Ch 25 section 7 | Build, configure, consume |
| Factory charter | The one ratified document holding mission, mandate and decision rights, operating principles, ordered values and governance commitments. Each value has an owner, a policy, a metric and a veto. | Book 2 Ch 18; Paper 5 | Factory charter |
| Two-compiler test | Every charter value must compile twice: into a human consequence (a hiring criterion, a promotion input or a named veto) and into a machine consequence (a policy rule, a gate or a stop condition). A value that compiles into neither is deleted. One that compiles into one side only is marked half-built. | Book 2 Ch 18 section 5.2 | Factory charter |
| Trust ledger | Trust held as four positions: with business sponsors, with the firm’s engineers, with the supervisor and with clients. Each is built and lost on its own clock. Read it from existing instruments rather than building a new one. | Book 2 Ch 18 section 4.4 | Factory charter |
| Revealed values | What the actuals show the firm values, set against the values its policy states. Audit measures the gap every quarter. | Book 2 Ch 18 section 7; Paper 5 | Factory charter, Policy, audit and actuals |
| Roadmap phases | The synthesised build sequence over about eighteen months, with overlapping phases: On-ramp, Foundation, Identity and Network, First Bounded Agents, Control Plane, Scale-out, Continuous Operation. Each phase has entry conditions, exit evidence and a “not yet” list. The roadmap is a dependency graph, not a calendar. | Book 1 Ch 18–19; Book 2 Ch 27, crosswalked on the treating page | Implementation roadmap |
| Tranche funding | The eighteen-month envelope is split into three tranches. Each is released against a phase’s exit evidence, on the audit committee’s calendar, never against a date. | Book 1 Ch 18 section 3; Book 2 Ch 27 section 4.4 | Implementation roadmap |
| Four signed trade-offs | Calibration choices the CIO signs and the CRO countersigns during Foundation: the number of zones, how the control plane is built, the autonomy ambition and the modernisation scope. If the CRO refuses, the choice is redrafted, not the risk appetite. | Book 1 Ch 18 section 5.2, Ch 19 section 7 | Implementation roadmap |
| Readiness instruments | Four instruments at four altitudes, never averaged: the six-question CIO self-diagnostic (yes or no); the ten-pillar control-plane scorecard (0–60); station readiness (the lowest of four scores, 0–3); and the ten evidence-scored statements (0–20, read as pilot, building or running). | Whitepaper Part I; Book 1 Ch 1, Ch 5; Book 09 Closing | Readiness diagnostic |
| Agent-Driven Department | A department in which agents do a defined, measured share of the work under bounded agency. One department must own four properties together: bounded agency, a named wrangler per agent, evidence to the Audit Evidence Schema, and execution through one enterprise agent control plane. It is first-line engineering and operations, not a risk function and not a business unit. | Book 2 Ch 20; ADD proposal | Agent-driven departments |
| Measured agent share | The department’s stated number for how much of its work agents do. It need not be large, but it must be known, so that the handover from people to agents is managed on purpose. | Book 2 Ch 20 section 4.1 | Agent-driven departments |
| Six-system stack | The department’s six systems in five layers. Foundation: the Trusted Agent Execution Architecture. Knowledge: the AI Skills Library. Orchestration: the Wrangler Control Plane. Execution: the Solution Development and the Service Management agent swarms. Autonomy extension: the Event-Driven Autonomous Agent Framework. | Book 2 Ch 20 section 5; ADD proposal | Agent-driven departments |
| AI Skills Library and the graveyard failure | Standards, patterns and runbooks written as skills that agents execute, version-controlled beside code and evaluated continuously. The graveyard failure is a library seeded once and never maintained, so agents apply last year’s standards at speed. | Book 2 Ch 20 sections 5.1 and 8 | Agent-driven departments |
Regulatory anchors (definitions only)
These terms appear across the reference. Their legal definitions, article references, thresholds and dates are maintained only on the regulatory map (articles and obligations) and the regulatory calendar (dates and status). The official texts and their verification status are listed on primary sources.
| Term | Working meaning for practitioners | Source |
|---|---|---|
| CIF (critical or important function) | DORA’s tag for a function whose disruption would materially impair the firm. It decides the depth of obligations on the ICT systems and third parties that support it. Tag each AI system that supports a CIF in its BOM. | Book 1 App D; Book 3 App J |
| Register of Information | DORA’s register of ICT third-party arrangements, which distinguishes those supporting CIFs. Model vendors, hosts, MCP servers and SSO intermediaries may each need an entry. | Book 1 App D; Book 3 App J |
| TLPT | Threat-led penetration testing under DORA. Its scope can include AI agents in CIFs. | Book 1 App D; Book 3 App J |
| FRIA | The EU AI Act’s fundamental rights impact assessment for certain high-risk deployers. Book 3 records it as a conditional field on the envelope’s Mandate. | Book 3 App J |
| Sub-processor | In the GDPR sense, a party engaged by a processor. Book 3 treats every connected MCP server as one. | Book 3 App J |
| CTPP (critical ICT third-party provider) | An ICT provider the European Supervisory Authorities have designated under DORA for direct oversight. Designation status changes how an exit is sequenced with the supervisor, so it is one of the eight contract-cleavage points recorded per route. Which providers are designated is tracked on the calendar. | Book 3 App H, App I |
| Operator, biller, data processor, contracting entity | Four roles to record separately for every deployment route: who runs inference, who invoices, who processes the prompts and outputs, and which legal entity the firm signed with. The processor is never inferred from the bill. | Book 3 Ch 4, App A |
| Stop-the-press calendar | Book 1 App C’s list of moving regulatory items, with three questions asked whenever an item moves: does it change a citation in the control map, a deadline on the programme plan, or the practical Monday-morning answer? The reference runs it as the regulatory calendar and its change-trigger procedure. | Book 1 App C |
Supporting Tools
| Term | Definition | Source | Treated on |
|---|---|---|---|
| Supporting Tools | The work-stream that publishes the specifications, CLI, plugins and reference implementation, on its own release cadence. The books pin a floor version of the specification. | Supporting Tools README; Book 2 App A | Schemas and tools |
ops | The reference CLI: one binary with five subcommands (run, log, cab, deploy, chk) plus the doctor diagnostic and a shared library, ops-core. Designed, not yet implemented. | Supporting Tools CLI README; Book 2 App A | Schemas and tools |
| Conformance pack | A set of positive and negative test vectors, with expected outcomes, that a producer must pass to claim conformance to a specification version. Conformance is a release artefact, not a runtime check. | Supporting Tools spec/conformance | Schemas and tools |
Composite organisations
The sources make concrete claims through composites: fictional institutions built from patterns across real European regulated firms. They are not case studies of real firms. Any page that uses one labels it as a composite.
| Composite | As described in Book 3 Appendix J |
|---|---|
| Bank A | Frankfurt-headquartered universal bank under direct ECB supervision |
| Asset Manager X | Luxembourg-headquartered asset manager, CSSF-supervised |
| Insurer I | Munich-headquartered pan-European life and non-life insurer, BaFin- and EIOPA-supervised |
The example records hosted with the schemas use the reserved documentation domain bank-a.example for Bank A’s hostnames and user names. The Supporting Tools source files use other illustrative domains.
Source and status
Source claims: definitions restated from Book 1 Appendix D, Book 2 Appendix A and Chapter 22, Book 3 Appendices E, G and J, the Book 09 closing chapter, Research Papers 1, 2 and 9, and the Supporting Tools specification. The sections from Data handling and deployment routes to Adoption, sourcing and the department were added in the final pass (version 0.2.0). They restate terms that the pages written after the first glossary introduced, and each entry names the book chapter that page cites. Those entries were spot-checked against Book 3 Appendix H (the 70% trigger), Book 3 Ch 16 (the Day −14 phase start), Book 3 Ch 17 (the four shapes), Book 09 Ch 3 (the eight-product, twenty-four-month threshold), Book 09 Ch 12 (the two-week trigger) and Book 1 Appendix C (the three questions). The rest follow the treating pages, which hold the full citations.
This page’s synthesis: the vocabulary rules and every crosswalk table. Where a cell maps one source’s term to another and no source states that mapping, the surrounding text says so. This applies in particular to the Book 3 labels and AES enum in the data-class table, the Book 3 audit-question mapping and the Book 09 phrases.
Unresolved:
- AES
classificationvalues do not match any book’s data scale. A firm-level mapping is needed. - Book 1 chapter numbers differ between the books that cite them.
- The Bedrock and Google-managed processor statements in the hosting-route crosswalk have not been re-read against current vendor terms. The Foundry statement was re-read on 15 November 2026 and differs from Book 3 Appendix J; this page follows the newer sources.
- Open checks for every vendor and legal term used here are consolidated on primary sources.
Review trigger: a new edition of any cited glossary or appendix, an AES release beyond v0.1.0, a new reference page that introduces a term, or a change to any page linked from the “Treated on” column.
Source material
- Book 1, Appendix D, Glossary
- Book 1, Appendix B, Audit Evidence Schema
- Book 2, Appendix A, Glossary
- Book 2, Appendix B, Technology Choices Revisited, 2024 to 2026
- Book 2, Appendix C, The Pattern Catalogue (opening and vocabulary note)
- Book 2, Chapter 22, The Shape of an AI Product (sections 4.3, 4.5 and 5.4)
- Book 3, Appendix E, Audit Evidence Schema for Claude Actions (section 2)
- Book 3, Appendix G, Risk-Tier Control Matrix (section 2)
- Book 3, Appendix J, Glossary
- Book 09, Closing chapter, An Afternoon with a Pencil
- Research Paper 1, AI Reference Architectures and Design Patterns: A Taxonomy for a Reuse-Driven AI Factory (sections 4.3 to 4.5)
- Research Paper 2, Ten Solution Archetypes for Regulated Finance (section 2.4)
- Research Paper 9, Data Classes, Processing Lanes and Controller/Processor Roles for AI (sections 3 to 5 and 10)
- Supporting Tools, README, CLI README and Audit Evidence Schema v0.1.0
- Book 1, Chapter 1, The Adoption Gap (agent count against wrangler count), as treated on the factory-measurement page
- Book 1, Chapter 2, The Bounded Agency Thesis (the Monday-morning test), as treated on the incident-response page
- Book 1, Chapter 13, tokenisation gate and transforms, as treated on the data-classes-and-lanes page
- Book 1, Chapter 14, the model usage registry, as treated on the model-governance page
- Book 1, Chapter 16, the Authority Process and the draft-versus-record pairs, as treated on the authority-process page
- Book 2, Chapter 17, Measuring the Factory (seven dimensions, served-request event, shipped-unused balance, patience runway)
- Book 2, Chapter 18, the charter's two-compiler test and the trust ledger, as treated on the factory-charter page
- Book 2, Chapter 20, Agent-Driven Departments (four properties, measured agent share, six-system stack)
- Book 2, Chapter 24, the control budget as a ratio (section 4.9)
- Book 2, Chapter 25, build, configure or consume (five dimensions; the renewal book)
- Book 3, Chapter 4, The Deployment Decision (routes; operator, biller, processor and contracting entity), with Appendix A
- Book 3, Chapter 16, model upgrades (the four phases from Day −14 to Day +90)
- Book 3, Chapter 17, the four incident shapes
- Book 3, Appendix H, Vendor Concentration and Exit Playbook (three axes, 70% and 85% triggers, eight cleavage points)
- Book 09, Chapter 3 and Closing chapter (the 8 / 24 / 3 portfolio threshold; the two leading numbers; the ten statements)
- Book 09, Chapter 12, Who Holds the Dial (the control band, the counting rule and the quarter-end rule)
- Research Paper 7, Build, Configure or Consume: Sourcing Decisions When Agents Make Code Cheap (the four gates, section 9)
- Research Paper 5, Mission and Values of the AI Factory: What Changes When the Values Document Is Executed (charter values and revealed values), as treated on the factory-charter page
- Book 1, Chapter 5 (ten-pillar control-plane scorecard), Chapter 10 section 8 (multi-cloud theatre test) and Chapters 18–19 (roadmap, tranches and signed trade-offs), as treated on the adopt and vendor-concentration pages
- Book 2, Chapter 21 section 5 (validated-intent lead time) and Chapter 27 (portfolio threshold; tranches), as treated on the measurement and adopt pages
- Book 3, Chapter 8 (Claude Code at the workstation), Chapter 18 (alias drift) and Chapter 20 section 5.1 (evidence tiers), as treated on the workstation, model-governance and measurement pages
- ADD proposal (Agent-Driven Departments, sections 4 to 4b) and Whitepaper Part I section 3 (six-question diagnostic), as treated on the treating pages
Related guidance
-
Schemas, Conformance Packs and the ops ToolchainWhat the versioned Supporting Tools schemas hosted under /aes/v0.1.0/ require, how to validate against them, where the source specification contradicts itself, and what the planned ops CLI, Claude plugins and service conventions define. -
Primary Sources and Open ChecksThe official texts this reference relies on (EU legal instruments with ELI links, DORA Level 2 acts, Commission and ESA publications, national law, standards, vendor documentation and the specifications hosted on this site), each with its identifier, the version or date it was read, its verification status and the pages that use it, followed by a consolidated register of the open fact-checks that still stand between a source claim and an official text. -
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. -
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. -
Data Classes, Processing Lanes and TokenisationClassify every model request by its data, route it only to a processing lane the class permits, keep derived artefacts inside their source class, and treat retention, roles and tokenisation as recorded, testable decisions. -
Choose and Contract Claude Deployment RoutesDecide, per use-case class, which route carries Claude into production (Anthropic API, Claude Platform on AWS, Bedrock, Google Cloud, Microsoft Foundry, plus the Microsoft 365 Copilot surface); record who operates, bills and processes; size the diligence to the processor; check residency, zero data retention and HIPAA per feature; sign a contracting matrix row; and run Agent SDK or hosted agents with the controls the product does not supply. Provider-specific and dated. -
Model Governance: Usage Registry and Upgrade LifecycleGovern models at the grain regulators ask about: a catalogue for what exists, an 18-field usage registry for what is used, risk classified per usage, a registry the policy decision point reads by usage_id, pinned model IDs, and a four-phase upgrade lifecycle from Day −14 to Day +90 with numeric rollback thresholds. -
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. -
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. -
Accountability and OwnershipHold provenance and accountability apart on purpose: four named accountabilities per product, a human owner for every agent change, seven named seats, a signed Build/Run RACI and a first-line/second-line boundary that survives consolidation. -
Control BudgetAn author proposal for a CRO-signed limit on how fast change may arrive relative to the firm's capacity to understand it: the CIO runs the line, the CRO signs the band, only changes with a full record count, two weeks outside the band queues intake automatically, quarter-end widening is signed in advance, and someone outside the squad reviews what the budget held back. -
Measure the FactoryRead usage first, then the seven-dimension scorecard; emit a served-request event that separates human from agent callers; label every reported number by evidence tier; watch the two leading numbers of a control gap; treat an unexplained sharp improvement as an alarm; and never turn a participation metric into a target.