The AI Delivery Factory: Operating Model
The factory's six connected parts, the control gap it closes, the handover curve that governs what agents may take over, and how to start one without rebuilding your tooling.
- 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
- Understand
- Source works
- Book 1 · Book 2 · ADD proposal · Whitepaper · Book 09
- Source chapters
- 1, 2, 3, 5, 6, 7, 8, 9, 16, 28
- Refresh trigger
- source change
Use this page to explain what an AI Delivery Factory is, why a firm needs one, how its parts fit together, and how to decide which delivery work agents may take over. It is an operating model for delivering software at machine speed while keeping architecture, accountability, control and evidence attached to the work. The agent-speed SDLC applies it to a single change; this page covers the estate.

At a glance: agents raise the arrival rate of change past human review capacity. The detailed diagram is under The problem: a control gap that opens silently. Source: The AI Delivery Factory, Chapter 1, Figure 1.1.
The problem: a control gap that opens silently
Before assistants, the effort of writing a change throttled how fast changes arrived, and that throttle happened to match the pace of human review. Assistants remove the throttle on the supply side only. The control gap is the distance between the rate change arrives and the rate the firm can understand and stand behind it (Book 2 Ch 1 §5). Three properties matter:
- It is invisible on the standard dashboard. Throughput, green builds, deployment frequency and change-failure rate all measure the production line. Almost nothing measures control capacity. A green build shows the code ran, not that anyone understood it; an approval shows the workflow completed, not that the reviewer proved anything.
- It cannot be closed by pushing review capacity up. Senior reviewers cannot be produced in a quarter, and good review does not parallelise. More reviewers and more approval steps buy delay, not understanding.
- It closes from the arrival side. Change the shape of the work: route low-risk, well-evidenced change to automated approval with a full evidence record, and keep human attention for change that earns it (change governance).

The control gap between the arrival of plausible change and review capacity. Source: The AI Delivery Factory, Chapter 1, Figure 1.1.
The queue does not disappear when routing clears it; it migrates to the shared, old, central stations that did not accelerate. Agent readiness explains how to find them.
Three-question control-gap diagnostic
Run this before any programme decision:
| Question | Evidence to pull (last 90 days) | Finding if… |
|---|---|---|
| What is our arrival rate of change, and is it rising? | PR volume, generated tests/config/IaC, change requests, AI-assisted-change ratio | Rising volume concentrated in high-adoption teams |
| What is our control capacity, and is it flat? | Review latency, reviewer load, ownership exceptions, security waivers, approval exceptions | Latency rising where adoption is high, flat where it is low |
| Are we measuring the second line at all? | Whether capacity measures appear in the same report as throughput | Capacity is tracked by hand, privately, or not at all |
Put high- and low-adoption review-latency curves on one chart; that chart is the business case for the factory. Then ask the risk committee to name a control-capacity limit: at first a proxy such as the review latency beyond which a domain is deemed over capacity, read by the same committee that reads throughput. Book 2 later formalises this as a risk-officer-signed control budget. Composite example (Book 2 Ch 1 §6, Asset Manager X): roughly 900 engineers and 340 repositories, PR volume up on the order of forty per cent, median review latency roughly tripled in three heavy-adoption domains, and audit evidence of human oversight that came back as screenshots. These are illustrative composite figures, not benchmarks.
The six connected parts
| Part | What it does | The question it answers |
|---|---|---|
| Product intent | Records the business problem, intended outcome, users and constraints before implementation. | What are we building, for whom, and why? |
| Recipe | Declares the approved way to assemble, govern, release and evidence a product. | How should this kind of product be built? |
| Bill of material (BOM) | Records the product’s components, dependencies, controls and versions. With its recipe, it forms a living specification. | What does the product contain? |
| Production line | Provides the standard foundation, workspaces, identity, pipelines, release path and evidence capture. | How does approved change move safely into production? |
| Control loop | Compares policy, audit evidence and actual operation; findings feed back into policy and delivery. | Is the factory operating as intended? |
| Evidence stream | Emits a queryable record at the seams of delivery and operation. | Can we show what happened, who was accountable and what followed? |
Intent constrains the recipe; the recipe and BOM guide work on the production line; the line emits evidence; the control loop compares evidence with policy and actuals and improves the next cycle. See BOM and recipes, policy–audit–actuals and audit evidence.
Two worker classes, one accountable system
The factory combines deterministic automation with coding agents. Scripts do the parts of delivery that must be identical every time. Agents do the variable work (drafting, code changes, analysis) inside the factory’s constraints. Product teams stay accountable for intent, risk, architecture decisions, approvals and acceptance. Each agent has a named agent wrangler who owns its behaviour and reviews its work (accountability).

