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
- Section
- Build the platform
- Source works
- Book 2 · Book 09 · Research Series
- Source chapters
- 5, 6, 8, 10, 16, 21
- Refresh trigger
- source change
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.

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 drives | Practical test | Owner |
|---|---|---|
| Whether to mandate a capability | Is it already faster than what teams use today? Mandate only after it is | Foundation product owner |
| Where to invest next | Which governed step is slower than its shadow alternative? | Foundation product owner with platform lead |
| Whether a boundary is working | Promotion and provisioning elapsed time compared with how long a team takes to build outside | Platform 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.

Shared application plumbing is the root system beneath differentiated product features. Source: The AI Delivery Factory, Chapter 6, Figure 6.1.
| Capability | What the foundation decides once | Decision to record |
|---|---|---|
| Authentication | How a user or service is identified | Identity provider and token pattern per caller type |
| User profiles | One home for preferences, team and entitlement references | Which attributes products may extend; no private copies |
| Authorisation | A permission model and enforcement point | Where decisions are made and logged |
| Feature flags | Support at three levels: application-wide, group-wide (desk, jurisdiction, cohort) and per user | Whether users may set their own per-user flags or flags are set for them by operators |
| Architecture shape | Modular monolith, micro-websites, or both by declared domain | See the decision below |
| Configuration and secrets | Where settings and secrets live and how secrets rotate | Rotation owner and interval (detail on identity and secrets) |
| Errors, health and readiness | One error convention; standard health and readiness endpoints | Error schema and endpoint paths |
| API-client and data-access patterns | How one service calls another and reaches data | Approved client libraries or gateway routes |
| Deployment path | Promotion between stages with dependency and security scanning wired in | Evidence emitted per promotion |
| Logging and usage telemetry | One logging convention and one usage event | See 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.
| Shape | Suits | Foundation consequence | Watch for |
|---|---|---|---|
| Modular monolith (one internal product absorbing modules) | A regulated internal estate with shared users and data | Plumbing is shared by construction; capabilities are called internally | One release train; module boundaries must stay enforceable |
| Micro-websites (separate design, deployment and boundary each) | Client-facing or campaign work needing different UI frameworks | Each site consumes the same capabilities as APIs across a boundary and pins its own UI node | Divergence 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.

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 products | Owner | Funding model |
|---|---|---|---|
| 0 Engineering chassis | Identity and access for humans and agents, telemetry backbone, scaffolding and recipe templates, infrastructure modules, secrets and classification services | Platform team | Durable platform budget |
| 1 AI primitives | Model gateway, prompt registry, evaluation harness, document ingestion, entitlement-aware retrieval | Platform team | Durable platform budget |
| 2 Capability services | Retrieval service, structured extraction, agent runtime, human-review console, synthetic data, UI component library | Platform team | Durable platform budget |
| 2.5 Experience layer | Portal platform, web pattern, catalogue with context injection | Platform team with product teams | Durable platform budget |
| Funding boundary | |||
| 3 Horizontal workflows | Knowledge assistant, meeting intelligence, regulatory watch, report drafting | Product teams (pods) | Product business case: sponsor, benefit hypothesis, adoption numbers |
| 4 Domain products | Research copilot, credit document analysis, ESG reporting, operations agents | Product 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.
| Loop | What it means | Status |
|---|---|---|
| Amortisation | Each consumer spreads fixed cost thinner; linear and saturating | Classical reuse economics |
| Quality | Each use improves the asset: telemetry shows gaps, incidents become regression tests, consumers contribute fixes | Established practice |
| Evidence | Each use emits a record in the evidence schema; accumulated clean history should make the next version cheaper to certify and its consumers cheaper to assure | Hypothesis (Paper 8 §3.1): unmeasured, and acceptance by a risk function is an open question |
| Tier | Asset class | Strong loops | Limit | Build order |
|---|---|---|---|---|
| 1 | Evidence schema, telemetry conventions, policy-as-code packs | All three, through network effect | Hard to change once everything depends on it; version it on that assumption | First |
| 2 | Running shared services (capability reuse: one running service, many callers) | Amortisation and quality | Availability commitment and contract versioning | Second |
| 3 | Recipes, foundation components, templates | All three, but only at rebuild | The factory’s upgrade cadence | Third |
| 4 | Evaluation harnesses, prompt and agent libraries, tool servers, standing-context files | Quality above all | Staleness; rarely governed as assets | Alongside 2–3, as catalogue entries with BOMs, versions and owners |
| 5 | Shared code libraries (code reuse: each consumer holds a copy) | Amortisation, weakly | Copies drift; regeneration is often cheaper than evaluation | Last, 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.
| Condition | Agent-era form | Evidence that it holds |
|---|---|---|
| Discoverable at the moment of need | An 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 exposes | The asset appears in the compiled context for the relevant product types; agent-generated rivals stop appearing |
| Trusted by evidence | Certification tier computed from evidence, not granted by committee | Tier record with the facts behind it |
| Versioned with a governed upgrade path | Contract tests hold the version boundary; upgrades are dispatched to agents | Pinned versions per consumer; upgrade PR history |
| Owned and funded as a product | Named owner, roadmap and a budget line that belongs to the asset | Owner and budget in the catalogue record |
| Fed back by its consumers | Inner source with trusted committers; consumers’ agents can propose changes; incidents flow upstream as evaluation cases | Contribution 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):
- Only evidence-certified assets are admitted to the sanctioned context.
- The pipeline has a named owner.
- 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.
- 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.
| Capability | Foundation provides | Product team owns | Boundary to preserve |
|---|---|---|---|
| Identity | Authentication integration and identity context | Product roles and user journeys | No parallel login or shared credential |
| Authorisation | Policy decision and enforcement integration | Product-specific rules within the model | No scattered local checks in place of the enforcement point |
| Profiles | One profile store | Product-specific extensions | No private copy of who the user is |
| Configuration and secrets | Storage, retrieval, rotation, references | Non-secret product settings | No hard-coded credentials; no secret values in prompts or manifests |
| Telemetry | Correlation, logging and the usage event | Product events and service objectives | No product whose use cannot be observed |
| Deployment and evidence | Tested promotion path, security checks, promotion evidence | Product acceptance tests and approvals | No private path that evades a required gate |
| Shared capabilities | Versioned APIs, components or services | Composition and business logic | Declared, 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).
| Mechanism | How it works | Control |
|---|---|---|
| Agent-driven upgrade | Agents raise pinned versions across the estate, run each product’s tests and open pull requests | Each PR reviewed by a named human owner (Paper 8 names the dispatching agent’s owner); evidence kept as for any change |
| Contract tests | The machine-checkable form of the interface promise; the version boundary that holds | A contribution or upgrade that breaks a consumer contract fails |
| Hyrum’s Law exposure | Agents create consumers of an interface faster than people did, so undocumented behaviour acquires dependants faster | Document and test observable behaviour; treat changes to it as breaking |
| Inner source | Any consuming team, or its agents under its wrangler’s name, proposes changes as pull requests; a named human trusted committer holds the merge right | Same review and evidence for agent and human proposals |
| Failure upstream | The most valuable contribution is often an incident expressed as an evaluation case in the shared harness | Incident 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) | Definition | Use |
|---|---|---|
| Active consumers per asset | Products consuming the asset in production | Adoption, and the platform-of-everything signal |
| Time to first consumption | From publication to first production consumer | Discoverability check |
| Rate of copied code | Duplicated or copy-pasted code across repositories | Counter-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 line | Whether the foundation is doing its job |
| Duplication telemetry | Clone detection across repositories, dependency overlap, the same capability implemented more than once | Feeds extraction candidates to the platform backlog |
| Declared exceptions | Count and age per capability | Missing 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) | |
|---|---|---|
| Purpose | Find out whether an idea holds | Run a product with an owner |
| Data | No production data, enforced by policy | Classified data per the product’s approvals |
| Lifetime | Time-limited with automatic eviction | Lifecycle with a kill clause and a tested retirement recipe |
| Visibility | Fully visible to the platform team: what is built, how much it is used, what it spends | Registered, with BOM, owner, usage event and evidence |
| Controls | Sandbox isolation, spend limits, no promotion without crossing | Identity, 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:
- Named product owner (the builder can be the owner, paired with a platform engineer, as in the composite lease-tool example).
- Registration with BOM and data classification.
- Usage event emitted from day one in production.
- 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.
- 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]
| Azure | AWS | Google Cloud | |
|---|---|---|---|
| Time-boxed sandboxes | Azure Deployment Environments and Dev Box | Control Tower account vending with a sandbox OU | Folder-and-project factory |
| No production data and expiry | Azure Policy with management-group scoping | Service control policies denying production data paths | Organisation policy constraints |
| Templated crossing | Azure Developer CLI stamping the foundation | Service Catalog and Proton | Application Design Center |
| Agent runtime | Foundry Agent Service | Bedrock AgentCore | Agent 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.
- Week one: inventory what exists in the default environment and read its spend and usage.
- 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]
- Stand up the governed crossing and promote validated tools through it.
- 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
- Pick the most common application type, not the most complex.
- Count how many ways the firm builds one plumbing capability; the count is the business case.
- Wire duplication detection into standing telemetry.
- 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.
- Name the product owner (at Asset Manager X the platform-engineering lead; in a small firm the named owner of the paved road).
- Admit the capability to compiled agent context through the certification controls above.
- Let existing applications adopt capability by capability when they touch it; measure migration as a falling duplicate count, not rising rewrites.
- 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
| Failure | Recognise it | Recover |
|---|---|---|
| Mandating before it is usable | Full adoption on paper; duplicates in code review | Return to adoption by attraction; make it the fastest route |
| Framework prison | Good teams lose reasonable exception requests | Treat the exception path as designed infrastructure |
| Funded as a project, not a product | Nobody knows which foundation version an application runs | Standing budget line, named owner, adoption measured like a product |
| Unversioned foundation | Foundation changes cause unattributable incidents | Explicit versions, pinning, published change notes |
| Read by humans, invisible to agents | Agent-generated rivals to documented capabilities | Ship the machine-readable expression; compile it into context |
| Shared-library graveyard | Assets published, not consumed; programme counts components built | Measure consumption; prune entries |
| Certification bottleneck | The catalogue has become a queue | Evidence-computed tiers |
| Platform of everything | Illustrative signal from Paper 8: an entry with no production consumer two quarters after publication | Let observed duplication justify the next component |
| Stale asset | A recipe or context file that was true last spring | Same-commit lifecycle; owner duty to retire |
| Tollbooth boundary | Promotion slower than building outside | Cut the crossing to days, then tighten |
| Landfill | Production systems with no retirement recipe or departed owners | Refuse 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
Related guidance
-
The Anatomy of an AI ApplicationA six-tier view of what one AI product is made of, crossed by a trust and operations plane that attaches controls to every tier; what the factory already supplies per tier, how the anatomy maps to the six-layer product portfolio, and how to run an anatomy review. -
The AI Delivery Factory: Operating ModelThe 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. -
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. -
Design the Cloud Production Line and Hosting BoundariesClassify, segment, constrain and observe every workspace at the plane where actions execute, choose hosting routes per request, and keep vendor maturity, contracts and exit equivalence dated and explicit. -
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. -
Identity, Secrets and Configuration for Agent WorkloadsGive every actor one owned identity, size its authority for the worst case, separate runtime from deployment, federate instead of holding keys, refuse impersonation and silent fallback, govern configuration by class, and audit the estate until flagged identities decline. -
Assess Agent Readiness Across the EstateCheck the estate's control foundations, grade the stations a change must cross on evidence, route work by the weakest station, fund readiness worst-first with a stated split, and make bought products machine-operable at renewal. -
The 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. -
Close the Policy, Audit and Actuals LoopRun governance as a standing comparison of declared policy against emitted records, route only the exceptions to the second line, and govern the policy packs that drive the comparison. -
Operate the Agent LifecycleInventory, register, sign, zone, review, suspend, recover and retire agents through a six-stage lifecycle with named human ownership, zone-specific authority and evidence at every transition. -
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.