Browse the reference ⌄
Artefact published

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

Full source list ↓ Source index →

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:

  1. Vocabulary rules: the term this reference uses when the sources offer several.
  2. 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.
  3. 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

ConceptTerm used on this referenceAlso seen in the sourcesWhy this choice
Where a model request is processedHosting 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 reachedDeployment route (Anthropic API, Claude Platform on AWS, Amazon Bedrock, Claude on Google Cloud, Microsoft Foundry, plus the Microsoft 365 Copilot surface)“Route” in Book 3A 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 productAgency class 0–4A0–A4 (Research Papers 1, 2 and 9)Same five classes, same definitions; only the notation differs.
Run-time, earned trustAutonomy ladder (advisory, controlled execution, autonomous standard-change)Action scope (read-only, draft, act with approval, act autonomously); Virtual CAB autonomy levelsSee the crosswalk below. Action scope is kept as the design-time ceiling view of the same ladder.
Reusable, parameterised assemblyRecipe and recipe familyGoverned 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 callsModel gatewayAI 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 callsTool 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 caseRisk 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 sensitivityData class C1–C4 with flagsFirm-specific labels; AES classification enumCodes from Paper 9; map them to the firm’s existing scale rather than adding a second one.
The nine-question recordAudit Evidence Schema (AES), as published at /aes/v0.1.0/Book 3’s differently worded question setThe 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 routeResearch Paper 9 processing laneDefining facts (Paper 9, section 4.1)Book 3 deployment routes that usually fall here
Vendor APILane A: vendor API under an enterprise contractThe model vendor operates inference and can see prompts and outputs during processing and any contractual retentionAnthropic 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 tenancyLane B: vendor model through the firm’s own cloud tenancy, approved region, private endpointsThe cloud provider operates inference; the model developer typically cannot see the dataAmazon 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 infrastructureLane C: open-weight or licensed model on infrastructure the firm controlsThe firm, or a provider acting solely on its instructions; no model vendor sees the dataSelf-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 notationWho decides the next stepUnit of testing
0: single callA0CodeOutput
1: grounded answerA1CodeOutput (plus indirect-injection exposure through documents)
2: workflowA2CodeOutput
3: bounded agentA3The modelTrajectory
4: multi-agentA4Models, code, or both; defined by separate owners and identitiesTrajectory 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-onlyAdvisoryAdvisory: the CAB recommends, humans decide
Draft (a human sends)AdvisoryAdvisory
Act with approvalControlled executionControlled execution: executes in a narrow band, humans review
Act autonomously within a defined envelopeAutonomous standard-changeAutonomous 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 tierLayer, combined with pattern as layer / pattern
Pattern family(inside the first field)
Agency classAgency class
(no field; autonomy ladder)Action scope
Risk tierRisk tier
Data classData class
Reuse generationReuse 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 codeBook 2 (Asset Manager X example, Ch 22)Book 3 data labels (Appendix G)AES v0.1.0 data[].classification enum
C1 PublicPublicPublicpublic
C2 InternalInternalInternalinternal
C3 ConfidentialConfidentialConfidential (non-customer, customer non-financial, customer financial)confidential
C4 Strictly confidentialStrictly confidentialRestricted; Strictly Confidentialrestricted? (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.

FlagPaper 9 (five flags, suffix letter)Book 2 Ch 22 (four flags)
Personal dataPPersonal data
Sensitive personal dataS (handled at least as C4)not listed separately
Client-identifying dataKClient-identifying data
Inside informationIMaterial non-public information (MNPI)
Regulated recordsRStatutory-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.

TierBook 3 nameApproval body (Book 3 App G)
T0Personal productivity with public or low-sensitivity dataLine manager at on-boarding
T1Internal knowledge assistanceAgent Control Board notification
T2Controlled operational assistance; the first tier with a registered agent and a named wranglerAgent Control Board full approval, with the envelope, evaluation-suite plan, confirmed identity pair and signed RACI
T3Regulated process support; every output crossing the agent’s boundary has a named human approverAgent Control Board with a named second-line signatory; AI Steering Committee notification
T4Material autonomous action; out of scope, and Book 3’s default answer for the next twelve months is noExecutive 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 1Book 2 reuse generationWhat the next consumer does
G0Ad hocRebuilds it
G1Shared codeImports it
G2Platform serviceCalls it
G3Composable capabilityBinds to it
G4 governed blueprintGoverned recipeFills 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 referenceBook 1Book 3Paper 1What it controls
Model gatewayAI gatewayLLM gateway (Azure API Management at the composite Bank A)AI gatewayEvery 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 gatewaynonenonenoneAgent-to-agent delegation, mutual authentication, egress to partner agents (Book 2 Ch 26)
Enterprise agent control planeSame, six planesSame, six planesnoneIdentity, 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 phraseSeries termTreated on
The named owner of each agentAgent wranglerAccountability
The architect who owns the standard designs and recipesPattern arbiterRecipe catalogue
The operator of the agent fleetThe seventh of Book 2’s seven names (governs the fleet)Running the factory
The seven seatsThe seven namesRunning the factory
The routing gate and its lineA scored change gate (Book 2’s Change Risk Index) and its auto-approval thresholdChange governance
The band; the limit on the pace of changeControl budgetControl budget
Control valuesEvery tolerance, threshold and limit that decides what a client sees, kept on one list that the second line signs as completePolicy, audit and actuals
One evidence recordAudit Evidence Schema and audit spineAudit evidence
A single door in front of every model callModel gatewayModel gateway
A common starting pointStandard application foundationApplication 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

TermDefinitionSourceTreated 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 JAccountability, Agent lifecycle
Product teamBook 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 JAccountability
PodA 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 ARunning the factory
Seven namesThe 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 closingRunning the factory
Pattern arbiterThe 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 CRecipe catalogue
Adoption leadReads usage telemetry after go-live and drives how a shipped solution changes to fit real use.Book 2 App ARunning the factory
AI Platform OwnerFirst-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 JFactory 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 JChange governance, Agent lifecycle
AI Steering CommitteeThe 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 JAccountability
Three lines of defenceFirst 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 FAccountability
Named accountabilityAccountability enforced at run time: the registry, gateway and detection rules refuse to work without a resolvable, current owner.Book 3 App JAccountability
Prohibited-use listA short, executive-approved list of use cases declined whatever the controls. Settled before any use case is tiered.Book 3 App JRisk tiers

Envelope, zones and autonomy

TermDefinitionSourceTreated on
Bounded agencyThe 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 JBounded 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 JAgent lifecycle
Envelope IDThe 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 JAgent lifecycle
Four-zone agent modelAgents 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.0Agent lifecycle, Identity and secrets
Agency classA design-time property: who decides the next step. Classes 0 to 4; see the crosswalk above.Book 2 Ch 22; Paper 1Choosing a product shape
Autonomy ladderRun-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 22Agent lifecycle
Action scopePaper 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.4Choosing a product shape
Least-agency ruleChoose 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 22Choosing a product shape
Cut-set reviewFor 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 ABounded agent
Loop-escape conditionEvery 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 ABounded agent
TranslocationMoving 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 AWorkflow
Suspension mechanismBook 3’s three-layer containment: wrangler level (minutes), gateway level (seconds) and organisational (rehearsed).Book 3 App JIncident 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.

WordWhat it doesOwner and record
ModelComputes: 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.
AgentDecides 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.
ToolExecutes: 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).
VendorSupplies. 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 systemEverything 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.

