Browse the reference ⌄
Concept published

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

Full source list ↓ Source index →

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.

Agents raise the arrival rate of change past human review capacity; the gap is where control is silently lost.

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:

  1. 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.
  2. 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.
  3. 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).
AI-assisted change arrives faster than human review capacity, widening the control gap. The axes are conceptual, not measured.

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:

QuestionEvidence 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 ratioRising volume concentrated in high-adoption teams
What is our control capacity, and is it flat?Review latency, reviewer load, ownership exceptions, security waivers, approval exceptionsLatency 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 throughputCapacity 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

PartWhat it doesThe question it answers
Product intentRecords the business problem, intended outcome, users and constraints before implementation.What are we building, for whom, and why?
RecipeDeclares 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 lineProvides the standard foundation, workspaces, identity, pipelines, release path and evidence capture.How does approved change move safely into production?
Control loopCompares policy, audit evidence and actual operation; findings feed back into policy and delivery.Is the factory operating as intended?
Evidence streamEmits 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 holds two classes of worker, human and agent; agent output is owned by a named wrangler.

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:

#JobOutputOwner
1Scaffold product structures from approved recipesRepositories, baseline code, docs, test projects, IaC modules, pipeline definitionsPlatform team
2Provision environments through approved landing-zone patternsEnvironments without one-off tickets (landing zone)Platform / cloud team
3Configure controls with the product, not after itIdentity, secret stores, policies, scans, approvals, logging, telemetryPlatform team with control owners
4Register the productOwner, business capability, risk classification, BOM, APIs, dependencies, environments, evidence obligationsPlatform team; product owner confirms
5Publish evidence in the firm’s one formatPre-attributed records into the audit spinePlatform team
6Upgrade products as recipes evolveFactory-generated upgrade pull requestsPlatform team; product owner merges
7Compile the catalogue into contextCertified slice of the capability catalogue injected into standing-context files and tool configuration at provisioning; re-run when the catalogue changes; versioned with the workspaceNamed 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.

  1. 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.
  2. Provisioning precedes generation. Workspace, controls and evidence emission exist before the first artefact is produced.
  3. 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.

StationWhat industrialisesStill bespoke
1. CraftNothing; context held in peopleEverything
2. Scripted automation, CI/CD, everything-as-codeAssemblyThe environment builds land in
3. Cloud and infrastructure as codeProvisioningThe developer’s path through it
4. Platform engineering and paved roadsThe developer experience of deliveryJudgement-laden domain work
5. Agent-driven factoryVariable work, done by agents inside stations 1–4’s constraintsOnly 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 pointSymptom
OnboardingNew joiners take months to be useful; conventions learned by apprenticeship
SecurityStrong policies, uneven enforcement across repositories
ArchitectureReference design on paper; live systems forked into local variants
OperationsIncident response depends on who knows the system
AuditEvery 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:

  1. SOPs not updated for the current platform; the agent inherits an undefined boundary.
  2. Cloud adoption mid-journey: landing zone provisioned, governance not; inconsistent baselines and tagging.
  3. Data catalogue incomplete: no governed inventory or lineage, so the agent cannot be told which source to trust.
  4. Shift-left declared, not achieved: no reliable autonomous deployment, so agent registration, update and retraction run at the wrong cadence.
  5. Planning not code: no machine-readable record of each agent’s mandate and authority.
  6. Machine identity processes not built, although the platform primitives exist.
  7. 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 handover curve: the share of delivery work agents run rises with earned maturity, not by a switch.

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 whatBoundary that must be builtExample
1. AssistedAgent accelerates a human who reads every step; the human is the controlA person reading the diffAutocomplete; a proposed change read line by line
2. DelegatedAgent performs a whole operation and reports; owner reviews the outcome, not the stepsAll three delegation conditions (below)Nightly break triage; routine schema migrations; a standard service from a recipe
3. Autonomous within guardrails / limitsAgent initiates and completes recurring operations without a human triggerGuardrail machine-enforced and continuously tested; earned rung by rung on the autonomy ladderPre-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):

ConditionAcceptance check
Described by a schema/description the agent can readThe 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 envelopeDeclared mandate, constrained tools and data, scoped memory, monitoring (bounded agent)
Evidenced: emits evidence on every runAn 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:

InputQuestion
Schema maturityIs the system described in a form an agent can consume?
Context maturityAre the architecture and its constraints written where the agent reads them?
Skill maturityIs 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):

  1. 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.
  2. List a week of the team’s work; mark each activity repetitive or judgement-laden.
  3. For each repetitive activity, record the columns below.
  4. Review monthly with someone senior enough to say no: what moved zone, what is queued, what was pulled back.
ActivityCurrent zoneTarget zoneMissing input (schema / context / skill)Delegation conditions met (described / bounded / evidenced)Named owner (wrangler) once movedLast review / pull-back note
e.g. nightly break triage12noneyes / yes / yesnamed engineermoved, holding
e.g. matching-logic redesign21n/a (judgement)n/aarchitectpulled 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):

