Browse the reference ⌄
Implementation Guide published

Build the Standard Application Foundation

Run the shared identity, telemetry, deployment, data and AI capabilities as a funded product that humans and agents both start from, with a contract, evidence-computed trust, a cheap promotion boundary and reuse measured by consumption.

Version
0.2.0
Owner
DEIXEI
Last reviewed
Reading time
26 min

For Cto · Ai Architect · Platform Engineer · Product Leader · Risk And Assurance

Sources and details
Source works
Book 2 · Book 09 · Research Series
Source chapters
5, 6, 8, 10, 16, 21
Refresh trigger
source change

Full source list ↓ Source index →

The standard application foundation is the set of shared capabilities a product consumes instead of rebuilding: identity, profiles, authorisation, configuration and secrets, telemetry, the deployment path and its evidence, and, for AI products, governed model access, retrieval, evaluation and review. It gives product teams a secure, observable starting point and gives coding agents approved components and contracts to build inside.

Run it as a platform product with an owner, a budget line, versions, support and a roadmap. A template without those things goes stale and is routed around, and at agent speed the routing-around is instant: an agent asked for a file upload will generate a plausible fifth one unless its context names the governed service. Book 2 (Chapter 6) states the agent-era definition sharply: a paved road is not published until its machine-readable expression ships with it, versioned and owned.

The six-layer product portfolio: reusable primitives at the bottom, differentiated products at the top; funding follows the layer boundary.

At a glance: six layers, with platform funding for the roots and product business cases for the canopy. The detailed diagram is under Place the foundation in the factory portfolio and fund it by layer. Source: The AI Delivery Factory, Chapter 6, Figure 6.2.

The law the foundation lives under: adoption by attraction

Book 2 (Ch 6 §5) names the law adoption by attraction: teams take up a foundation only when it is their quickest route to a working product; otherwise they do not take it up at all. The foundation’s real competitor is not the absence of a road but the shadow road: the personal subscription, the ungoverned tool, the agent pointed at a repository with no procurement and no review. The shadow road wins only on friction, and that is precisely the axis a governed platform is tempted to concede.

The same law applies to every control surface built on the foundation: recipes, gates, the promotion boundary and the context agents read. Where a control is easier to evade than to use, evasion is the result, and agents evade without malice by generating the improvised alternative.

Decision this law drivesPractical testOwner
Whether to mandate a capabilityIs it already faster than what teams use today? Mandate only after it isFoundation product owner
Where to invest nextWhich governed step is slower than its shadow alternative?Foundation product owner with platform lead
Whether a boundary is workingPromotion and provisioning elapsed time compared with how long a team takes to build outsidePlatform lead, reported to the CIO

Recognise failure as 100 per cent adoption on paper while duplicate implementations keep appearing in code review. Recover by making the paved road the fast road, not by escalating the mandate.

Start with the plumbing every product needs

The plumbing catalogue is the capability set that sits beneath business logic and barely varies between applications. None has a direct revenue line, which is why each gets deferred; all are the reason the canopy stands.

Business features sit above shared identity, authorisation, telemetry and document capabilities; value and reuse compound through the shared foundation.

Shared application plumbing is the root system beneath differentiated product features. Source: The AI Delivery Factory, Chapter 6, Figure 6.1.

CapabilityWhat the foundation decides onceDecision to record
AuthenticationHow a user or service is identifiedIdentity provider and token pattern per caller type
User profilesOne home for preferences, team and entitlement referencesWhich attributes products may extend; no private copies
AuthorisationA permission model and enforcement pointWhere decisions are made and logged
Feature flagsSupport at three levels: application-wide, group-wide (desk, jurisdiction, cohort) and per userWhether users may set their own per-user flags or flags are set for them by operators
Architecture shapeModular monolith, micro-websites, or both by declared domainSee the decision below
Configuration and secretsWhere settings and secrets live and how secrets rotateRotation owner and interval (detail on identity and secrets)
Errors, health and readinessOne error convention; standard health and readiness endpointsError schema and endpoint paths
API-client and data-access patternsHow one service calls another and reaches dataApproved client libraries or gateway routes
Deployment pathPromotion between stages with dependency and security scanning wired inEvidence emitted per promotion
Logging and usage telemetryOne logging convention and one usage eventSee the usage event below

