Software factory
What a software factory is, and why it needs an infrastructure factory
Everyone describes the software factory as a loop that runs the whole lifecycle. Almost nobody describes the floor it stands on. This page defines the factory from its own sources, then shows where the floor is missing.
Definition
A definition thirteen sources agree on
Thirteen talks, articles and walkthroughs published between January 2024 and October 2026 describe the software factory. Their common ground is one sentence.
A software factory is a codified, largely automated production system that carries work through the entire software lifecycle: from incoming signals (requests, bugs, alerts) through planning, implementation, verification and release to monitoring. Agents do most of the execution inside standardized workflows and quality gates, humans set intent and approve at defined checkpoints, and the system measures its own runs and feeds what it learns back into itself. Engineers build and tune the factory; the factory builds the product.
The definition is drawn from thirteen sources published between January 2024, when Jama described a software factory before coding agents existed,46 and October 2026. They are numbered 35 to 47 on the sources page. The term is contested enough that WorkOS gave a conference talk titled "No, That's Not a Software Factory".43 A definition has to be earned from the sources, not asserted.
The loop
Monitoring feeds the next signals
A factory is a loop, not a pipeline. Two properties separate it from a team that ships code with agents.
Warp's architecture article names the two properties.47 Standardized inputs: every unit of work carries scope, acceptance criteria, an owner and a target environment before an agent touches it. Standardized tooling: agent and human changes pass one gateway, one set of evaluations and one release control. Everything else in the loop follows from those two.
Warp's own numbers show where the loop waits. Kickoff to pull request takes about 35 minutes. Pull request to first human review takes about 3.5 hours, at more than 2,000 pull requests a month.36 The human checkpoint, not the agent, sets the cycle time. The figures are self-reported; read them as direction.
Who builds it
Engineers become factory engineers
The job moves from writing the product to building and tuning the system that writes it.
Zach Lloyd's talk at the AI Engineer World's Fair carries the shift in its title: software engineering is becoming factory engineering.38 The factory itself is code and markdown: repositories, MCP servers, configuration and agent definitions, versioned like any other code.38 For a solo builder it is five or six markdown files.42 Matt Pocock open-sourced his own "AFK software factory", a build-to-merge loop that runs while he is away from the keyboard.39
Lloyd's prediction is that every project of size will run a factory the way every project now runs continuous integration.38 If that holds, the question stops being whether a team has a factory and becomes what the factory runs on. That is the subject of the rest of this page.
Where it runs
The floor
Every source assumes a layer of infrastructure under the loop. Assembled across the thirteen, mostly from Warp's architecture article and Factory's agent-readiness pillars, it has five layers and a cross-cutting set.4741
- Control planeDispatch, scheduling, budgets, audit trail.
- Context and data planeMCP gateway, context lake, memory, session data.
- Dev environments and infrastructure as codeReproducible, previewable, agent-ready.
- Compute and sandboxesIsolated execution, virtual machines for computer use.
- Models and inferenceRouting, providers, self-hosted open models.
- Cross-cuttingIdentity and access, policy and audit, observability and replay, security and supply chain.
The gap
The floor is a prerequisite in every source, and a factory in none
Several sources call the floor the hardest part. None gives it a product, a loop or metrics of its own.
- Dru Knox of Tessl: the agent-ready stack is always more work than teams expect.40
- Dex Horthy and Vaibhav Gupta: the development environment is the most underrated layer, and you should own it.45
- theSeniorDev's step-by-step walkthrough: most of the real work is making environments reproducible. Its own factory runs 10 to 20 pull requests per developer per day, with a full end-to-end suite at about $1.50 per run, self-reported.37
- Davis Palmie of Factory: reproducible development environments are one of eight agent-readiness pillars.41
- Tereza Tížková of Factory: validation took about 40% of a 16-hour customer mission, and validation needs somewhere to run.35
- Warp's architecture article lists centrally managed development environments as one of three foundations.47
- Port runs Terraform pull requests, incident remediation and CVE fixes as factory lines, and reports that its context layer cut agent cost by up to 80% in its own research, a vendor claim.44
None of the thirteen treats infrastructure as a factory with its own product, loop and metrics. That is the gap this site fills.
Why
Why a software factory needs an infrastructure factory
It consumes environments
Every unit of work carries a target environment. The software factory does not make environments. It consumes them from the infrastructure factory.
Its agents run on models
The coding agents that do the execution run on models served by the AI factory, through a gateway the infrastructure factory operates.
It builds the code of both
The contracts, policies and vending lines of the infrastructure factory are code. So are the evaluation harnesses of the AI factory. The software factory builds them.
The throughput argument
At agent throughput, a human-gated environment line is the queue. Both lanes receive the same work at the same rate; the software lane ships in minutes, and the environment lane stops at a gate a person opens a few times a day. Work in progress equals arrival rate times lead time, so the queue grows until the gate is removed. The live model shows it, and the metrics page does the arithmetic.
The ownership argument
An environment request carries fields no agent can sign: cost center, compliance owner, data classification, on-call owner, network zone and lifetime. Each is a human decision, made per request, usually in a ticket. The infrastructure factory resolves them once, by contract: defaults inherited from the catalog, delegation rules, policies evaluated before provisioning. The ownership table on the evidence page shows the same request resolved both ways.
Symmetry
The Infrastructure Factory mirrors the software factory
Factory.ai, BCG Platinion, StrongDM and Uber describe the software factory in the same terms: a production system with inputs, agent workers, quality gates and a throughput number. The Infrastructure Factory has the same shape. Its product is an environment instead of a pull request, and the software factory is one of its customers.
| Element | Software factory | Infrastructure factory |
|---|---|---|
| Product | Pull requests, releases | Environments: compliant, owned, observable, cost-attributed |
| Inputs | Business intent, issues, signals, specifications | Intents from humans or agents, policies, budgets, owners |
| Workers | Coding agents, orchestrated by engineers who "build the factories that build the software"1 | Provisioning agents and orchestrators, run by platform engineers who build the factory that builds the environments |
| Production line | Plan, write, test, review, merge, deploy | Request, policy pre-check, vend, attach identity and telemetry and cost, hand over, reclaim |
| Quality gates | Tests, code review, CI, security scanning | Policy as code, admission control, compliance evidence, cost guardrails |
| Unit of trust | A reviewed, tested change | A signed owner, a classified dataset, an attributed cost center |
| Throughput | PRs merged per week, tokens per engineer, DORA metrics | Environments per day, lead time from intent to compliant environment, zero-touch rate |
| Failure mode | Review backlog, unverified code, main-branch regressions | Ticket queues, orphaned resources, unowned spend, policy drift |
| Who already has one | NVIDIA, EY, Adobe, Palo Alto Networks, Adyen, Uber, StrongDM, per their own accounts163 | Platform One, AWS Control Tower users with Account Factory, landing-zone factories. None of them names it.2224 |
"Isn't infrastructure just a station in the software factory?"
Some definitions say yes. Encore's AI software factory "provisions and deploys to the team's own cloud account" and pays off "once standing up infrastructure for each experiment is the thing slowing the agents down"14. Port writes that platform engineering moved "from building a portal to building the software factory", and that the portal work "is largely finished"13. (voice from the off: I don't agree on how Port defines platform engineering, that was never about building a portal)
Those definitions treat infrastructure as one step inside one code pipeline. The Infrastructure Factory is a separate production system with its own inputs (intents, policies, budgets, owners), its own throughput and its own failure modes. It serves workloads that no single software factory owns: the data platform, the shared cluster fleet, the compliance boundary, and the sandbox an agent asks for at 3am on behalf of nobody's pipeline.