Build a Living Product Bill of Material and Recipe
Describe what an AI product contains and how the firm builds it in one versioned specification shared by pipelines, agents and assurance teams, including the classification line, readiness grades and reuse generations.
- Version
- 0.2.0
- Owner
- DEIXEI
- Last reviewed
- Reading time
- 23 min
For Cto · Ai Architect · Platform Engineer · Product Leader · Risk And Assurance
Sources and details
- Section
- Design
- Source works
- Book 2 · Research Series
- Source chapters
- 3, 5, 8, 22
- Source appendices
- 02:C
- Refresh trigger
- source change
A product description kept apart from its build process drifts. An AI delivery factory needs a versioned, machine-readable description of what a product contains, which obligations apply to it, and how the firm assembles, releases and operates it. Book 2 calls that pair the bill of material (BOM) and the recipe.
- The BOM is the inventory. It answers: what must exist for this product to be built, deployed, operated, secured and audited?
- The recipe is the choreography. It answers: how does the firm assemble, govern, release and evidence this kind of product?
Keep both in one living specification, versioned alongside the product. The BOM and recipe model, the classification line and the readiness field are author design proposals from Book 2, not adopted industry standards.

At a glance: one living specification, versioned and queryable, that the coding agent reads. The detailed diagram is under Keep one living specification. Source: The AI Delivery Factory, Chapter 5, Figure 5.3.
What the BOM records
The enterprise BOM is broader than a software dependency list. Give every line a stable identifier, an owner, a version and a link to its authoritative evidence.
| BOM area | Record |
|---|---|
| Product identity | Name, purpose, owner, business capability, lifecycle, risk tier. |
| Source and artefacts | Repositories, build outputs, registries, deployment artefacts. |
| Runtime and infrastructure | Application components, hosting services, environments, cloud resources. |
| Software dependencies | Libraries and packages, with a generated SBOM in CycloneDX or SPDX. The SBOM is one layer of the BOM, not the whole enterprise record. |
| Interfaces and data | APIs consumed and exposed, data domains read or written, data classification, entitlements, retention obligations. |
| Identity and secrets | User, workload and agent identities, roles, references to secrets, certificates and keys, rotation policy. Never put secret values in the BOM. |
| Agents in the product | A reference to each agent’s bounded-agency envelope (mandate, means, memory, monitoring). The BOM points to the envelope; it does not define it again. |
| Delivery and operations | Pipeline templates, environments, observability, alerting, support ownership. |
| Controls and evidence | The controls the product must satisfy and the evidence records it is obliged to emit. These are first-class lines, not additions late in the project. |
| Readiness grade (per component) | See below. |
| AI-specific fields | The classification line and the release manifest (both below). |
Treat data classification as material. It is not metadata. In Book 2’s composite worked example, the recipe refuses production data access until the classification exists, because the classification decides which controls the production environment must carry. When a field changes the meaning of an exported record, update the classification line first. Retention, export handling and the auditor’s view all follow from it.
Release manifest. For an AI product, a release is a pinned combination: model and dated version, parameters, prompt version, orchestration version, retrieval and index version, tool versions, and the evaluation results that combination achieved. Changing any one of these is a release, even when no code changes. If a vendor publishes a new dated model behind an unchanged endpoint name, you have made a release nobody decided on. This is why the manifest pins the version, not the name. The pipeline writes the manifest back as actuals. Evaluation and progressive rollout are covered under release engineering, and model lifecycle under the model gateway.
The classification line