Feature-flag self-service. Book 2 gives no universal answer to whether users may set their own flags; the wrong outcome is every team answering differently. Decide once per product family, record it in the foundation contract, and treat a flag change in production as configuration change with evidence.

Decide the architecture shape deliberately

Both shapes are legitimate (Book 2 Ch 6 §4). What is not legitimate is drifting into one application by application with no shared answer to how applications authenticate, log or exchange files.

ShapeSuitsFoundation consequenceWatch for
Modular monolith (one internal product absorbing modules)A regulated internal estate with shared users and dataPlumbing is shared by construction; capabilities are called internallyOne release train; module boundaries must stay enforceable
Micro-websites (separate design, deployment and boundary each)Client-facing or campaign work needing different UI frameworksEach site consumes the same capabilities as APIs across a boundary and pins its own UI nodeDivergence in identity, logging and document handling unless the contract binds them

The composite Asset Manager X runs both: a modular monolith for regulated internal work and micro-websites for client-facing work, with one document service beneath both. Record the shape per domain as an architecture decision, and route a micro-website’s different UI framework through the declared exception path rather than a silent fork.

Make usage telemetry a default foundation event

Usage is the gauge that moves first: a defect rate needs a release, a business outcome needs a quarter, usage shows within a week whether provisioned users came back (Book 09 Ch 10). The composite example: a product granted to 41 people in July had six active users after a month, two of them repeat users, while every delivery metric was green.

The event (Book 09 Ch 10). Every product emits one event each time it does its job, carrying at least:

  • the product identifier;
  • the caller, distinguishing a person from another system or agent;
  • the model cost of that use.

Put the event in the foundation so measuring use is the default; bolted on later, teams measure what is easy rather than what matters. Where a product predates the event, fall back to identity-provider sign-ins and mark the figure as lower quality.

Read it first. In the quarterly product review, usage comes before delivery metrics, and decisions on each product follow it. Two rules travel with it: read usage for products, never for people (it must not appear in anyone’s objectives), and set no targets on participation measures such as suggestion acceptance or agent share of commits. Products shipped but not used are carried as a cost at their running cost, each with a decision (keep, fix or retire), an owner and a date (Book 09 Ch 10); the operating review is on Run the factory.

Place the foundation in the factory portfolio and fund it by layer

The portfolio asks what reusable products the factory ships; the application anatomy asks what one application contains. Use the portfolio to decide where durable platform money belongs.

A six-layer portfolio moves from engineering chassis and AI primitives through capability and experience services to horizontal workflows and domain products.

The proposed portfolio separates reusable platform funding from product-specific business cases. Source: The AI Delivery Factory, Chapter 6, Figure 6.2.

Layer (Book 2 Ch 6, adapted from Research Paper 1)Representative productsOwnerFunding model
0 Engineering chassisIdentity and access for humans and agents, telemetry backbone, scaffolding and recipe templates, infrastructure modules, secrets and classification servicesPlatform teamDurable platform budget
1 AI primitivesModel gateway, prompt registry, evaluation harness, document ingestion, entitlement-aware retrievalPlatform teamDurable platform budget
2 Capability servicesRetrieval service, structured extraction, agent runtime, human-review console, synthetic data, UI component libraryPlatform teamDurable platform budget
2.5 Experience layerPortal platform, web pattern, catalogue with context injectionPlatform team with product teamsDurable platform budget
Funding boundary
3 Horizontal workflowsKnowledge assistant, meeting intelligence, regulatory watch, report draftingProduct teams (pods)Product business case: sponsor, benefit hypothesis, adoption numbers
4 Domain productsResearch copilot, credit document analysis, ESG reporting, operations agentsProduct teams (pods)Product business case

Layers 0 to 2.5 are roots: fund them with a standing budget, product-grade ownership, service levels and a roadmap. Layers 3 and 4 are canopy: fund them through product business cases. Two conflations rebuild the funding trap one layer up: asking the platform to justify itself product by product, and letting a product quietly grow a private platform. The source cautions against selling the stack to a board as a paradigm to adopt whole; build it as a capability sequence in which each layer pays its way.

Build in the order assets compound

Research Paper 8 ranks asset classes by how strongly three loops run on them. The ranking is the author’s judgement, not a measurement, and the paper observes it is close to the reverse of how firms usually spend.

