Infrastructure factory

What an infrastructure factory is

An infrastructure factory is a platform that turns intents from humans or agents into compliant, owned, observable, cost-attributed environments, with no ticket in the path. This page takes that sentence apart, lists the parts, draws the line, states the twelve factors, and ends with a test and a place to start.

Definition

The definition

An Infrastructure Factory is a platform1 that turns intents2, from humans or agents3, into compliant, owned, observable, cost-attributed4 environments5, with no ticket in the path6.

  • Not an AI factory in NVIDIA's sense. No racks of GPUs turning energy into tokens.
  • Not only an account vending machine. It contains vending lines such as AWS Account Factory and Azure subscription vending, and everything around them that a human still adds by hand.
  1. 1

    Platform

    A production system that a team runs as a product, with customers, a backlog and a service level. Not a project, not a folder of modules, not a committee of approvers. Its operators build the line.

  2. 2

    Intents

    A request that says what the environment is for, who owns it, what data it touches and how long it lives. The factory translates the intent into resources. The requester never has to.

  3. 3

    Humans or agents

    The same contract serves a developer in a portal, a delivery pipeline, an operations agent remediating an incident, and a coding agent validating a change in the middle of the night. If an agent cannot use it unaided, it is a portal, not a factory.

  4. 4

    Compliant, owned, observable, cost-attributed

    Four properties present on arrival, never added later. Compliant: every policy evaluated, every decision recorded. Owned: a cost center, a compliance owner and an on-call owner that resolve to real people. Observable: telemetry flowing before the first request arrives. Cost-attributed: every euro lands on the owner's line.

  5. 5

    Environments

    The factory's unit of product: a bounded set of resources with a name, an owner, a lifetime, a data classification, a network position, an identity, telemetry and a cost line. An account, a namespace, a cluster, a sandbox or a set of managed services can each be an environment. A virtual machine is a part.

  6. 6

    No ticket in the path

    No human action between the intent and the environment. Humans decide at the contract, once, and the decisions live on as defaults, delegations and policies. A human may be notified, asked to approve a renewal above a threshold, or paged when a policy fails. A human is never a station.

Components

What it is made of

Each of the parts exists as open source or as a cloud primitive today. The factory is the arrangement of those.

The front door

One API, exposed to agents as a tool surface over MCP. Portals and command lines are views on it, never separate paths with their own rules.

MCP tool server · Backstage · a CLI

The contract registry

Versioned, machine-readable contracts that state what the requester may choose and what the platform decides. The requester reads the contract before asking, so the first request is fulfillable.

Kratix Promises · Crossplane Compositions · Backstage templates

The catalog

The source of truth for ownership: teams, cost centers, compliance contacts, on-call rotations, data classifications, and for physical estates the assets themselves.

Backstage catalog · NetBox · the HR and finance systems behind them

The policy engine and the defaults

The pre-check that answers allow or deny with a reason, and the delegation rules that fill the fields no agent can sign.

Open Policy Agent · Kyverno · Gatekeeper

The vending lines

One per terrain: cloud accounts and projects, virtual machines, clusters, namespaces, sandboxes, bare metal. The contract hides which line runs.

Account Factory for Terraform · Cluster API · KubeVirt · Metal3 · Agent Sandbox

The inventory

Capacity held as stock: warm pools, quotas, reservations and, off the cloud, procurement forecasts with a published fill rate.

SandboxWarmPool · node pools · hardware pools

The identity system

Short-lived, scoped identities for every requester and every workload, agents included. Credentials move through it and nowhere else.

SPIFFE/SPIRE · Keycloak · cloud IAM

The meter and the evidence store

Telemetry, cost attribution and the decision record for every environment, kept as the factory's output rather than compiled for an audit afterwards.

OpenTelemetry · OpenCost · Prometheus · policy audit logs

Boundaries

What it is not

The table reads left to right as a history: most organizations have built the first three and call the result a platform.

DimensionTicket desk with scriptsDeveloper portalPlatform orchestratorInfrastructure Factory
Who can askHumans, in a queue.Humans, through a form.Humans and pipelines, through an API.Humans and agents, through a contract the agent can read.
What they sendFree text.Form fields.A specification or a claim.An intent, with purpose, owner, data and lifetime.
Who decidesA person, per request.A person, per request, behind the form.Partly encoded; the rest escalates.Encoded once: policy, defaults, delegations. Nobody per request.
What comes backResources.Resources and a catalog entry.An environment.An environment with owner, evidence and cost attached.
How long it livesForever.Forever.Sometimes until deleted.Until its lifetime ends, then it is reclaimed.
Whose problem is capacityProcurement's.Procurement's.The cloud's.The factory's, held as inventory with a fill rate.
How it is measuredTicket SLA.Adoption.Deployments.Lead time, zero-touch rate, time to owner, orphan rate.