PathDefault trustMinimum controls
Pre-authored tool codeTrusted as production softwareNormal change management, typed parameters, input validation, least-privilege service identity, per-call logging
Agent-generated runtime codeUntrusted by defaultRuns 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 deploymentUntrusted until reviewedHuman-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

TermDefinitionSourceTreated on
Application anatomyThe 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 22Application anatomy
Pattern familyOne 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.2Recipe catalogue
Classification lineThe 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.4BOM and recipes
Risk tierThe 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 ARisk tiers
Data classHow much harm follows if information reaches the wrong party. C1–C4, plus flags that can only tighten handling.Paper 9 section 3Data 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 4Data classes and lanes, Cloud and hosting
Reuse generationA 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.3Recipe 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 ABOM and recipes
RecipeThe 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 ABOM and recipes
Recipe familyOne 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 2Recipe catalogue
Release manifestThe 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 ARelease engineering
Living specThe BOM and recipe once agents consume them: a versioned, queryable record that can answer questions about its own history.Book 2 App ABOM and recipes
Policy packA 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 APolicy, audit and actuals
Standard application foundationThe 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 AApplication foundation
Foundation contractFor 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 AApplication foundation
Paved roadAn 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 ALanding zone
Promotion boundaryThe crossing from prototype to production. The rule: promotion must be cheaper than evasion.Book 2 App AApplication foundation
Readiness event horizonThe decay point past which agents cannot help repair a station, because it has no tests, no observability and no working build.Book 2 App AAgent readiness
Control inheritance rateThe share of a product’s required controls whose evidence comes from an inherited platform asset.Book 2 App ARunning the factory

