Actions that we see more and more often happening: It is 3:12 in the morning. A coding agent has just finished a change to orders-api. The local tests pass. Before it opens the pull request, it wants to do what any decent engineer does: run the thing somewhere real. A database, a public endpoint, a couple of hours testing it in real conditions, and then throw it away.
In most companies, what happens next is a ticket. You know, your beloved tools like Jira or ServiceNow. And then you have to wait. And wait.
The agent does not sleep; it waits, but the ticket idles somewhere in the void of the service organization of a company. And what happens then is that a platform engineer starts looking at it some day later, reviews the demand, and pulls out a blueprint of a Terraform, then needs to find a cost center nobody has assigned yet and a security check designed for humans who ask once a quarter, but not for agents that ask forty times a night. (and that would be heavily underrated if you run a software factory)
Code got cheap. The environments it needs did not.
What the numbers say
Google says 75 percent of its new code is now AI-generated and engineer-approved. Faros AI measured what that does downstream: median review time per change is up 441 percent while throughput per developer rose 33.7 percent. CircleCI saw daily pipeline runs climb 59 percent while main-branch throughput for the median team fell 7 percent.
Anthropic had to build a new software versioning tool to replace Git because of high throughput.
More code, more runs, less shipping? These figures come from organizations that benefit from them, so read them as direction. But the direction is unambiguous: the bottleneck not is the editor, its the infrastructure. It sits in every station after the code is written and published.
The queue
Picture a conveyor belt where agents produce pull requests and next to it a second belt where each of those pull requests needs somewhere to run. Both receive work at the same rate. The first runs at machine speed. The second has a human gate: a ticket, an approval, a review.
Little’s law explains the rest. At forty environment requests a day and a three-day lead time, you carry 120 open requests at any moment. Cut the lead time to twenty minutes and the same demand leaves 0.6 in the queue. Nothing about the demand changed. Only the gate!
This is the state of most enterprises I talk to: a platform team serving hundreds or thousands of developers, built for a world where a developer asked for an environment once a month. The same team now faces agents that ask every time they want to validate a change. A software factory feeding a manual infrastructure shop is like stuffed goose.
Every software factory has a blind spot
I spent the last months going through the most-cited software factory talks and articles of this year: Factory, Warp, Tessl, WorkOS, Port, Boundary, and a handful of independent builders, dozens of pieces. They agree on what a software factory is: a codified, largely automated production system that carries work through the entire lifecycle, from incoming signal to monitoring, with agents doing the execution and humans approving at defined checkpoints. Engineers build the factory; the factory builds the product.
Some sources also agree on something they rarely say out loud.
Tessl: the agent-ready stack is always more work than teams expect.
Boundary and HumanLayer: the development environment is the most underrated layer, and you should own it.
A senior engineer walking through his own factory: most of the real work is making environments reproducible.
Factory lists reproducible environments as an agent-readiness pillar.
Warp calls centrally managed environments one of three foundations.
Not one of them treats infrastructure as a factory with its own product, its own loop and its own metrics.
Everyone stands on it. Nobody owns it. Because none have reached the state of a true agentic software factory machinery yet.
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.
So a platform is a product with customers, a backlog and a service level. An intent states purpose, owner, data and lifetime, not a list of resources. Therefore, is an environment the unit of product; a virtual machine is only a part of it and a container just an entity. No ticket in the path means humans decide once, at the contract, through defaults and policies and nobody decides per request. A human never sits in one of those stations and become the bottleneck.
Let’s walk imaginary down the factory line. An intent arrives through MCP, an API or a portal and is validated against a published schema. It resolves to a golden-path contract that says what the requester may choose and what the platform decides. A policy check the agent can read returns allow or deny with a reason and defaults fill the fields an agent couldn’t sign: cost center, compliance owner, classification, network zone, lifetime. The vending lines create the account, cluster, namespace or managed service. If the environment must run code or other artifacts an LLM wrote, an isolated sandbox is claimed from a warm pool. Identity, telemetry, cost tags, and the ownership record are attached autonomously. The requester gets endpoints, credentials and an evidence bundle, and the time-to-live makes reclamation automatic.
At this point, the loop closes. Drift, expiry, cost anomalies, incidents and policy changes re-enter the line as new intents. The factory monitors what it vended and reacts with what is required to change to meet new intents.
It’s not NVIDIA’s AI factory
NVIDIA’s AI factory turns power into tokens. That is infrastructure too, specialized but honestly also focused on one highly opinionated stack: from the network to the model. An AI factory in the model sense sources, adapts, evaluates and serves models. An infrastructure factory produces environments.
What they share is a floor: GPU quotas, inference endpoints, model and artifact registries, identity, policy, cost, observability, the sandboxes agents run in. The infrastructure and AI factories share a floor, but not the product. It is important to clarify the ownership. The infrastructure factory operates as the serving platform; the AI factory decides what runs on it.
In my opinion, the infrastructure factory can be the AI factory, but doesn’t need to be, if you don’t build on your own dedicated hardware.
Is yours a factory?
I haven’t found one yet that really reached the infrastructure factory, but I thought about what could be the identification criteria for it.
Intent in, environment out. Requesters state purpose and constraints; the platform picks the resources.
No ticket in the path. A human is never involved between request and environment.
Policy before provisioning. Allow or deny with a reason, before anything is created; not by a change advisory board 4 weeks after the request.
Ownership and expiry by default. Every environment has an owner, a cost center and an end date from the moment it exists.
The factory measures itself. Lead time to a compliant environment, zero-touch rate, time to owner, orphan rate.
Why your CFO and your CISO should care
Let’s talk money and business. Every finished request, every published new code that stucks in pipes is work nobody can use yet and every environment that outlives its purpose is capacity you pay for. A factory treats capacity as inventory with a lead time, attaches the cost center at vending time instead of reconstructing it at month end and reports an orphan rate the way a warehouse reports shrinkage.
Contracts cover the sovereignty case. An agent does not know where your data may live, which jurisdiction a workload falls under, or which provider you are allowed to depend on. The contract knows. In a factory the contract carries the jurisdiction, the proof ships with the product and the parts are replaceable, so the platform can say no to a provider without saying no to its customers.
For European enterprises and public sector operators, this is where sovereignty stops being a mystery and becomes a property of every environment you vend.
Where to start?
Do not build the whole factory. Build one vending line.
Start with ephemeral sandboxes for coding agents: isolated, pre-warmed, 48-hour environments an agent can claim to validate its own change. Google Cloud reports sandboxes on GKE grew 16x in under five months after it previewed exactly this.
Second line: preview environments per pull request.
Third: production vending, the one that needs the full contract.
Measure lead time to a compliant environment from the first day and see how it develops over time.
The thing under the thing
Platform engineering was never about Kubernetes. I think it's now becoming a discipline for how to run factories. For the last five years we built platforms for developers who asked politely and waited.
But within one year, the customer has changed. Agents do not wait, they do not sleep, and if wrongly instrumentalized, they don’t respect borders.
The platform that serves them is the infrastructure factory.
The full concept lives at infrastructure-factory.com: the definition, the twelve factors, the seven-station line, the metrics, a live queue model you can play with, and every figure with its source. It is a working concept under Apache 2.0. Argue with it on GitHub, or reply to this post and tell me in which state your platform is. I read every answer.
Figures from Google, Faros AI, CircleCI and Google Cloud are vendor-reported; sources and caveats at infrastructure-factory.com/sources.