It is also not an AI factory in NVIDIA's sense, not an IaC generator, and not a product from any one vendor. A portal is its front door. An orchestrator is one of its stations. An IaC generator is a faster way to write the input the factory exists to make unnecessary.

Production line

An end to end line

An agent working a backlog at night needs an environment to validate a change against a real database and a public endpoint. Nobody is awake to open a ticket. This is the line that serves it, built from open source building blocks that exist today. Each station names the projects that implement it.

  1. Intent arrives

    The agent calls a tool exposed over MCP or a plain API: an environment for the service orders-api, with Postgres, a public endpoint, classification derived from its data sources, for 48 hours. A human in a portal sends the same request through a form. Nobody writes Terraform here.

    What moves to the next station

    A structured intent, as YAML or JSON, validated against a published schema.

    Building blocks
    • MCP tool server
    • Backstage
    • Portal or CLI
  2. Golden-path contract

    The intent resolves to a published abstraction: a Kratix Promise or a Crossplane Composition. The contract is versioned and machine-readable. It lists what the requester may choose and what the platform decides, which is exactly the information an agent needs to ask for something fulfillable the first time. One Kratix customer put it plainly: "instead of letting AI freestyle infrastructure code, you give it structured abstractions to work with."15

    What moves to the next station

    A claim against a named contract version.

    Building blocks
    • Crossplane
    • Kratix
    • Backstage software templates
  3. A policy pre-check the agent can read

    OPA or Kyverno evaluates the claim before anything is created and returns allow or deny with a reason the agent can act on. Defaults fill the fields the agent cannot sign: the cost center from the owning team's catalog record, the compliance owner by delegation, the classification from the declared data. A denial is a usable answer, and never a ticket.

    What moves to the next station

    An admitted claim with ownership, classification and budget attached, plus the policy decision kept as evidence.

    Building blocks
    • Open Policy Agent
    • Kyverno
    • Gatekeeper
  4. Vend

    The vending lines that already exist do their work: an account or project from AWS Account Factory for Terraform, Azure subscription vending or Google's project factory; a cluster or namespace from Cluster API or a virtual cluster; the Postgres and the endpoint from OpenTofu modules. GitOps reconciles the result and keeps reconciling it.

    What moves to the next station

    A reconciled environment, with endpoints and a record of what was created.

    Building blocks
    • OpenTofu
    • Argo CD
    • Flux
    • Cluster API (Kubernetes SIG)
    • Account Factory for Terraform
  5. Execution sandbox for untrusted code

    When the environment exists to run code an LLM wrote, a Kubernetes Agent Sandbox supplies the isolated runtime from a warm pool, claimed in seconds. The sandbox is one station and never the whole factory. Stations three, six and seven are what the CNCF means by "sandboxing your agent is not enough"10.

    What moves to the next station

    A SandboxClaim bound to a running, isolated workload.

    Building blocks
    • Agent Sandbox (SIG Apps)
    • gVisor or Kata Containers
  6. Attach what humans used to add by hand

    Workload identity for the environment, and a scoped, least-privilege identity for the agent that asked for it. Telemetry wired to the platform's collectors. Cost attribution tags that match the cost center from station three. The ownership record registered in the catalog. None of this needs a person, and all of it used to wait for one.

    What moves to the next station

    An environment that is observable, attributable, and reachable only by the identities the policy allowed.

    Building blocks
    • SPIFFE / SPIRE
    • OpenTelemetry
    • OpenCost
    • Backstage catalog
  7. Hand over, then reclaim

    The requester receives endpoints, credentials through the identity system, and the evidence bundle: policy decisions, owner, classification, budget. The TTL and the owner record make reclamation automatic. The factory emits its own metrics at this station: lead time, zero-touch, time to owner.

    What leaves the line

    An environment in use, a metrics record, and a scheduled reclaim.

    Building blocks
    • Prometheus
    • Kyverno cleanup policies
    • Argo CD or Flux

CNCF project    Other open source, Kubernetes SIG or cloud-provider building block

The loop

Station eight closes the line into a loop

The line ends at hand-over only on a diagram. In a factory, the environment keeps reporting, and what it reports becomes the next intent.

Station eight turns the line into a loop 1 Intent 2 Contract 3 Pre-check 4 Vend 5 Sandbox 6 Attach 7 Hand over 8 Observe drift · expiry · cost anomalies · incidents · policy changes become new intents
Station eight. What a running environment reports becomes the next intent, which is what makes the factory a loop. Download PNG

Operate: observe, remediate, reclaim

