Browse the reference ⌄
Implementation Guide published

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

Full source list ↓ Source index →

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.

The bill of material and recipe as a living spec — versioned, queryable, with history — consumed by coding agents.

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 areaRecord
Product identityName, purpose, owner, business capability, lifecycle, risk tier.
Source and artefactsRepositories, build outputs, registries, deployment artefacts.
Runtime and infrastructureApplication components, hosting services, environments, cloud resources.
Software dependenciesLibraries 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 dataAPIs consumed and exposed, data domains read or written, data classification, entitlements, retention obligations.
Identity and secretsUser, workload and agent identities, roles, references to secrets, certificates and keys, rotation policy. Never put secret values in the BOM.
Agents in the productA 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 operationsPipeline templates, environments, observability, alerting, support ownership.
Controls and evidenceThe 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 fieldsThe 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

A six-value classification line joins anatomy tier, pattern family, agency class, risk tier, data class and reuse generation, read by catalogue search, policy-as-code and the pattern arbiter.

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.

FieldValuesDefined inWhat reads it, and what it changes
Anatomy tierInfrastructure 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 seventhApplication anatomyWhich tier controls attach. Catalogue search (“what else lives here?”)
Pattern family and codeModel 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 CRecipe catalogueSearch, for example “which products depend on permission-aware retrieval?” before you change it. The pattern arbiter compares a design with its siblings
Agency class0 single call, 1 grounded answer, 2 workflow, 3 bounded agent, 4 multi-agentChoose the AI product shapeControl 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 tierThe firm’s own AI risk classificationRisk tiersSelects the control bundle and caps the autonomy ceiling
Data classC1 public, C2 internal, C3 confidential, C4 strictly confidential. Four flags travel with the class: personal data, client-identifying data, MNPI, statutory-retention recordsFirm classification policyWhich hosting routes, models and logging options are allowed. Policy pack selection
Reuse generationG0 to G4 (below)This pageWhat 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
Layoutanatomy tier / pattern family | agency class | risk tier | data class | reuse generationlayer / pattern | agency class | action scope | risk tier | data class | reuse generation
Examplereasoning and orchestration / WF-ROUTE | class 2 | tier 2 | C3 | G3L3/WF-ROUTE | A2 | Draft | Tier-2 | C3 | G3
Action scopeNot in the line. “What a design does” (read-only, draft, act with approval, act autonomously) is treated as the autonomy ladder viewed at design timeA 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:

  1. 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.
  2. 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.
  3. 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).

GenerationUnit of reuseThe next consumerEntry criteria (Working Paper 01)Examples
G0 ad hocNothing formalRebuilds itNonePilot notebooks, one-off scripts
G1 shared codeLibraries, prompt templates, IaC modulesImports or copies it, then operates itVersioned repository, owner, README, classification line in the manifestDocument parser library, prompt library
G2 platform serviceMulti-tenant service run by a platform teamCalls an APISLO, on-call rota, tenancy model, cost allocation, security reviewModel gateway, retrieval service, evaluation harness
G3 composable capabilityTools and agents behind standard protocolsFinds it in the catalogue and binds to itMCP or A2A interface, capability description, golden evaluation set, agent identity, accountable ownerCustomer-data MCP server, KYC-document agent
G4 governed recipeA solution shape: a pattern composition with a pre-approved control bundle and templatesFills in parameters and runs a pipelineArchitecture 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:

FieldWhy
OwnerSomeone answers when it misbehaves
VersionChanges are visible and reversible
Certification tier: sanctioned, certified, contributed or quarantinedBook 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 productsA change to the asset can be traced to the products it affects
Classification lineSame 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 kindMeaningExample
Automated actionThe factory performs it with no human decisionCreate an environment, run a scan, publish a signed artefact
Policy gateA machine checks a condition and allows or blocks progressDeny production data access until classification and entitlement checks pass
Human decisionA named person applies judgement and records the decisionAccept 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.

A product BOM expands into component BOMs while the product recipe invokes owned sub-recipes.

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

SlotAzure (Book 2 reference)AWSGoogle Cloud
Infrastructure modulesBicep modules as Template Specs, or via Deployment StacksCloudFormation, CDK, TerraformTerraform, Config Connector
IdentityEntra IDIAM Identity Center with IAM rolesCloud Identity with Workload Identity Federation
ScanningMicrosoft Defender for CloudAmazon Inspector plus native SBOM exportSecurity Command Center
Data classificationMicrosoft PurviewMacieSensitive Data Protection
API registrationAzure API ManagementAPI GatewayApigee or API Gateway
SecretsKey VaultSecrets Manager or Parameter StoreSecret Manager
TelemetryApplication InsightsCloudWatchCloud 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

One versioned BOM and recipe is read by the pipeline, the coding agent and the auditor; delivery actuals and proposed corrections update its history.

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.

  1. 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.
  2. 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.
  3. Move both into the repository beside the code, together with the standing-instruction file.
  4. Version from now on. Make the next product change a change to its description, in the same commit.
  5. 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.
  6. Add readiness grades to the components most often changed.
  7. 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.
  8. 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-patternRecognise itRecover
BOM as a compliance documentIt lives in a governance system, and its last-modified date trails the product’s by weeksMove it beside the code and make it a required part of every change
Recipe as a Word documentThere is no path from the document to an executed step, and agents invent around itMove steps towards templates, modules and policy-as-code. Leave only genuine judgement points as prose
Over-standardising too earlyThere are more recipes than patterns in use, and teams file exceptions more often than they follow the patternGo back to the one or two most common patterns and make them excellent. Let demand pull the others in
Frozen specOne spec version against fifty deploymentsBind spec changes to product changes in the same commit, and give the spec a queryable history
Human-only specAgent output is plausible but consistently off convention in small waysMake the load-bearing parts structured: named components, patterns and constraints
Per-team islandOne product described in several places that no single query can reconcile, with collisions found at merge timeMake 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.

FailureGate responseRecovery
Missing or conflicting classification lineStop before tool or data access or provisioning, and route to the classification ownerResolve from the authoritative decision record, amend the spec and validate again
Classification value that no mechanism readsFlag in reviewWire it to its consequence or remove it
Component version mutable or unresolvedBlock reproducible releasePin the resolved version, run build and evaluation again, and record the rationale
Component missing a readiness gradeRoute to the human or mixed laneGrade the component; the lane can change at the next work order
Agent definition, prompt library or MCP server not on the BOMTreat it as ungoverned and keep it out of the paved contextRegister it with owner, version, tier and consumers
Control exists only as proseTreat it as advisory. Do not claim the gate passedImplement a deterministic check, or keep an explicit human control with an owner and evidence
Deployed actuals differ from the approved BOMPause rollout according to release policy, and keep both recordsEstablish what ran, then roll back or approve a corrected spec. Never rewrite the historical approved BOM
Component recipe upgrade breaks a consumerStop promotion for affected consumers and keep the last compatible pinTest 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)

← All AI Delivery Factory guidance

On this page

  1. What the BOM records
  2. The classification line
    1. Book 2’s line versus Working Paper 01’s code
  3. Reuse generations, G0 to G4
  4. Grade each component for agent readiness
  5. Make the factory’s own working material catalogue citizens
  6. Make the recipe executable, step by step
    1. Fill the slots per provider (vendor-specific)
  7. Harvest the recipe from an exemplary team
  8. Keep one living specification
  9. Implement incrementally
    1. Example change record: a model or prompt update
  10. Anti-patterns
  11. Gates, failures and recovery
  12. Source lineage

All pages in Design →