Delivery artefacts

TermDefinitionSourceTreated on
Two-speed SDLCA 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 AAgent-speed SDLC
Artefact chainThe 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 AAgent-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 AAgent-speed SDLC
Spec (spec.md)The testable requirements and design. It generates the tests that judge the build.Book 2 App AAgent-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 AAgent-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 AAgent-speed SDLC
ADR and GIPAn 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 AAgent-speed SDLC
Skills and hooksA 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 AAgent-speed SDLC
Automation factoryThe 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 AFactory model
Controls that executeControls 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 AControl map
Golden recordA 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 AEvaluation and resilience
Failure-mode registerA 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 ARelease engineering

Change and release

TermDefinitionSourceTreated on
CABChange 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 ToolsChange governance, Schemas and tools
Virtual CABEleven 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 JChange governance
Change DossierThe 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 AChange governance
CAB decision enumgo, go-with-conditions, no-go, needs-review, superseded. A chair’s refusal is a separate event kind, cab.refuse.CAB Decision Record v0.1.0Schemas 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 09Change governance
Control budgetAn 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 12Control budget, Change governance
Control valuesEvery 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 closingPolicy, audit and actuals
Model upgradeA 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 JModel governance, Release engineering
Deployer ManifestThe 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 ToolsSchemas and tools

Evidence and the audit spine

TermDefinitionSourceTreated 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 ToolsAudit evidence, Schemas and tools
Audit spineThree 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 AAudit evidence
Leaf, edge, centreEvidence 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 AEnterprise control plane
LakeThe 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 AAudit evidence
session_id / change_idThe 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 AAudit evidence
kindThe 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.0Schemas and tools
Correlation IDBook 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 EAudit evidence
Policy / audit / actuals loopThe 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 APolicy, audit and actuals
Policy Decision APIThe 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 DEnterprise control plane
Evidence dividendThe artefacts that make the factory operable double as the artefacts supervisors require: one investment, two returns.Book 2 App AAudit evidence
Evidence portabilityAn 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 HVendor concentration and exit
Replay rehearsalBook 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 EAudit evidence

Platform doors and registries

TermDefinitionSourceTreated on
Model gatewayThe 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 AModel gateway
Tool brokerThe 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 AMCP and connector broker
MCP serverA 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 JMCP and connector broker
Agent gateway and agent cardThe 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 AMCP and connector broker
Grounding data APIThe 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 AData, API and integration
Enterprise agent control planeIdentity, 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 JEnterprise control plane
Model catalogue versus model usage registryA 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 JModel governance, Model gateway
Agent-readable data dictionaryThe 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 DData, API and integration, Authority process
Trust spineIdentity, secrets and configuration taken together; everything on the production line inherits their strength or weakness.Book 2 App AIdentity and secrets
Agent identity, runtime identity, deployment identityAn 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 JIdentity and secrets
Landing zoneThe 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 JLanding zone

Data handling and deployment routes

TermDefinitionSourceTreated on
Processing lanePaper 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 10Data classes and lanes
Class × lane permission matrixPaper 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.1Data classes and lanes
Derived-artefact ruleEmbeddings, 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 9Data 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 4Data classes and lanes, Deployment routes
Tokenisation, masking, redaction, pseudonymisation, anonymisationFive 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 13Data classes and lanes
Rehydration mapThe 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 pageData classes and lanes
Deployment routeOne 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 2026Deployment routes
Contracting matrixOne 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 8Coding-agent workstation
Guidance versus controlAn 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 8Coding-agent workstation, Agent-speed SDLC