Five signals leave a running environment and re-enter the line as intents. Drift: the environment no longer matches its contract, so the factory reconciles it or raises a change. Expiry: the lifetime ends, so the factory reclaims, or the owner renews through a request like any other. Cost anomalies: spend leaves the budget ceiling, so the factory throttles, notifies the owner, or both. Incidents: an alert names the environment, so a remediation agent raises the fix as a pull request. Policy changes: a rule changes, so every environment it touches is re-evaluated and the gaps become work.

Why it matters

Without station eight the factory produces environments and forgets them. Orphans accumulate, cost drifts, and the audit is assembled by hand. With it, the factory's output is also its input, which is what makes the metrics on the metrics page measurable at all.

Operations

Operations is the loop, and agents run most of it

There is no separate operations department behind the line. Every operational event is a signal from station eight, and every response is an intent that goes through the same contract, policy and evidence path as a new environment. That makes operations the place where agents do the most work: the events are frequent, the fixes are mostly known, and the contract says what a correct state looks like.

  • Triage agentReads the alert, compares the environment against its contract and decides on which side of the boundary the problem sits: the factory's or the workload's. Routes it to the owner from the catalog with the evidence attached.
  • Remediation agentRaises the fix for a known failure or a drift as a pull request on the infrastructure line. The policy engine decides whether it may apply on its own or needs the owner.
  • Rollout agentMoves environments to a new contract version: OS and cluster upgrades, certificate rotation, CVE fixes. Canary first, then waves inside the maintenance windows the contract names, and a rollback when a health check fails.
  • Cost agentWatches spend against the budget ceiling, right-sizes idle capacity and asks the owner before anything is throttled.
  • Steward agentFinds orphans and environments near expiry, asks owners, and hands renewals and reclaims to the engine.

The rule is the same as on the line: agents propose and execute within the contract, engines decide, people decide once. A human approves only where the contract says so: a change to production outside its window, a blast radius above a threshold, or a fix the contract does not describe.

Who operates the factory itself

The platform engineers. The factory is a production system with its own on-call rotation, its own SLOs (the metrics in factor XI) and its own environments, vended by its own line where it can. When the front door or the gate is down, environments that exist keep running; only new requests wait. An emergency change made by hand goes through a break-glass path and is recorded as an intent afterwards, so the evidence stays complete.

Who owns an incident

The contract draws the line. The factory owns what the contract promises: the account, the cluster, the network, identity, monitoring and backup. The on-call owner attached at station six owns the workload: code, data and configuration. The triage agent checks the environment against the contract first. If it has drifted, the incident is the factory's. If it has not, it goes to the workload's owner, and the signal goes back to the software factory as its next input.

How long-lived production is kept current

Everything expires, in production too, but what expires is the contract version, not the environment. OS and cluster upgrades, certificate rotation and CVE fixes arrive as a new contract version. An environment on an outdated version is drift, and the rollout agent moves it forward in waves. Renewal of a production environment is a re-attestation: the owner, the budget and the classification are confirmed again, and nothing is deleted.

What stays with humans

Writing and changing contracts and policies, approving at the checkpoints the contract names, and running the post-incident review. When the same incident comes back, the fix belongs in the contract or the policy, not in another remediation.

The workers

Who does what

Agents

Raise and execute Terraform pull requests, remediations, rollouts and CVE fixes, and triage what the running environments report, within the contract and under a scoped identity. Most of operations is theirs.

Humans

Sign ownership once, through contracts and defaults, and approve at the few defined checkpoints: a renewal above a threshold, a classification the contract does not cover.

Platform engineers

Build the factory: the contracts, the policies, the vending lines and the inventory. They do not fulfil requests, and they are on call for the factory itself. How platform engineering holds the three factories together.

Factors

Twelve factors of an Infrastructure Factory

The Twelve-Factor App of 201134 told a generation how to write software that a platform could run. These twelve say how to build the platform that agents can run on. Each one is written as a test. A factory either passes it, or there is a ticket in the path somewhere.

Intents over resource lists.

Defaults over approvals.

Contracts over tickets.

Evidence over reports.