One accountable product team, two classes of worker; agent output is owned by a named wrangler. Source: The AI Delivery Factory, Chapter 7, Figure 7.1.
Factory rule: automate repeatable mechanics and enforce mandatory controls deterministically. Keep human judgement at the decisions that set purpose, risk, policy exceptions and production authorisation.
The seven jobs of the automation factory
Book 2 (Ch 16 §4.1, §4.5) lists six jobs the pre-agent automation factory already did and one the agent era adds. All seven are provisioning jobs run by deterministic scripts. The Owner column is this page’s recommendation except for job 7, where Book 2 requires a named owner of the injection pipeline:
| # | Job | Output | Owner |
|---|---|---|---|
| 1 | Scaffold product structures from approved recipes | Repositories, baseline code, docs, test projects, IaC modules, pipeline definitions | Platform team |
| 2 | Provision environments through approved landing-zone patterns | Environments without one-off tickets (landing zone) | Platform / cloud team |
| 3 | Configure controls with the product, not after it | Identity, secret stores, policies, scans, approvals, logging, telemetry | Platform team with control owners |
| 4 | Register the product | Owner, business capability, risk classification, BOM, APIs, dependencies, environments, evidence obligations | Platform team; product owner confirms |
| 5 | Publish evidence in the firm’s one format | Pre-attributed records into the audit spine | Platform team |
| 6 | Upgrade products as recipes evolve | Factory-generated upgrade pull requests | Platform team; product owner merges |
| 7 | Compile the catalogue into context | Certified slice of the capability catalogue injected into standing-context files and tool configuration at provisioning; re-run when the catalogue changes; versioned with the workspace | Named owner of the injection pipeline (a control surface with an audit trail) |
The seventh job exists because agents do not browse a catalogue; an asset not in their context does not exist for them, so they rebuild it. What is injected is decided by computed certification tiers (sanctioned and certified injected by default; contributed reachable on request; quarantined never), not by committee. Reuse generation is recorded per asset beside the tier. See running the factory and the research paper Reusability and the Compounding Factory.
Three architectural claims to test your factory against
Book 2 (Ch 16 §5) holds the framework together with three claims. If any is aspirational rather than built into the provisioning path, build that next.
- Both worker classes work inside one boundary. Recipe and workspace constrain scripts and agents alike. No looser regime for agents on laptops with free tool choice.
- Provisioning precedes generation. Workspace, controls and evidence emission exist before the first artefact is produced.
- The human gate is on output, not effort. Wranglers review what merges and deploys; bounding the workspace shrinks what that review must cover.
Meeting two of the three gives a script collection with an agent bolted on.
Where your estate stands
Agents fit where the estate is industrialised and flood where it is not. Use three lenses before deciding where agents go.
Five stations of delivery industrialisation
Book 2 (Ch 2 §5) describes five overlapping stations. Each absorbs a class of undifferentiated work. Assess per domain, not per firm: one firm can be at station four on its reporting estate and at station two on its legacy core.
| Station | What industrialises | Still bespoke |
|---|---|---|
| 1. Craft | Nothing; context held in people | Everything |
| 2. Scripted automation, CI/CD, everything-as-code | Assembly | The environment builds land in |
| 3. Cloud and infrastructure as code | Provisioning | The developer’s path through it |
| 4. Platform engineering and paved roads | The developer experience of delivery | Judgement-laden domain work |
| 5. Agent-driven factory | Variable work, done by agents inside stations 1–4’s constraints | Only what the constraints do not yet cover |
Per domain, ask: how many application patterns do you actively support; how long from approved idea to repository, pipeline, environment, identity, logging and a first deployable skeleton; what evidence a standard deployment produces without manual effort. Vague answers are the finding. Where a domain is at station four, let agents in deliberately. Where it is at station two, finish the road before you widen agents. Sequence by exposure: domains where agent use is widening fastest and domains touching a critical or important function first.
Five places craft-alone delivery breaks
Use these as a symptom checklist; they share one root, excellence held in memory rather than structure (Book 2 Ch 3 §4.2):
| Break point | Symptom |
|---|---|
| Onboarding | New joiners take months to be useful; conventions learned by apprenticeship |
| Security | Strong policies, uneven enforcement across repositories |
| Architecture | Reference design on paper; live systems forked into local variants |
| Operations | Incident response depends on who knows the system |
| Audit | Every supervisory request becomes a small project (“audit as archaeology”) |
Seven operational gaps beneath a red status
When a target-operating-model review marks one item red, do not assign a single workstream. Book 1 (Ch 1 §4.6, §8.6) lists seven gaps from unfinished earlier transformations that usually sit underneath:
- SOPs not updated for the current platform; the agent inherits an undefined boundary.
- Cloud adoption mid-journey: landing zone provisioned, governance not; inconsistent baselines and tagging.
- Data catalogue incomplete: no governed inventory or lineage, so the agent cannot be told which source to trust.
- Shift-left declared, not achieved: no reliable autonomous deployment, so agent registration, update and retraction run at the wrong cadence.
- Planning not code: no machine-readable record of each agent’s mandate and authority.
- Machine identity processes not built, although the platform primitives exist.
- Development and operations without a shared ledger: the hand-off from repository to service-management tool is a person re-keying data.
The gaps compound; closing identity without fixing SOPs leaves an agent operating against undefined procedures. Treat the red item as the entry point to this diagnostic.
The handover curve: governing what agents take over
The handover curve relates the maturity of the structure you give agents (machine-readable system descriptions, standing context, encoded skills) to the share of delivery work agents carry (Book 2 Ch 3 §4.3, §5; Book 09 Ch 2). Work moves over in a predictable order: repetitive, well-bounded operations first; judgement last or never. The reason is reliability: agents do well on work whose inputs and acceptable outputs can be written down and checked automatically, and a genuinely new decision has no such description, because writing one would mean making the decision.