Models, vendors and exit

TermDefinitionSourceTreated on
Model usage registry rowEighteen 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 16Model governance
usage_idThe 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 14Model governance
Four-phase model upgradeBook 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 16Model governance, Release engineering
Pinned model ID and alias driftProduction 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 18Model governance
Concentration axesThree 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 2Vendor 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 8Vendor concentration and exit
Contract-cleavage pointsEight 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 3Vendor concentration and exit
Exit rehearsalAn 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 HVendor concentration and exit

Records, incidents and suspension

TermDefinitionSourceTreated on
Draft versus recordGenerative 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.4Authority process
Authority ProcessThe 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 16Authority process
Four incident shapesWrong 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 17Incident response
Monday-morning testThe 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 7Incident response
One playbook, several cover sheetsAgent 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.10Incident response

Measuring the factory

TermDefinitionSourceTreated on
Seven-dimension scorecardFlow, 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 4Factory measurement
Served-request eventOne 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 10Factory measurement
Evidence tierThe 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.1Factory measurement
Shipped-unused balance and patience runwayTwo 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 5Factory measurement
Validated-intent lead time and intent coverage ratioThe 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 5Factory measurement
Two leading numbers of the control gapPulled 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 ClosingFactory measurement
Agent-to-wrangler ratioThe 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 1Factory measurement, Accountability

Adoption, sourcing and the department

TermDefinitionSourceTreated 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 27Build, configure, consume, Implementation roadmap
Four sourcing gatesPaper 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 9Build, configure, consume
Five sourcing dimensionsBook 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 25Build, configure, consume
Renewal bookThe 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 7Build, configure, consume
Factory charterThe 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 5Factory charter
Two-compiler testEvery 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.2Factory charter
Trust ledgerTrust 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.4Factory charter
Revealed valuesWhat 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 5Factory charter, Policy, audit and actuals
Roadmap phasesThe 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 pageImplementation roadmap
Tranche fundingThe 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.4Implementation roadmap
Four signed trade-offsCalibration 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 7Implementation roadmap
Readiness instrumentsFour 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 ClosingReadiness diagnostic
Agent-Driven DepartmentA 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 proposalAgent-driven departments
Measured agent shareThe 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.1Agent-driven departments
Six-system stackThe 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 proposalAgent-driven departments
AI Skills Library and the graveyard failureStandards, 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 8Agent-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.

TermWorking meaning for practitionersSource
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 InformationDORA’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
TLPTThreat-led penetration testing under DORA. Its scope can include AI agents in CIFs.Book 1 App D; Book 3 App J
FRIAThe 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-processorIn 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 entityFour 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 calendarBook 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

TermDefinitionSourceTreated on
Supporting ToolsThe 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 ASchemas and tools
opsThe 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 ASchemas and tools
Conformance packA 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/conformanceSchemas 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.

CompositeAs described in Book 3 Appendix J
Bank AFrankfurt-headquartered universal bank under direct ECB supervision
Asset Manager XLuxembourg-headquartered asset manager, CSSF-supervised
Insurer IMunich-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 classification values 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

← All AI Delivery Factory guidance

On this page

  1. Vocabulary rules this reference follows
  2. Crosswalks
    1. Where a request is processed: hosting route, lane and deployment route
    2. Design shape versus run-time trust: agency class, action scope and the autonomy ladder
    3. The classification line and the classification code
    4. Data classes across four sources
    5. Risk tiers
    6. Reuse generations, recipes and “blueprints”
    7. Gateways, brokers and planes
    8. The nine audit questions: specification versus Book 3
    9. Book 09 plain language
    10. Book 1 chapter numbers cited from other books
  3. Glossary
    1. Accountability and governance bodies
    2. Envelope, zones and autonomy
    3. Five words to keep apart
    4. Design, classification and composition
    5. Delivery artefacts
    6. Change and release
    7. Evidence and the audit spine
    8. Platform doors and registries
    9. Data handling and deployment routes
    10. Models, vendors and exit
    11. Records, incidents and suspension
    12. Measuring the factory
    13. Adoption, sourcing and the department
    14. Regulatory anchors (definitions only)
    15. Supporting Tools
    16. Composite organisations
  4. Source and status

All pages in Reference →