LayerContentsOwner
Foundational controlsData governance, identity, network segmentation, regulatory alignmentCIO / head of cloud (landing zone, identity and secrets)
Model lifecycle governanceVersioning, provenance, drift monitoring, red-teaming, guardrails in the delivery workflowDelivery and model owners (release engineering, model governance)
Operational governanceReal-time oversight, incident playbooks, platform-enforced action boundaries, named owner per agentOperations 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:

StageOutput
AssessEvidence-led readiness baseline across the three layers and a prioritised closure plan
GovernA small set of platform-enforced policies (the whitepaper suggests typically fewer than ten), accountable owners, risk appetite
BuildDeployable reference architecture: identity, network, observability, integration
DeployPer agent: registry entry, populated boundary record, operational handover, named owner
OperateContinuous 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.

  1. 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.
  2. 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.
  3. Make intent and product shape explicit. Outcome, owner, users, data class, risk tier and agency class (choose AI product shape).
  4. Compose the product specification. Pin foundation, recipe, dependencies, model/tool versions, controls and evidence obligations; record deviations with owner and review date.
  5. 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.
  6. 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).
  7. Ask one business expert for twenty golden records (verified input–output pairs, catalogued under their name) for your closest-to-production AI product.
  8. 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.
  9. 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.
  10. 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.
  11. 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 toolKeeps doingWrapped so that
CI/CD pipelineBuilding and testingEach step emits a signed evidence record
Change-control processMeeting and decidingThe decision is captured in the firm’s evidence format
DeployerDeployingEvery deployment carries a manifest with mandatory verification and rollback
Identity provider, model usage registry, data catalogueTheir current roleThe 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

RecordMinimum content
ScopeProduct, change type, repositories/services and explicit exclusions.
AccountabilitiesProduct owner, agent wrangler, platform owner, risk/control owner and release approver.
BoundariesRisk/data classification, agency allowed, handover zone per activity, permitted tools and systems, prohibited actions and escalation route.
Enforced pathRequired artefacts, machine gates, human decisions, evidence identifiers and release/rollback mechanism.
Success and stop conditionsBaseline 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.
ReviewDecision 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 dependenciesTools
Product risk, data meaning, integration strategy, rollback designA 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-patternRecognise itRecover
Filing it under productivityAI programme has a throughput case and no control-capacity linePut control capacity on the same dashboard as throughput
Funding on throughput aloneEvery number deciding the next funding round measures productionWrite the control-capacity limit into the funding, reviewed by the same committee, with power to throttle
More meetings and gatesCycle time worsens after a “governance improvement” that caught nothingRoute by risk and automate checks
Banning the toolsPolicy says no AI coding; assistants are in every editorLegitimise the tools inside the factory (recipe, wrangler, routing gate)
Permanent “AI code” special caseA change’s route depends on how it was typed, not its riskOne 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 machineryGive teams a platform where the governed path is the easy one
Bolt-on: agents onboarded as ordinary applicationsAgents 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 riskGovern 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 factoryEvery tool can be named; no supported application pattern canChoose one paved road and make it easier than the alternatives
Local excellence hiding a weak modelProof that “it works” is always the same two teamsExtract 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 theatreLicences deployed; estate still run on memoryMeasure what hands over, not what is installed
Moving judgement, not operationsAgent output merged on questions of taste and trade-offDraw the line in the recipe; reclassify
Ungoverned steepnessYou cannot say in one query what an agent did last TuesdayStop advancing the curve until every handed-over activity is bounded and evidenced
Rigid standardisationExceptions vanish from the record because declaring one is punishedMake deviation cheap to declare; treat it as a missing guideline
Industrialisation as a programmeThe platform has an end date, not a roadmapFund the factory as a standing product
Scaffolding without lifecycleFactory-built products drift from the recipe; module versions spreadBuild factory-generated upgrade PRs before scaling creation
Generating faster than the platform governsEvidence assembled for audits; agent PRs carry no agent identityPave 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)

← All AI Delivery Factory guidance

On this page

  1. The problem: a control gap that opens silently
    1. Three-question control-gap diagnostic
  2. The six connected parts
  3. Two worker classes, one accountable system
    1. The seven jobs of the automation factory
    2. Three architectural claims to test your factory against
  4. Where your estate stands
    1. Five stations of delivery industrialisation
    2. Five places craft-alone delivery breaks
    3. Seven operational gaps beneath a red status
  5. The handover curve: governing what agents take over
    1. Three zones
    2. Conditions for delegation
    3. Shape and steepness
    4. Demotion is information
    5. The handover backlog
  6. Governance layering and programme sequence
  7. Put the model into operation
    1. Wrap, do not rebuild
    2. Decision record for the first production line
  8. Is it a factory or a pile of tools?
  9. Anti-patterns
    1. Lessons from data mesh
  10. Provenance and status

All pages in Understand →