LoopWhat it meansStatus
AmortisationEach consumer spreads fixed cost thinner; linear and saturatingClassical reuse economics
QualityEach use improves the asset: telemetry shows gaps, incidents become regression tests, consumers contribute fixesEstablished practice
EvidenceEach use emits a record in the evidence schema; accumulated clean history should make the next version cheaper to certify and its consumers cheaper to assureHypothesis (Paper 8 §3.1): unmeasured, and acceptance by a risk function is an open question
TierAsset classStrong loopsLimitBuild order
1Evidence schema, telemetry conventions, policy-as-code packsAll three, through network effectHard to change once everything depends on it; version it on that assumptionFirst
2Running shared services (capability reuse: one running service, many callers)Amortisation and qualityAvailability commitment and contract versioningSecond
3Recipes, foundation components, templatesAll three, but only at rebuildThe factory’s upgrade cadenceThird
4Evaluation harnesses, prompt and agent libraries, tool servers, standing-context filesQuality above allStaleness; rarely governed as assetsAlongside 2–3, as catalogue entries with BOMs, versions and owners
5Shared code libraries (code reuse: each consumer holds a copy)Amortisation, weaklyCopies drift; regeneration is often cheaper than evaluationLast, by exception

Price the concentration beside the benefit: one document service is one place a vulnerability reaches the whole estate. Map shared internal assets that support critical or important functions in the firm’s dependency documentation; how the ICT-asset and register-of-information duties apply to internal platforms is a legal-structure question covered on the regulatory map and argued in Research Paper 8 §3.7.

Apply the five-condition test to every catalogue entry

Well-built shared assets fail when one of five conditions is missing (Paper 8 §3.3). Record which conditions each entry fails; a failing entry is heading for one of the failure modes below.

ConditionAgent-era formEvidence that it holds
Discoverable at the moment of needAn agent does not browse. The asset must be in the standing context compiled into each workspace at provisioning, or reachable through a tool the workspace exposesThe asset appears in the compiled context for the relevant product types; agent-generated rivals stop appearing
Trusted by evidenceCertification tier computed from evidence, not granted by committeeTier record with the facts behind it
Versioned with a governed upgrade pathContract tests hold the version boundary; upgrades are dispatched to agentsPinned versions per consumer; upgrade PR history
Owned and funded as a productNamed owner, roadmap and a budget line that belongs to the assetOwner and budget in the catalogue record
Fed back by its consumersInner source with trusted committers; consumers’ agents can propose changes; incidents flow upstream as evaluation casesContribution and evaluation-case history

Treat context injection as a supply-chain decision

Agents consume what their context offers without the scepticism a senior engineer applies to an old wiki page. Putting an asset into agent context is therefore the same kind of decision as admitting a third-party dependency (Paper 8 §3.3; Book 2 Ch 8 §4.7).

Certification tiers, computed from evidence. Four tiers: sanctioned, certified, contributed, quarantined. The computing facts named in the sources are: scans current, contract tests passing, production consumers present, incident history attributed and clean, owner responsive. An asset whose scan goes stale or whose owner stops responding drops a tier because the evidence moved, without a meeting. People set the criteria; they do not work a queue. The sources do not prescribe the mapping from facts to each tier; define it locally and agree it with the second line before relying on it.

What each tier means at injection (Book 2 Ch 16 §4.5). Sanctioned and certified assets are injected into the paved context and tool surfaces. Contributed assets stay reachable on deliberate request by an engineer or wrangler but are never injected by default. Quarantined assets are never injected. Because tiers are recomputed, an asset that slides down simply stops being offered to the next provisioned workspace.

Controls on the compile pipeline (the pipeline that turns the catalogue into per-workspace context; Paper 8 §3.3 and §4):

  1. Only evidence-certified assets are admitted to the sanctioned context.
  2. The pipeline has a named owner.
  3. Every change to what is injected leaves an audit trail. Recommended fields (this page’s proposal, not a source schema): asset, version, tier at injection, target workspaces, change approver.
  4. Each injected expression changes in the same commit, versions in the same scheme and retires the same day as the capability it describes (Book 2 Ch 6 §5).

Publish a foundation contract

For each capability, the platform and its consumers must be able to answer: what the foundation provides, what a product team may change, and what it must not bypass.