The share of delivery work agents carry rises with earned structural maturity, not by a switch. Source: The AI Delivery Factory, Chapter 3, Figure 3.1.
Three zones
| Zone (Book 2) / stage (Book 09) | Who does what | Boundary that must be built | Example |
|---|---|---|---|
| 1. Assisted | Agent accelerates a human who reads every step; the human is the control | A person reading the diff | Autocomplete; a proposed change read line by line |
| 2. Delegated | Agent performs a whole operation and reports; owner reviews the outcome, not the steps | All three delegation conditions (below) | Nightly break triage; routine schema migrations; a standard service from a recipe |
| 3. Autonomous within guardrails / limits | Agent initiates and completes recurring operations without a human trigger | Guardrail machine-enforced and continuously tested; earned rung by rung on the autonomy ladder | Pre-agreed standard changes; remediation of known conditions |
Very little of a regulated estate belongs in Zone 3 as of 2026 (Book 2). Do not attempt Zone 3 anywhere until Zone 2 handovers hold with evidence.
Terminology: Book 2 says “zones” and “autonomous-within-guardrails”; Book 09 says “stages” and “autonomous within limits”. They describe the same model; this page uses Book 2’s zone numbers with both labels. The ADD proposal’s earn-it trust levels for event-driven agents (advisory → controlled execution → autonomous standard change) are a runtime-autonomy layer for a single agent; the handover curve classifies delivery activities. Use both: an activity’s zone caps the trust level its agent can hold. The bounded-agent page and risk tiers cover the autonomy ladder and re-tier triggers.
Conditions for delegation
An activity may enter Zone 2 only when all three hold (Book 2 Ch 3 §5; Book 09 Ch 2):
| Condition | Acceptance check |
|---|---|
| Described by a schema/description the agent can read | The input and acceptable output are written down where the agent reads them, not in a slide deck or a person’s habit |
| Bounded: runs inside a bounded-agency envelope | Declared mandate, constrained tools and data, scoped memory, monitoring (bounded agent) |
| Evidenced: emits evidence on every run | An Audit Evidence Schema record per run, answerable in one query (audit evidence) |
Missing any one, the activity is not in Zone 2, whatever the agent’s capability. An activity in Zone 2 whose evidence you cannot produce is in Zone 1 with nobody reading the steps.
Shape and steepness
The curve is an S. The early rise is slow: the first schemas and context files are expensive and hand over little, and firms give up here, mistaking foundation cost for evidence that the technology does not work. The middle is steep once enough structure exists. The top flattens against work that is judgement and never hands over. Steepness is set by structure, not tools: two firms with identical licences can sit at opposite ends.
Diagnose a stuck activity by the missing input:
| Input | Question |
|---|---|
| Schema maturity | Is the system described in a form an agent can consume? |
| Context maturity | Are the architecture and its constraints written where the agent reads them? |
| Skill maturity | Is the operation encoded as a repeatable procedure, not a habit? |
There is one curve per station of the estate. How much an agent can safely do in a given system is set by how cheaply that system catches a wrong change, not by model capability. Book 2 (Ch 3 §4.3) names tests that assert behaviour, types, a deterministic build and fast checks; Book 09 (Ch 2) adds whether a change can be undone cheaply and whether its effect is visible. Grade stations with agent readiness and the research paper Technology Management and Agent Readiness.
Demotion is information
Work moves back along the curve as well as forward. Composite example (Book 2 Ch 3 §6; Book 09 Ch 2, Asset Manager X): after two clean Zone 2 handovers (break triage, schema migrations), the team gave an agent a matching-logic redesign. It passed every generated test, because those tests came from the same flawed spec, and it quietly replaced a configured tolerance. The architect, reviewing second, caught it. The team moved matching-logic changes back to Zone 1 and wrote that boundary into the recipe.
- Treat a pulled-back activity as a mis-classification corrected, not a failure. Record why, and encode the boundary in the recipe.
- Watch for judgement dressed as operation: work that looks mechanical but encodes a risk decision (tolerances, thresholds, matching rules). Those stay human.
- A Zone 2 handover that has absorbed a judgement call is a classification error to fix, not a productivity win to defend.
The handover backlog
Make the curve operational with one sheet per team (Book 2 Ch 3 §7):
- Pick an exemplary team and refuse “good engineers” as the explanation. Extract its hidden structure (templates, review habits, dashboards, runbooks, ownership, deployment and test discipline) as a candidate recipe.
- List a week of the team’s work; mark each activity repetitive or judgement-laden.
- For each repetitive activity, record the columns below.
- Review monthly with someone senior enough to say no: what moved zone, what is queued, what was pulled back.
| Activity | Current zone | Target zone | Missing input (schema / context / skill) | Delegation conditions met (described / bounded / evidenced) | Named owner (wrangler) once moved | Last review / pull-back note |
|---|---|---|---|---|---|---|
| e.g. nightly break triage | 1 | 2 | none | yes / yes / yes | named engineer | moved, holding |
| e.g. matching-logic redesign | 2 | 1 | n/a (judgement) | n/a | architect | pulled back; boundary added to recipe |
Columns are this page’s recommendation from the source description. Run it like a risk register: named owners, a review rhythm, and a preference for moving one activity properly over ten hopefully. Large firm: three exemplary teams in parallel, named wranglers from the first handover. Smaller firm: one team, one Zone 2 handover done properly, used as the reference.
Governance layering and programme sequence
Two other source models describe the same journey at different altitudes. Use them as layers on top of the six parts, not as replacements.
Three-layer governance model, foundations first (Whitepaper Part II §3):
| Layer | Contents | Owner |
|---|---|---|
| Foundational controls | Data governance, identity, network segmentation, regulatory alignment | CIO / head of cloud (landing zone, identity and secrets) |
| Model lifecycle governance | Versioning, provenance, drift monitoring, red-teaming, guardrails in the delivery workflow | Delivery and model owners (release engineering, model governance) |
| Operational governance | Real-time oversight, incident playbooks, platform-enforced action boundaries, named owner per agent | Operations and wranglers (agent lifecycle) |
Sequencing rule: build foundations, then lifecycle, then operational governance. Back-filling foundations after agents are live turns lifecycle obligations into paperwork.
Five-stage progression (Whitepaper Part III §1), with stage outputs:
| Stage | Output |
|---|---|
| Assess | Evidence-led readiness baseline across the three layers and a prioritised closure plan |
| Govern | A small set of platform-enforced policies (the whitepaper suggests typically fewer than ten), accountable owners, risk appetite |
| Build | Deployable reference architecture: identity, network, observability, integration |
| Deploy | Per agent: registry entry, populated boundary record, operational handover, named owner |
| Operate | Continuous evidence trail, drift detection, incident response, resilience testing |
The six-step sequence below is the delivery-level version of Build–Deploy–Operate for one product line. A fuller adoption roadmap is not yet on this reference.
Put the model into operation
Treat the factory as linked records and gates, not a platform purchase. Build it against a real, hard change (a migration exercises every part) and keep only the parts that do work on that change.
- Choose a bounded change path. One product team and one recurring change type with a visible queue or hand-off cost. Record baseline elapsed time, review latency, escaped defects and recovery path.
- Map the manual setup for one product type. Every ticket, hand-off and wait, with elapsed time, rework and control risk. Automate first the step where friction and control risk are both high, not the one that demos well: repository creation with branch policies, pipeline creation, secret-store provisioning, logging, evidence publishing. Do not skip evidence publishing.
- Make intent and product shape explicit. Outcome, owner, users, data class, risk tier and agency class (choose AI product shape).
- Compose the product specification. Pin foundation, recipe, dependencies, model/tool versions, controls and evidence obligations; record deviations with owner and review date.
- Provision agent workspaces exactly as human ones. Same repository shape, locked toolchain, standing context, isolated runtime, identity and evidence bindings. Agents on laptops with human credentials move to purpose-built runtimes before you scale.
- Seed the shared evaluation harness from your last three software-caused incidents, each reduced to an executable case wired into every merge path. From then on, no incident review closes until its evaluation case is contributed (evaluation and resilience).
- Ask one business expert for twenty golden records (verified input–output pairs, catalogued under their name) for your closest-to-production AI product.
- Close the unregistered path. If an unregistered model, agent or tool can obtain a credential or route today, close that first; it makes every other control enforceable.
- Run work through the line and close the loop on actuals. Commit intent, spec, plan, changes and results in order; bind the release identifier to what was deployed, approvals and observations; make discrepancies actionable.
- Name the factory as a product. Owner, backlog, support model, versioning approach, adoption metric. This includes the injection pipeline and the evaluation suite. Build the upgrade path before scaling creation.
- Expand only after the path is repeatable. Reuse the foundation for a second product; promote improvements through versioned components.
Scale: in a 50,000-person institution this is a platform team’s flagship product maturing over quarters; in a 1,000-person firm, one or two engineers can have a first slice (one recipe, one provisioning path, one evidence seam, one agent workspace) inside a month. The controls do not shrink with the firm.
Wrap, do not rebuild
Adopt the factory by wrapping existing tooling at its seams (the strangler-fig pattern, Book 2 Ch 16 §4.11):
| Existing tool | Keeps doing | Wrapped so that |
|---|---|---|
| CI/CD pipeline | Building and testing | Each step emits a signed evidence record |
| Change-control process | Meeting and deciding | The decision is captured in the firm’s evidence format |
| Deployer | Deploying | Every deployment carries a manifest with mandatory verification and rollback |
| Identity provider, model usage registry, data catalogue | Their current role | The audit spine consumes them rather than duplicating them |
Provision one workspace, wrap the seams it touches, dispatch one agent, read the evidence, then widen.
Decision record for the first production line
| Record | Minimum content |
|---|---|
| Scope | Product, change type, repositories/services and explicit exclusions. |
| Accountabilities | Product owner, agent wrangler, platform owner, risk/control owner and release approver. |
| Boundaries | Risk/data classification, agency allowed, handover zone per activity, permitted tools and systems, prohibited actions and escalation route. |
| Enforced path | Required artefacts, machine gates, human decisions, evidence identifiers and release/rollback mechanism. |
| Success and stop conditions | Baseline and target measures, including review latency and the control-capacity proxy; pause triggers such as missing provenance, failed controls, untraceable changes or an untested recovery path. |
| Review | Decision date, approver, unresolved assumptions and the date or event that triggers reassessment. |
This is an implementation recommendation, not a universal control standard. A failed mandatory gate stops promotion and preserves the failed evidence. Recovery means correcting the source artefact or control, rerunning the affected checks and recording a new decision; editing evidence to make a release look compliant defeats the control loop.
Is it a factory or a pile of tools?
Run a genuinely hard change and watch where the effort goes (Book 2 Ch 28 §7):
| Effort goes into… | You have… |
|---|---|
| Provisioning, chasing approvals, reconstructing evidence, remembering hidden dependencies | Tools |
| Product risk, data meaning, integration strategy, rollback design | A factory |
A factory does not remove expertise; it stops wasting it. Run the test on each major migration and record the split.
Anti-patterns
| Anti-pattern | Recognise it | Recover |
|---|---|---|
| Filing it under productivity | AI programme has a throughput case and no control-capacity line | Put control capacity on the same dashboard as throughput |
| Funding on throughput alone | Every number deciding the next funding round measures production | Write the control-capacity limit into the funding, reviewed by the same committee, with power to throttle |
| More meetings and gates | Cycle time worsens after a “governance improvement” that caught nothing | Route by risk and automate checks |
| Banning the tools | Policy says no AI coding; assistants are in every editor | Legitimise the tools inside the factory (recipe, wrangler, routing gate) |
| Permanent “AI code” special case | A change’s route depends on how it was typed, not its risk | One delivery system that records how work was produced and controls by risk |
| Pushing governance down to teams | ”Human oversight” is a sentence with no shared machinery | Give teams a platform where the governed path is the easy one |
| Bolt-on: agents onboarded as ordinary applications | Agents pass a CAB built for human software, get generic service accounts, appear as one inventory line; nobody can list each agent’s tools or reasoning trail; risk register files them under generic operational risk | Govern agents as a distinct actor class: own identity, registered tools, reasoning-level evidence, named owner (enterprise control plane). The whitepaper names the dominant incident categories at European banks and insurers past pilot as control-plane shortfalls, not model defects: misconfigured tool access, undifferentiated runtime authority, irreversible actions without a gate, missing reasoning observability |
| Tool accumulation mistaken for a factory | Every tool can be named; no supported application pattern can | Choose one paved road and make it easier than the alternatives |
| Local excellence hiding a weak model | Proof that “it works” is always the same two teams | Extract those teams’ pattern into a recipe |
| Hero preservation | ”That team is different” | Extract the exemplary team’s recipe first, while its people can explain it |
| Tooling theatre | Licences deployed; estate still run on memory | Measure what hands over, not what is installed |
| Moving judgement, not operations | Agent output merged on questions of taste and trade-off | Draw the line in the recipe; reclassify |
| Ungoverned steepness | You cannot say in one query what an agent did last Tuesday | Stop advancing the curve until every handed-over activity is bounded and evidenced |
| Rigid standardisation | Exceptions vanish from the record because declaring one is punished | Make deviation cheap to declare; treat it as a missing guideline |
| Industrialisation as a programme | The platform has an end date, not a roadmap | Fund the factory as a standing product |
| Scaffolding without lifecycle | Factory-built products drift from the recipe; module versions spread | Build factory-generated upgrade PRs before scaling creation |
| Generating faster than the platform governs | Evidence assembled for audits; agent PRs carry no agent identity | Pave first, then dispatch |
Lessons from data mesh
Book 2 (Ch 2 §4.7) reads data mesh as a parallel experiment the factory is designed against. The convergent moves are domain ownership, exhaust as product, a funded self-serve platform and computational governance. The documented failure pattern in large financial institutions:
- Ownership mandated, platform never funded to product standard.
- Hand-curated catalogues rotted. The factory registers what it builds as a pipeline by-product.
- Governance stayed in policy portals, not the platform. The factory runs the policy–audit–actuals loop in the platform.
- A branded paradigm gave boards one thing to cancel. The factory is funded as a product with measured outcomes.
The differences also matter. The mesh assumed every actor was a human who could be held to account; it let a federation negotiate rules that, in a regulated firm, the supervisor sets; and it was often built greenfield where the factory wraps existing tooling. Book 2 cites vendor retrospectives for the pattern only and quotes no adoption statistics; neither does this page.
Provenance and status
The six-part model, control gap, five stations, five break points, handover curve, automation-factory jobs, three claims, start-up actions, strangler-fig adoption and effort test are synthesised from The AI Delivery Factory (Book 2), Chapters 1–3, 5–9, 16 and 28. The seven operational gaps come from Building Organizations for the Age of AI (Book 1), Chapter 1. Book 09, Everything Is Green, Draft 1 (14 November 2026), contributes the plain-language stage names and the “move back is information” framing in its Introduction and Chapters 1–2; it does not replace Book 2’s technical treatment. The three-layer model, five-stage progression and bolt-on pattern come from the whitepaper Building Organisations for the Age of AI; its survey statistics are composite signals and are not repeated here. The ADD proposal supplies the earn-it trust levels. Asset Manager X and its people are composites, not customer evidence. Regulatory obligations referenced by the sources are on the regulatory map. The handover backlog columns, operating sequence and decision record are reference recommendations. This page is a draft.
Source material
- Book 2, Chapter 1: The Day the Review Queue Broke (§4–§5 the control gap; §7 Monday actions; §8 anti-patterns)
- Book 2, Chapter 2: Software Delivery Was Already Industrialising (§4.7 data mesh; §5 five stations; §7; §8)
- Book 2, Chapter 3: Why Craft Alone No Longer Scales (§4.2 five break points; §4.3 and §5 the handover curve; §7 handover backlog; §8)
- Book 2, Chapters 5–9 (BOM and recipes, foundation, product teams, policy–audit–actuals loop, audit spine) as referenced
- Book 2, Chapter 16: The Automation Factory (§4.1 six jobs; §4.5 the seventh job; §4.11 adoption by wrapping; §5 framework and three claims; §7 start-up actions; §8)
- Book 2, Chapter 28: Mary's Migration, Rewritten (§7 factory-versus-tools test; §8)
- Book 1, Chapter 1: The Adoption Gap (§4.6 seven operational gaps; §8.6)
- Book 09, Introduction and Chapters 1–2 (Draft 1; handover curve stages, conditions for delegation, moving work back)
- Whitepaper: Building Organisations for the Age of AI, Part I §1–2 (bolt-on pattern), Part II §3 (three-layer governance model), Part III §1 (five-stage progression)
- ADD proposal, Strategic Brief §4a.5 (earn-it trust levels)
Related guidance
-
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. -
Change Governance for Agent-Enabled DeliveryRoute agent-speed change by risk without losing the approver: control values that always reach a person, a routing gate that reads the right signals, autonomy earned per change family, a Virtual CAB that prepares a complete dossier, and three bodies with defined escalation. -
Release Engineering for Agent-Written ChangeMove agent-speed change into production through five evidence-emitting stations: one change type per change, a reversal decided at authoring, a valid Deployer Manifest, a gateway that cannot be bypassed, hard health gates and at-most-once rollback. -
Build a Living Product Bill of Material and RecipeDescribe 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. -
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. -
Prepare a Governed Landing Zone for AI DeliveryDesign the management-group hierarchy, enforce guardrails in deny mode, give humans and agents the same paved workspace, integrate the eight agent-platform components, close the perimeter, and prove the zone is done with seven observable exit criteria and a second-line sign-off. -
Bounded-Agent PatternA class 3 agent lets a model choose the next step, but only inside a registered, validated and enforced envelope of Mandate, Means, Memory and Monitoring. -
Accountability and OwnershipHold provenance and accountability apart on purpose: four named accountabilities per product, a human owner for every agent change, seven named seats, a signed Build/Run RACI and a first-line/second-line boundary that survives consolidation. -
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. -
Evaluate, Assure and Test Agent ResilienceDefine a versioned evaluation contract, test the trajectory and the execution boundaries, run three assurance layers into one quarterly pack, map the OWASP Agentic Top 10 to controls that demonstrably fire, bring agents into threat-led penetration testing with a five-section scope, keep a continuous cadence between formal tests, land every finding as a live control-plane artefact, and engineer recovery down to a minimal AI service level on models you host. -
Run the AI Delivery FactoryOperate demand, capacity, the two worker classes, exceptions and evidence as one service: read two leading numbers, keep a handover backlog, gate construction on three conditions, run queues and alerts at agent volume, and count unused products as cost.