The classification line: one line, six values, carried in the repository manifest and repeated on the catalogue entry. Source: The AI Delivery Factory, Chapter 5, Figure 5.1.
Every AI product, and every component it composes, carries one line in its repository manifest and its catalogue entry (Book 2, Chapter 5 §4.2, Chapter 22 §5.4, Appendix C.1):
anatomy tier / pattern family (and code) / agency class / risk tier / data class / reuse generation
Book 2’s worked example for a routing step in a document pipeline is reasoning and orchestration / WF-ROUTE | class 2 | tier 2 | C3 | G3. A product carries its own line and lists the line of every component it composes. The BOM does not define the six values. It is the one place where all six sit together in a form a machine can read. If the six facts are held in three separate systems, Book 2 expects them to disagree within a quarter.
| Field | Values | Defined in | What reads it, and what it changes |
|---|---|---|---|
| Anatomy tier | Infrastructure and hosting; data and knowledge; models; reasoning and orchestration; integration and interoperability; experience and channels. The trust and operations plane crosses all six tiers and is not a seventh | Application anatomy | Which tier controls attach. Catalogue search (“what else lives here?”) |
| Pattern family and code | Model interaction (MI), knowledge and grounding (KN), model adaptation (AD), workflow (WF), agent (AG), multi-agent (MA), integration and interoperability (IN), trust, governance and operations (TR), plus the entry code from Appendix C | Recipe catalogue | Search, for example “which products depend on permission-aware retrieval?” before you change it. The pattern arbiter compares a design with its siblings |
| Agency class | 0 single call, 1 grounded answer, 2 workflow, 3 bounded agent, 4 multi-agent | Choose the AI product shape | Control intensity and test depth. Between class 2 and class 3, the unit of testing changes from an output to a trajectory. The arbiter checks the least-agency rule: no agent where a workflow will do |
| Risk tier | The firm’s own AI risk classification | Risk tiers | Selects the control bundle and caps the autonomy ceiling |
| Data class | C1 public, C2 internal, C3 confidential, C4 strictly confidential. Four flags travel with the class: personal data, client-identifying data, MNPI, statutory-retention records | Firm classification policy | Which hosting routes, models and logging options are allowed. Policy pack selection |
| Reuse generation | G0 to G4 (below) | This page | What the next consumer has to do. Makes reuse countable |
All three facts that select a policy pack (agency class, risk tier and data class) are on this line. Policy-as-code reads them to attach the product’s policy pack without a meeting.
Connect every field to a consequence. A field that no consumer reads is decoration. For each value, name the mechanism that acts on it and test that it does. Examples: the pack-selection rule for agency class, risk tier and data class; the hosting-route permission check for data class; the arbiter’s review checklist for pattern family and agency class; the catalogue’s reuse report for generation. If changing a value would not change any behaviour, either wire it to a mechanism or drop it.
Keep the scales orthogonal. Agency class is a design-time fact: whether code or the model decides the next step. It is not a readiness grade, a risk tier or a rung on the autonomy ladder. The autonomy ladder runs advisory, controlled execution, then autonomous standard-change, and each rung is earned at run time per agent, per runbook, per domain. A class 3 design running at the advisory rung is normal. Choosing a class 3 design where class 2 would do breaks the least-agency rule, whatever rung it runs at.
Book 2’s line versus Working Paper 01’s code
The sources give two versions of the six-field record. They do not match, and this page does not merge them.
| Book 2 (Ch 5, Ch 22, App C) | Working Paper 01 §4.5 and Working Paper 02 §2.4 | |
|---|---|---|
| Layout | anatomy tier / pattern family | agency class | risk tier | data class | reuse generation | layer / pattern | agency class | action scope | risk tier | data class | reuse generation |
| Example | reasoning and orchestration / WF-ROUTE | class 2 | tier 2 | C3 | G3 | L3/WF-ROUTE | A2 | Draft | Tier-2 | C3 | G3 |
| Action scope | Not in the line. “What a design does” (read-only, draft, act with approval, act autonomously) is treated as the autonomy ladder viewed at design time | A field. Read-only, Draft (a human sends), Act with approval, Act autonomously within a defined envelope. It separates advice from execution and starts narrow, widening on recorded evidence |
| Labels | ”class 2”, “G4 governed recipe" | "A2”, “G4 governed blueprint” |
This page follows Book 2 for the line. Appendix C says that where the working paper and the book disagree on vocabulary, the book wins. In practice, the two fit together in layers rather than competing:
- Design-time layer, the classification line. These are the facts fixed when the design is chosen, read by search, the pack selector and the arbiter.
- Deployment layer, action scope and autonomy rung. These are recorded per deployed agent or workflow, beside the line rather than inside it, on the agent registry and in the envelope’s mandate. Policy-as-code reads this layer too, because it decides whether an action executes. Working Paper 01’s scopes map onto Book 2’s rungs as follows: read-only and draft are advisory, act with approval is controlled execution, and act autonomously within the envelope is autonomous standard-change. Working Paper 02 adds that an archetype fixes the starting action scope.
- Resourcing layer, human roles. Working Paper 01 records the human roles a solution needs (supervisor, annotator, feedback provider) as a list in the same manifest, outside the code, because a resourcing process reads it and the policy engine does not. Book 2 has no equivalent field. This page recommends keeping the list.
If your catalogue already uses Working Paper 01’s code, you do not have to rewrite it. Document the mapping above and make sure the action scope your policy engine reads is the deployment’s current rung, not a copy frozen at design time.
Reuse generations, G0 to G4
Reuse is recorded per asset. It is not an organisational maturity score. The generation tells the next consumer what they have to do. The definitions and entry criteria come from Working Paper 01 §6, a design proposal. Names follow Book 2 (Chapter 22 §5.4).
| Generation | Unit of reuse | The next consumer | Entry criteria (Working Paper 01) | Examples |
|---|---|---|---|---|
| G0 ad hoc | Nothing formal | Rebuilds it | None | Pilot notebooks, one-off scripts |
| G1 shared code | Libraries, prompt templates, IaC modules | Imports or copies it, then operates it | Versioned repository, owner, README, classification line in the manifest | Document parser library, prompt library |
| G2 platform service | Multi-tenant service run by a platform team | Calls an API | SLO, on-call rota, tenancy model, cost allocation, security review | Model gateway, retrieval service, evaluation harness |
| G3 composable capability | Tools and agents behind standard protocols | Finds it in the catalogue and binds to it | MCP or A2A interface, capability description, golden evaluation set, agent identity, accountable owner | Customer-data MCP server, KYC-document agent |
| G4 governed recipe | A solution shape: a pattern composition with a pre-approved control bundle and templates | Fills in parameters and runs a pipeline | Architecture approval, second-line sign-off on the control bundle, a reference implementation in production | ”Grounded knowledge assistant” recipe |
- There is no G5 generation. Some frameworks add a step in which agents build and operate assets themselves. Book 2 and Working Paper 01 both treat that as a capability of the factory (the automation factory), which acts on assets of every generation. Working Paper 01 keeps the label G5 for that capability because it is in circulation, but no catalogue entry should carry it.
- Promotion is a judgement, not a rule. A second consumer does not automatically promote an asset from G1 to G2. A third recurrence of a composition does not automatically create a G4 recipe. These are telemetry signals that open a decision for the people who would own the result: its operating cost, service level and on-call rota. This page recommends recording the decision in a design record. Promoting automatically creates platform services that no one agreed to operate.
- Retirement is the same judgement run backwards. When usage or evaluation freshness drops under its threshold, the asset is flagged, the catalogue names a successor, and an owner makes the call. Working Paper 01’s orphan rate (assets with no active owner, or no evaluation run, in 90 days) uses 90 days as a starting value to be tuned. It is not a benchmark.
Grade each component for agent readiness
Book 2, Chapter 5 §4.2 adds a per-component readiness grade to the BOM. It records the four properties from agent readiness: describability, verifiability, reversibility and observability. Record each as a graded, checkable fact rather than an opinion. Examples: the tests exist and run in a stated number of minutes, the build is deterministic, the telemetry answers named questions.
- The recipe consumes the grade. When a work order arrives, the recipe reads the grades of the components the change touches. It routes the work to the human lane, the agent lane or a mixed lane, at an autonomy rung the grade can support.
- Readiness routes the lane. The risk tier authorises the autonomy. A payments API with excellent tests can be very agent-ready and still risk-critical. “Ready” says how cheaply a wrong change is caught, not how much a wrong change costs. Keep the two on separate lines so that the factory never reads “ready” as “safe”.
- Acceptance check: a work order that touches a low-grade component routes to the human or mixed lane, even when the change looks trivial.
Make the factory’s own working material catalogue citizens
Prompt libraries, agent definitions, MCP servers and the standing-instruction files themselves are components, and they belong on BOMs exactly as code does (Book 2, Chapter 5 §4.5). If an agent definition exists only as dotfiles in one repository, nobody answers for it when it misbehaves, its changes go unversioned, and there is no route to upgrade it when its underlying model changes.
Give each one these BOM lines:
| Field | Why |
|---|---|
| Owner | Someone answers when it misbehaves |
| Version | Changes are visible and reversible |
Certification tier: sanctioned, certified, contributed or quarantined | Book 2 (Chapter 8 §4.7) computes the tier from evidence: current scans, green contract tests, production consumers, clean incident history, a responsive owner. A committee does not grant it. An asset whose scan goes stale or whose owner stops responding drops a tier without a meeting. Only evidence-certified assets reach the paved context that agents build from |
| Consuming products | A change to the asset can be traced to the products it affects |
| Classification line | Same rules as any other component |
The pattern catalogue is the recipe side: the shapes the firm sanctions. The BOM is the inventory side: what this instance contains, at which version, and who owns it. A firm with only one of the two can say how its agents should be built, or what it built, but not both. See the MCP and connector broker for tool registration.
Make the recipe executable, step by step
A recipe is a sanctioned sequence of provisioning, configuration, checks, approvals, release and evidence. Label every step as exactly one of three kinds:
| Step kind | Meaning | Example |
|---|---|---|
| Automated action | The factory performs it with no human decision | Create an environment, run a scan, publish a signed artefact |
| Policy gate | A machine checks a condition and allows or blocks progress | Deny production data access until classification and entitlement checks pass |
| Human decision | A named person applies judgement and records the decision | Accept a risk exception; confirm that the product does what the business needs |
Most recipes rot because these three get muddled. A gate is written as a hopeful sentence rather than an enforced check, or an inconvenient human decision is quietly automated away. “Obtain approval” is not a policy gate until the pipeline checks for a valid approval record. When an agent reaches a human-decision step, it prepares the material and waits. The recipe never hands judgement to the model. The recipe’s release and evidence steps are what make an agent’s output defensible: a recipe that requires a CAB decision record and a deployer manifest produces the evidence the audit spine expects.
Compose rather than copy. The product recipe is mostly a sequence of calls to smaller sanctioned recipes (foundation, identity, logging, secrets), plus a few steps specific to the product. Each component recipe has its own owner and version. Improve the identity recipe and every product that composes it inherits the change at its next build.

