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
Infrastructure factory
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
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.
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.
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.
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.
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.
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.
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
Each of the parts exists as open source or as a cloud primitive today. The factory is the arrangement of those.
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
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 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 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
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
Capacity held as stock: warm pools, quotas, reservations and, off the cloud, procurement forecasts with a published fill rate.
SandboxWarmPool · node pools · hardware pools
Short-lived, scoped identities for every requester and every workload, agents included. Credentials move through it and nowhere else.
SPIFFE/SPIRE · Keycloak · cloud IAM
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
The table reads left to right as a history: most organizations have built the first three and call the result a platform.
| Dimension | Ticket desk with scripts | Developer portal | Platform orchestrator | Infrastructure Factory |
|---|---|---|---|---|
| Who can ask | Humans, 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 send | Free text. | Form fields. | A specification or a claim. | An intent, with purpose, owner, data and lifetime. |
| Who decides | A 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 back | Resources. | Resources and a catalog entry. | An environment. | An environment with owner, evidence and cost attached. |
| How long it lives | Forever. | Forever. | Sometimes until deleted. | Until its lifetime ends, then it is reclaimed. |
| Whose problem is capacity | Procurement's. | Procurement's. | The cloud's. | The factory's, held as inventory with a fill rate. |
| How it is measured | Ticket 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 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.
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.
A structured intent, as YAML or JSON, validated against a published schema.
Building blocksThe 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
A claim against a named contract version.
Building blocksOPA 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.
An admitted claim with ownership, classification and budget attached, plus the policy decision kept as evidence.
Building blocksThe 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.
A reconciled environment, with endpoints and a record of what was created.
Building blocksWhen 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.
A SandboxClaim bound to a running, isolated workload.
Building blocksWorkload 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.
An environment that is observable, attributable, and reachable only by the identities the policy allowed.
Building blocksThe 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.
An environment in use, a metrics record, and a scheduled reclaim.
Building blocksCNCF project Other open source, Kubernetes SIG or cloud-provider building block
The 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.
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.
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
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.
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.
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.
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.
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.
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
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.
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.
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
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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
Maturity
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?
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.
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.
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.
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.
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
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
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.
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.
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.