CapabilityFoundation providesProduct team ownsBoundary to preserve
IdentityAuthentication integration and identity contextProduct roles and user journeysNo parallel login or shared credential
AuthorisationPolicy decision and enforcement integrationProduct-specific rules within the modelNo scattered local checks in place of the enforcement point
ProfilesOne profile storeProduct-specific extensionsNo private copy of who the user is
Configuration and secretsStorage, retrieval, rotation, referencesNon-secret product settingsNo hard-coded credentials; no secret values in prompts or manifests
TelemetryCorrelation, logging and the usage eventProduct events and service objectivesNo product whose use cannot be observed
Deployment and evidenceTested promotion path, security checks, promotion evidenceProduct acceptance tests and approvalsNo private path that evades a required gate
Shared capabilitiesVersioned APIs, components or servicesComposition and business logicDeclared, reviewed deviations only; no silent forks

Three clauses turn the contract into a governance instrument (Book 2 Ch 6 §5):

  • Exception path. Deviations are declared, reviewed and recorded. Each is a signal that a guideline is missing or wrong; count them and review frequent ones.
  • Versioning. The foundation has versions, publishes what changed, and every application can state the version it is on.
  • Machine-readable expression. Each capability ships its standing-context entry (what it is, its contract, how to consume it) in the same commit, version scheme and lifecycle as the capability. A stale expression is worse than none.

Fund context assets as a standing function and keep them portable

The reusable asset of an AI factory is increasingly context: inventories, templates, repository instruction files, recorded decisions, design rules. These decay silently and are paid for on every task (Paper 6 §3.5). Recommendations from Paper 6 §4 (proposals, not tested practice):

  • Owner and budget. Assign context-asset upkeep to a role that already exists (the platform or delivery-automation owner is the natural fit; no new title is needed). Fund it from a budget line that outlives the programme, and make retiring stale assets part of the duty, not only adding new ones. Layering and the review cadence for standing-context files are on The SDLC at agent speed.
  • Proportional specification. Scale required precision to the risk and size of the change. If people bypass the specification step, treat that first as evidence the step costs more than the work it unlocks.
  • Portability. Keep context in plain, open formats (Paper 6 cites the AGENTS.md convention, as of November 2026 [FACT-CHECK: current AGENTS.md stewardship and adoption figures]) and bind processes to a role in the delivery chain rather than to one agent product. Run a periodic second-model exercise: execute a representative task on a second model or tool and record what broke. The source is explicit that the exercise is the control; a file format alone does not make behaviour portable.

Make the design system a control surface

At agent speed the design system stops being a library people consult and becomes a constraint set that many agent threads obey (Book 2 Ch 21 §4.3). It is a versioned, machine-readable global practice injected into every thread that touches a user-facing surface.

  • Write to be obeyed, not consulted. “Use whitespace generously” is a guideline; “card padding is 16px; deviations need a recorded exception” is a constraint an agent can honour and a reviewer can check. Rewrite interpretable sentences as checkable rules.
  • Put the regulated conventions here once. How confidence is displayed on generated output, how citations render, how approvals are captured, and what a user sees when an agent acted on their behalf. Every product inherits a correct convention; a wrong one ships across the estate at machine speed.
  • Ownership. The design lead owns the constraint set as a product, with versions and an exception path (a client-facing micro-site’s different framework goes through it).

Compose capabilities; avoid a monolithic framework

Represent the foundation as independently owned, versioned nodes in the product BOM. A batch integration references identity, logging, secrets and deployment and nothing about a front end. You do not need to finish the foundation before it is useful: one working node, referenced by the applications that need it, is enough; the next node earns its place when a second capability turns out to be built several times.

Bind teams to the contract, not the SKU. Book 2 lists typical bindings as of 2026: on Azure, Entra ID, Key Vault, Application Insights and Azure Monitor, Blob Storage with a metadata store, GitHub Actions or Azure DevOps, Bicep; on AWS, IAM with Cognito for profiles, Secrets Manager, CloudWatch, S3 with DynamoDB metadata, CodePipeline or GitHub Actions, CDK or Terraform; on Google Cloud, Cloud Identity and IAM, Secret Manager, Cloud Logging and Monitoring, Cloud Storage with Firestore, Cloud Build, Terraform. [FACT-CHECK: current service names] A cloud migration should then re-wire roots rather than replant the tree.

Run upgrade as an industrial function

Template-class assets compound only as fast as consumers are upgraded; a factory that can create but not upgrade manufactures its next legacy estate (Paper 8 §3.2–3.3; Book 2 Ch 16).