There is value on the right of every line. The factory encodes it once, so that nobody has to supply it per request.

  1. I

    Intent in

    The input is an intent: what the environment is for, who owns it, what data it touches, how long it lives. Never a resource list. A resource list is the factory's output, translated back into its inputs by a human.

  2. II

    Environment out

    The output is an environment that is owned, compliant, observable and cost-attributed on arrival. Anything less is a resource, and resources are what the ticket queue used to deliver.

  3. III

    Machine-readable contracts

    What the requester may choose and what the platform decides is a versioned schema. The API is the interface; portals and CLIs are views on it. Agents are first-class customers, and a contract an agent cannot read is a contract a human will be asked to interpret.

  4. IV

    No ticket in the path

    Humans decide once, at the contract, or encode the decision as a default, a delegation or a policy. A human may be notified. A human is never a blocking station. Platform engineers build the line; they do not fulfil requests.

  5. V

    Policy before provisioning

    The pre-check returns allow or deny, with a reason the requester can act on, before anything is created. Nothing is built to be torn down by a reviewer later, and a denial is an answer rather than an escalation.

  6. VI

    Ownership by default

    Cost center, compliance owner, on-call owner and data classification are inherited from the catalog, never typed into a form. No reachable owner, no environment.

  7. VII

    Scoped identity for every requester

    Every request runs under a short-lived, least-privilege identity, agents included. Credentials move through the identity system and never through a prompt, a ticket or a chat message.

  8. VIII

    Everything expires

    A lifetime is part of every intent. Renewal is a request like any other and carries the same owner. Reclaim is automatic, and an orphan is a defect of the factory, not of the requester.

  9. IX

    Evidence ships with the product

    The decision record travels with the environment: policies evaluated, owner, classification, budget, jurisdiction. An audit reads the factory's output, not a spreadsheet assembled afterwards.

  10. X

    Capacity is inventory

    Warm pools, quotas and buffer stock absorb bursts. Where elasticity is missing, the factory keeps stock and publishes its fill rate instead of pretending that lead time is zero.

  11. XI

    The factory measures itself

    Lead time to a compliant environment, environments per platform engineer, zero-touch rate, policy-violation rate, time to owner, orphan rate. Published to the factory's customers the way an SLO is, and argued about the same way.

  12. XII

    Built from replaceable parts

    Contracts outlive tools. Every station is a building block that can be swapped, Crossplane for Kratix, Kyverno for OPA, a hyperscaler for a rack, without changing what the requester asks for or what the requester gets back.

Checklist

You have an infrastructure factory when

  • An agent with a scoped identity can obtain an owned, compliant environment with nobody awake.
  • Every environment has a reachable owner, a cost center and a classification before it exists.
  • Every denial carries a reason the requester can act on without opening a ticket.
  • Every environment has a lifetime, and reclaim runs without a human.
  • Every environment ships with its decision record.
  • The factory publishes its own lead time, zero-touch rate, time to owner and orphan rate.
  • A contract can move to another terrain without changing what the requester asks for.
  • Platform engineers spend their time on contracts, policies and lines, and none of it fulfilling requests.

Maturity

From ticket desk to factory

Most organizations are somewhere on this ladder. Each stage keeps everything the previous one built and removes one kind of human from the path. The test at every stage is the same: can an agent with a scoped identity obtain an owned, compliant environment at any time?

  1. 0

    Ticket desk

    Requests arrive as text. People build what they understand. Lead time is days to weeks, and the organization measures the queue.

    Fails the test: nobody is awake.

  2. 1

    Automated fulfilment

    Scripts and modules do the building, but a person still approves, classifies and assigns cost. Lead time drops; the queue stays.

    Fails the test: the approval is a person.

  3. 2

    Self-service portal

    Humans fill forms. Decisions are still made per request, behind the form, and the form itself is unreadable to an agent.

    Fails the test: the agent cannot fill the form, and the form cannot sign the owner.

  4. 3

    Contracted API

    Machine-readable contracts, a policy pre-check with readable denials, defaults for ownership. Agents can ask. Evidence, lifetime and capacity are still somebody else's problem.

    Fails the test at volume: orphans accumulate and the audit is compiled by hand.

  5. 4

    Infrastructure Factory

    Ownership by default, identity for every requester, a lifetime on everything, evidence shipped with the product, capacity held as inventory, and the factory publishing its own metrics.

    Passes the test, at production volume, on every terrain.

Where to start

Vending lines as foundation

Start narrow, where demand is highest and the blast radius is smallest. The software factory sources give the same advice for their own lines: Factory suggests incident triage first, and Lloyd lets triage send easy, unambiguous issues straight to implementation.4136

  1. 1

    Ephemeral sandboxes for coding agents

    The first line. Demand is already there: sandboxes on GKE grew 16x in under five months after the Agent Sandbox preview.9 A sandbox needs an identity, a lifetime and a policy, and nothing a human has to sign. It is the smallest complete environment.

  2. 2

    Preview environments per pull request

    The second line. Every change gets an environment with the service, its data and its endpoint, owned by the change's owner, reclaimed at merge. This is where ownership defaults and cost attribution get exercised at volume.

  3. 3

    Production vending

    The third line. Accounts, projects, clusters and namespaces with the full evidence bundle. By now the contracts, policies and inventory exist, and production is one more terrain for them.