Composition lets product, platform and component owners each maintain the part they understand. Source: The AI Delivery Factory, Chapter 5, Figure 5.2.
A composed specification goes stale only where a specific sub-component changes, and the team that owns that node owns the change. History is kept per node, so a product can ask its dependencies what changed and when. A coding agent needs that query most when the foundations under a product have moved.
Fill the slots per provider (vendor-specific)
The BOM and recipe are the stable layer. Provider components are the replaceable layer beneath them. Reference provider services as named components so that swapping one is a BOM change rather than a rewrite of the recipe. As of 2026, per Book 2, Chapter 5 §4.6. [FACT-CHECK: confirm current service names and status against Microsoft, AWS and Google Cloud documentation before publication.]
| Slot | Azure (Book 2 reference) | AWS | Google Cloud |
|---|---|---|---|
| Infrastructure modules | Bicep modules as Template Specs, or via Deployment Stacks | CloudFormation, CDK, Terraform | Terraform, Config Connector |
| Identity | Entra ID | IAM Identity Center with IAM roles | Cloud Identity with Workload Identity Federation |
| Scanning | Microsoft Defender for Cloud | Amazon Inspector plus native SBOM export | Security Command Center |
| Data classification | Microsoft Purview | Macie | Sensitive Data Protection |
| API registration | Azure API Management | API Gateway | Apigee or API Gateway |
| Secrets | Key Vault | Secrets Manager or Parameter Store | Secret Manager |
| Telemetry | Application Insights | CloudWatch | Cloud Logging, Cloud Monitoring |
Book 2 adds these provider-specific notes. Treat each as a dated claim:
- Azure Blueprints is deprecated. Book 2 reports a retirement on 31 January 2027, with Deployment Stacks and Template Specs as the replacements. A recipe that still names Blueprints is building on a retiring product. [FACT-CHECK: Azure Blueprints retirement date and replacement guidance, per Microsoft Learn “Azure Blueprints retirement”.]
- Book 2 judges that AWS Bedrock’s session-tagged agent identifiers fit the BOM’s agent-identity line more directly than Azure’s agent identity did for much of 2026. It advises firms to check Entra Agent ID against current documentation rather than assume parity. [FACT-CHECK: current Entra Agent ID capability and status.]
- On Google Cloud, Book 2 says agent identity from the Gemini Enterprise Agent Platform fills the same slot, and that this platform absorbed the earlier Vertex AI agent tooling as of April 2026. [FACT-CHECK: product name and scope.]
Harvest the recipe from an exemplary team
The cheapest good recipe already exists in the team the firm considers exemplary (Book 2, Chapter 3 §6–§8). Do not accept “good engineers” as the explanation. Look for the hidden structure, and write down:
- repository structure and branch policy;
- test stages and deployment gates;
- logging requirements and the configuration model;
- ownership records and the runbook template;
- the evidence package the team produces.
Write down the recipe the team actually follows, not the one the policy says exists. The gap between the two is where hidden labour and audit friction sit. Put the result in the repository as standing context that both new joiners and coding agents read. As of 2026, Book 2’s composite uses a CLAUDE.md file for Claude Code, or AGENTS.md as the vendor-neutral sibling, at the root of each service. [FACT-CHECK: current file names Claude Code and other agents read by default.] Add a line every time an agent produces output that is plausible but wrong for the enterprise. The standing-instruction file then fills in exactly the conventions that were ambiguous.
Write the judgement boundaries into the recipe as well. In the composite, an agent’s matching-logic redesign passed every generated test because the tests came from the same flawed specification. It nearly changed a tolerance for a whole class of breaks. The team pulled the activity back and wrote into the recipe that changes to matching logic are reviewed step by step by humans, whatever the agent’s confidence.
Anti-pattern: hero preservation. The firm exempts its best team from standardisation (“that team is different”). The firm’s best operating knowledge then never leaves anyone’s head, and it walks out of the door with the lead. Extract that team’s recipe first, while the people who built it are still there to explain it.
Keep one living specification