MechanismHow it worksControl
Agent-driven upgradeAgents raise pinned versions across the estate, run each product’s tests and open pull requestsEach PR reviewed by a named human owner (Paper 8 names the dispatching agent’s owner); evidence kept as for any change
Contract testsThe machine-checkable form of the interface promise; the version boundary that holdsA contribution or upgrade that breaks a consumer contract fails
Hyrum’s Law exposureAgents create consumers of an interface faster than people did, so undocumented behaviour acquires dependants fasterDocument and test observable behaviour; treat changes to it as breaking
Inner sourceAny consuming team, or its agents under its wrangler’s name, proposes changes as pull requests; a named human trusted committer holds the merge rightSame review and evidence for agent and human proposals
Failure upstreamThe most valuable contribution is often an incident expressed as an evaluation case in the shared harnessIncident and review findings routed into the harness as test cases

Measure consumption, detect duplication, decline the rule of two

Measure (Paper 8 §4; Book 2 Ch 6 §7)DefinitionUse
Active consumers per assetProducts consuming the asset in productionAdoption, and the platform-of-everything signal
Time to first consumptionFrom publication to first production consumerDiscoverability check
Rate of copied codeDuplicated or copy-pasted code across repositoriesCounter-measure to consumption counts
Inherited share (headline, proposed in Paper 8)Fraction of a shipped product’s BOM inherited by reference rather than written for that product, per production lineWhether the foundation is doing its job
Duplication telemetryClone detection across repositories, dependency overlap, the same capability implemented more than onceFeeds extraction candidates to the platform backlog
Declared exceptionsCount and age per capabilityMissing or wrong defaults

Industrialise the duplication count. A one-off spreadsheet audit (the composite Nadia’s two-day count of four file uploads) is the bootstrap, not the process. Run detection as standing telemetry on a cadence and feed it to the factory scorecard. Estate-level portfolio reuse metrics are on Run the factory.

Keep extraction a judgement. The classical rule of three said to abstract on the third duplication. At agent speed the third copy can arrive the same week as the second, which tempts an automatic rule of two. Both sources decline it: a wrong abstraction also propagates at agent speed, and a shared asset is hard to change once it has consumers. Treat a second consumer or a second duplicate as a signal that opens an owner’s judgement, never as a trigger that performs the extraction. For AI products, run the same count per tier of the application anatomy: a private gateway, retrieval store or evaluation set is this year’s duplicated file upload.

Make promotion cheaper than evasion

Cheap construction means every business unit can have a working tool within days. The dangerous artefact is the successful prototype that gathers users, data and dependencies without crossing into production, and six months later is load-bearing, unowned and unevidenced (Book 2 Ch 21 §4.5; Book 09 Ch 10). The foundation must double as the promotion boundary, and crossing it must cost less than staying hidden.

Two tiers and a crossing

Prototype tier (below the boundary)Governed foundation (above)
PurposeFind out whether an idea holdsRun a product with an owner
DataNo production data, enforced by policyClassified data per the product’s approvals
LifetimeTime-limited with automatic evictionLifecycle with a kill clause and a tested retirement recipe
VisibilityFully visible to the platform team: what is built, how much it is used, what it spendsRegistered, with BOM, owner, usage event and evidence
ControlsSandbox isolation, spend limits, no promotion without crossingIdentity, authorisation, telemetry, deployment and evidence inherited from the foundation

The crossing. A squad should complete it in days, because the foundation supplies controls by inheritance rather than by assessment. Recommended promotion checklist, assembled from the sources:

  1. Named product owner (the builder can be the owner, paired with a platform engineer, as in the composite lease-tool example).
  2. Registration with BOM and data classification.
  3. Usage event emitted from day one in production.
  4. Kill clause written before further construction: a date and a falsifiable condition based on a baseline measured at selection, signed by whoever asked for the product.
  5. A retirement recipe that has been run once against the prototype: data disposed, identities retired, integrations unwound, evidence closed and retained, register amended. You can cheaply retire only what you can completely enumerate.

Thresholds and triggers. Measure promotion elapsed time. If promotion takes more than two weeks, fix that before anything else (Book 2 Ch 21 §7). In a very large firm the centre’s obligation is to guarantee promotion in days; a centre that only vetoes is a tollbooth. Refuse promotion without a run retirement recipe, and put a scheduled kill review on the portfolio-review cadence (decommissioning detail on agent lifecycle).

Spend-based discovery. Book 09’s composite example found an unregistered low-code tool, processing roughly 1,500 confidential leases, because a weekly per-environment view of model and capacity spend showed an unrecognised line overtaking every sanctioned product. Read spend by environment weekly; an unfamiliar rising line is validated demand that had nowhere to go, not only an offender.

The prototype tier on each cloud

As of August 2026, per Book 2 Ch 21 §4.5. [FACT-CHECK: product names and availability, including AWS Proton’s current support status and Google Application Design Center, against current documentation]

AzureAWSGoogle Cloud
Time-boxed sandboxesAzure Deployment Environments and Dev BoxControl Tower account vending with a sandbox OUFolder-and-project factory
No production data and expiryAzure Policy with management-group scopingService control policies denying production data pathsOrganisation policy constraints
Templated crossingAzure Developer CLI stamping the foundationService Catalog and ProtonApplication Design Center
Agent runtimeFoundry Agent ServiceBedrock AgentCoreAgent Runtime on Gemini Enterprise Agent Platform (formerly Vertex AI Agent Engine)

Close the low-code default environment, after the crossing is fast

Microsoft Power Platform (as of November 2026, per Book 2 Ch 21 and Book 09 Ch 10, citing Microsoft Learn). Each tenant has one default environment shared by all users, in which all licensed users hold the environment maker role; it cannot be deleted; Copilot Studio agents are created there by default unless specified otherwise. Managed-environment features and data policies exist and work, but an administrator must enable them. Both books criticise the default, not the capability.

Sequence matters. Book 2 says close the default environment in week one; Book 09 and Book 2’s own failure-mode section say close it only once a fast crossing exists, otherwise building moves to personal subscriptions, unmanaged notebooks and consumer assistants with less telemetry. This page follows the stricter sequence: instrument first, build the crossing, then close.

  1. Week one: inventory what exists in the default environment and read its spend and usage.
  2. Enable managed-environment controls, a data policy for the default environment and environment routing so new makers land in governed environments. [FACT-CHECK: current names of these controls in the Power Platform admin centre]
  3. Stand up the governed crossing and promote validated tools through it.
  4. Then close the default environment to new building.

The same exposure exists on other clouds’ citizen-development surfaces: Google AppSheet and Gemini in Workspace, and on AWS the surface Book 2 calls Amazon Q Apps and Book 09 calls Amazon Quick Suite (the successor to Amazon Q Business from October 2025). [FACT-CHECK: current AWS product name] The answer is the same: know where non-engineers build, read what they use, and make the crossing cheap. Sandbox-OU and landing-zone mechanics are on Prepare a governed landing zone.

Worked example: solving file upload once

Composite example from Book 2 Ch 6; not a measured deployment. Four teams had each built their own upload. A file is two things: the binary and its metadata (uploader, time, owning case, type, retention class, classification). The platform team built one document service: bytes in object storage, metadata in a governed store beside it, identity from the foundation, and virus scanning, size limits, content-type checks, retention tagging and an access audit trail done once. Retention class and classification became mandatory metadata fields set at upload and enforced by the service. It emitted the usage event and was exposed as an API and an embeddable UI component. Teams adopted it the next time they touched upload code; an agent asked later to add an attachment found the service in its context and wired to it. The outcome was one scan configuration to patch, one evidence source, and a duplication count that began to fall. The same service sat under both the modular monolith and the micro-websites.

Operate the foundation as a product

  1. Pick the most common application type, not the most complex.
  2. Count how many ways the firm builds one plumbing capability; the count is the business case.
  3. Wire duplication detection into standing telemetry.
  4. Ship a narrow first version (one identity integration, one logging convention, one deployment path, one document service) with its contract, version, support path and machine-readable expression.
  5. Name the product owner (at Asset Manager X the platform-engineering lead; in a small firm the named owner of the paved road).
  6. Admit the capability to compiled agent context through the certification controls above.
  7. Let existing applications adopt capability by capability when they touch it; measure migration as a falling duplicate count, not rising rewrites.
  8. Scale the build to the firm: a forty-engineer firm wraps one managed service in a thin contract and forbids the second.

Failure modes and recovery