The same specification is build input, agent context and assurance evidence, with version history behind it. Source: The AI Delivery Factory, Chapter 5, Figure 5.3.
A living specification is:
- versioned. Every product change updates the description in the same commit, with a reason.
- queryable. A pipeline, an agent or an auditor can ask for the current approved state.
- historied. An agent can ask what the product was, what changed and why, not only what it is now.
- composed. Components are referenced by identity and version, never copied.
- written back. The pipeline writes actuals (what it provisioned and released, at which versions, with what result). An agent that hits an undocumented convention proposes a correction to the spec instead of working around it. Over time, the auditor’s queries show which parts carry regulatory weight. A proposed correction is not an approved change.
Co-ownership. The BOM’s natural owners are product, service and technical owners. The recipe’s are platform, architecture and risk owners. Keep both halves in one place and own them jointly. Do not split them across two systems. The triggers for change differ: the BOM changes when a component, dependency, control or owner changes, and the recipe changes when the pattern, a policy or the platform changes. Every trigger produces a new version with a reason.
Why it matters more with agents. A stale spec does not produce one wrong change. It produces a series of confident, consistent wrong changes, each built faithfully on the last. When a line of agent work has grown from a spec that turned out to be wrong, correct the spec and restart the work against it rather than patching the output (agent-speed SDLC).
Implement incrementally
Do not try to describe the whole estate. Start with the product pattern your teams build most often.
- Write the BOM by hand from what exists. Read the repository, the pipeline, the cloud resources and the identity configuration. Any field you cannot complete is a finding: it marks a part of the product nobody owns.
- Write down the real recipe (see the harvest section above). Label every step as an action, a gate or a decision, and give each step an executor, inputs, outputs, a failure result and an evidence identifier.
- Move both into the repository beside the code, together with the standing-instruction file.
- Version from now on. Make the next product change a change to its description, in the same commit.
- For an AI product, add on day one a hand-written classification line and the pinned combination currently in production (model, prompt and index versions). A team that cannot name its endpoint’s model version has found its first gap.
- Add readiness grades to the components most often changed.
- Validate. Check required fields, allowed classification values, version pins, ownership, recipe dependencies and gate conditions. The pipeline rejects an incomplete or stale specification before provisioning or dispatching work.
- Then automate one step only, for example repository creation, identity registration or evidence publishing.
Use an existing versioned schema where one already defines the record you need. Where the tooling stream has no normative type yet, keep a small local schema beside the implementation and mark it as a local draft. This page does not claim that a universal BOM or recipe schema has been adopted.
For scale: in a large firm the living spec needs an owner with authority, usually the head of platform engineering, and a named forum for the seam between product and platform owners. A smaller firm can drop most of the ceremony but not the discipline, and especially not the machine-readability.
Example change record: a model or prompt update
Record the proposed and currently approved version, the reason, the affected products and behaviour, the evaluation set and its version, pass and fail results, the risk and data impact, the required human approval, the rollout and rollback method, and the resulting release identifier. The pipeline verifies the pins and the required evidence. A named product or risk owner decides whether the changed behaviour is acceptable. A green evaluation is evidence for that decision, not automatic approval, unless a separately approved policy explicitly delegates the decision.
Anti-patterns
Book 2, Chapter 5 §8 names six failure modes.
| Anti-pattern | Recognise it | Recover |
|---|---|---|
| BOM as a compliance document | It lives in a governance system, and its last-modified date trails the product’s by weeks | Move it beside the code and make it a required part of every change |
| Recipe as a Word document | There is no path from the document to an executed step, and agents invent around it | Move steps towards templates, modules and policy-as-code. Leave only genuine judgement points as prose |
| Over-standardising too early | There are more recipes than patterns in use, and teams file exceptions more often than they follow the pattern | Go back to the one or two most common patterns and make them excellent. Let demand pull the others in |
| Frozen spec | One spec version against fifty deployments | Bind spec changes to product changes in the same commit, and give the spec a queryable history |
| Human-only spec | Agent output is plausible but consistently off convention in small ways | Make the load-bearing parts structured: named components, patterns and constraints |
| Per-team island | One product described in several places that no single query can reconcile, with collisions found at merge time | Make the spec a shared, composed artefact with versioned cross-references between teams’ nodes |
Gates, failures and recovery
Treat a BOM or recipe revision as a code-reviewed change. Keep the previous approved version available for comparison and rollback.
| Failure | Gate response | Recovery |
|---|---|---|
| Missing or conflicting classification line | Stop before tool or data access or provisioning, and route to the classification owner | Resolve from the authoritative decision record, amend the spec and validate again |
| Classification value that no mechanism reads | Flag in review | Wire it to its consequence or remove it |
| Component version mutable or unresolved | Block reproducible release | Pin the resolved version, run build and evaluation again, and record the rationale |
| Component missing a readiness grade | Route to the human or mixed lane | Grade the component; the lane can change at the next work order |
| Agent definition, prompt library or MCP server not on the BOM | Treat it as ungoverned and keep it out of the paved context | Register it with owner, version, tier and consumers |
| Control exists only as prose | Treat it as advisory. Do not claim the gate passed | Implement a deterministic check, or keep an explicit human control with an owner and evidence |
| Deployed actuals differ from the approved BOM | Pause rollout according to release policy, and keep both records | Establish what ran, then roll back or approve a corrected spec. Never rewrite the historical approved BOM |
| Component recipe upgrade breaks a consumer | Stop promotion for affected consumers and keep the last compatible pin | Test against consumer contracts, publish a versioned fix and migrate consumers deliberately |
Acceptance evidence: a representative pipeline consumes the approved specification and fails on a deliberately invalid fixture. Each classification value drives a named mechanism. Work touching a low-grade component routes away from the agent lane. A reviewer can reconstruct the exact approved and deployed combination from the release record, and actuals link the release to its evaluation, approval and operational evidence.
Source lineage
- Book 2. Chapter 5 is the source for the BOM and recipe distinction, composition, the readiness field, factory working material as catalogue citizens, the release manifest, provider slots and the anti-patterns. The classification line is from Chapter 5 §4.2, Chapter 22 §5.4 and Appendix C.1. Certification tiers are from Chapter 8 §4.7. Recipe harvesting and hero preservation are from Chapter 3.
- Research Series. G0–G4 entry criteria, the orphan rate, action scope and the human-roles list are from Working Paper 01 §4.5 and §6. The six-field code with action scope also appears in Working Paper 02 §2.4.
- Where the sources disagree. The difference between Book 2 and the working papers is stated in the comparison above, and this page follows Book 2 for the line.
- Composite examples. Asset Manager X and its people are composites.
- This page’s own recommendations. The implementation sequence, the failure table and “connect every field to a consequence” are recommendations by this page.
- Status. All of these are design proposals, not a normative schema. This page remains a draft.
Source material
- Book 2 (The AI Delivery Factory), Chapter 5, Bills of Material and Recipes
- Book 2 (The AI Delivery Factory), Chapter 3, Why Craft Alone No Longer Scales (§6–§8)
- Book 2 (The AI Delivery Factory), Chapter 8, The Policy / Audit / Actuals Loop (§4.2 policy packs, §4.7 certification tiers)
- Book 2 (The AI Delivery Factory), Chapter 22, The Shape of an AI Product (§4.1–§4.3, §5.3–§5.4)
- Book 2 (The AI Delivery Factory), Appendix C, The Pattern Catalogue (C.1 How to read an entry)
- DEIXEI Research Series, Working Paper 01, A Taxonomy for a Reuse-Driven AI Factory (§4.3–§4.5, §6)
- DEIXEI Research Series, Working Paper 02, Ten Solution Archetypes for Regulated Finance (§2.4)
Related guidance
-
Choose the Shape of an AI ProductA least-agency decision sequence for choosing a product design: agency classes and their trade-offs, the eight questions, evidence for every step up, the consequence matrix that caps action scope, the cut-set review for agents, the other selection dimensions, and the design record. -
Assess Agent Readiness Across the EstateCheck the estate's control foundations, grade the stations a change must cross on evidence, route work by the weakest station, fund readiness worst-first with a stated split, and make bought products machine-operable at renewal. -
The Anatomy of an AI ApplicationA six-tier view of what one AI product is made of, crossed by a trust and operations plane that attaches controls to every tier; what the factory already supplies per tier, how the anatomy maps to the six-layer product portfolio, and how to run an anatomy review. -
The Ten AI Product Recipe FamiliesThe ten recipe families and their design cards (flow, action scope, data classes, controls, evidence, evaluation, anti-patterns), how to fit a request and choose between neighbours, the pattern catalogue beneath them, the human duties each recipe must staff, who governs the catalogue, and the pipeline checks that catch family drift, families of one and orphans. -
Build the Standard Application FoundationRun the shared identity, telemetry, deployment, data and AI capabilities as a funded product that humans and agents both start from, with a contract, evidence-computed trust, a cheap promotion boundary and reuse measured by consumption. -
Close the Policy, Audit and Actuals LoopRun governance as a standing comparison of declared policy against emitted records, route only the exceptions to the second line, and govern the policy packs that drive the comparison. -
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. -
The Agent-Speed SDLCA committed artefact chain, governed context, trusted tests and eight SDLC controls that let coding agents work quickly while intent, review, identity and evidence stay connected. -
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. -
Govern MCP Connectors Through a BrokerAdmit, tier, pin and enforce every MCP server through one registry and two enforcement points, keep tokens audience-bound, govern A2A delegation through its own registry and gateway, and expose client-facing agent channels only through the same policy layer.