FailureRecognise itRecover
Mandating before it is usableFull adoption on paper; duplicates in code reviewReturn to adoption by attraction; make it the fastest route
Framework prisonGood teams lose reasonable exception requestsTreat the exception path as designed infrastructure
Funded as a project, not a productNobody knows which foundation version an application runsStanding budget line, named owner, adoption measured like a product
Unversioned foundationFoundation changes cause unattributable incidentsExplicit versions, pinning, published change notes
Read by humans, invisible to agentsAgent-generated rivals to documented capabilitiesShip the machine-readable expression; compile it into context
Shared-library graveyardAssets published, not consumed; programme counts components builtMeasure consumption; prune entries
Certification bottleneckThe catalogue has become a queueEvidence-computed tiers
Platform of everythingIllustrative signal from Paper 8: an entry with no production consumer two quarters after publicationLet observed duplication justify the next component
Stale assetA recipe or context file that was true last springSame-commit lifecycle; owner duty to retire
Tollbooth boundaryPromotion slower than building outsideCut the crossing to days, then tighten
LandfillProduction systems with no retirement recipe or departed ownersRefuse promotion without a run retirement recipe; scheduled kill reviews

Acceptance evidence

  • A named product owner and team maintain the backlog, roadmap, support model, version policy and a standing budget line for layers 0–2.5.
  • Each capability has a contract, tested interface, exception path and a machine-readable expression in the same commit and version.
  • Every new product emits the usage event (product, caller type, model cost) from its first production day, and the quarterly review reads usage first.
  • Each catalogue entry records its five-condition status and its computed certification tier, with the facts behind it.
  • The context compile pipeline has a named owner, admits only evidence-certified assets and keeps an audit trail of injected changes.
  • Duplication telemetry runs on a cadence; inherited share and time to first consumption are reported per production line.
  • Upgrades are dispatched as agent-opened pull requests reviewed by named owners; contract tests guard each shared interface.
  • Promotion elapsed time is measured and under two weeks; every promoted product has a kill clause and a retirement recipe that has been run.
  • The low-code default environment is instrumented, governed and, once a crossing exists, closed to new building.
  • A second-model exercise has been run on a representative task within the review period.

Source status. The plumbing catalogue, foundation contract, six-layer portfolio and promotion boundary are design proposals from Book 2 Chapters 6 and 21. The asset tiers, five conditions, evidence loop, certification tiers and inherited share are proposals and a stated hypothesis from Research Paper 8; context-asset funding and portability come from Paper 6’s recommendations. The usage-first review comes from Book 09. Asset Manager X, Nadia’s count, the 41-user product and the lease tool are composites. Vendor product facts are dated and carry FACT-CHECK markers.

Source material

  • Book 2, Chapter 5, Bills of Material and Recipes
  • Book 2, Chapter 6, The Standard Application Foundation
  • Book 2, Chapter 8, The Policy, Audit, Actuals Loop (§4.7 certification tiers)
  • Book 2, Chapter 16, The Automation Factory (§4.7 inner source with trusted committers)
  • Book 2, Chapter 21, Product Development at Agent Speed (§4.3 design system, §4.4 kill clause, §4.5 promotion boundary, §7–8)
  • Book 09, Chapter 10, Is Anyone Using It? (usage event, prototype tier, low-code default environment)
  • DEIXEI Research Series, Working Paper 06, The AI Factory versus the Software Factory (§3.5, §4)
  • DEIXEI Research Series, Working Paper 08, Reusability and the Compounding Factory (§3–§4)
  • DEIXEI Research Series, Working Paper 01, Taxonomy for a Reuse-Driven AI Factory

← All AI Delivery Factory guidance

On this page

  1. The law the foundation lives under: adoption by attraction
  2. Start with the plumbing every product needs
    1. Decide the architecture shape deliberately
    2. Make usage telemetry a default foundation event
  3. Place the foundation in the factory portfolio and fund it by layer
  4. Build in the order assets compound
  5. Apply the five-condition test to every catalogue entry
  6. Treat context injection as a supply-chain decision
  7. Publish a foundation contract
    1. Fund context assets as a standing function and keep them portable
  8. Make the design system a control surface
  9. Compose capabilities; avoid a monolithic framework
  10. Run upgrade as an industrial function
  11. Measure consumption, detect duplication, decline the rule of two
  12. Make promotion cheaper than evasion
    1. Two tiers and a crossing
    2. The prototype tier on each cloud
    3. Close the low-code default environment, after the crossing is fast
  13. Worked example: solving file upload once
  14. Operate the foundation as a product
  15. Failure modes and recovery
  16. Acceptance evidence

All pages in Build the platform →