The software factory is back. Robert Bemer was writing about one at General Electric in the late 1960s. Hitachi opened its Software Works in 1969. Michael Cusumano published Japan’s Software Factories in 1991. For most of the sixty years since, the phrase described a dream that never quite landed — standardized tooling, repeatable production, manufacturing discipline applied to code — and it became a reliable object of ridicule. Now it is back, and this time the company building one is literally named Factory. In September 2026 it raised $200 million at a $5 billion valuation for agents called Droids, which write, test, review, and ship code in enterprise repositories. The word went from punchline to pitch deck.

The meaning changed along the way. The old software factory — Toshiba’s 1981 operation, NASA’s Software Engineering Laboratory — assembled software from reusable, pre-defined components. The design was assumed solved; the factory stamped out implementations. Today’s version inverts that. The agents are not on the line assembling parts from a finished design. They are doing the design work itself, end to end. Zach Lloyd, the CEO of Warp, told his own company this in a memo that is worth reading whole: the job of engineers “is no longer to write code. It’s not even to build products. It’s to build an internal machine – a cloud software factory – that builds the products for them.” His factory runs a fixed loop: triage, spec, implementation, review, and verification agents, then human review, CI, ship, and a monitor agent that files the next tickets. Warp sells that loop as a platform called Oz. Its metrics are throughput metrics — percentage of fully automated tasks, shipped product divided by inference cost plus human time.

OpenAI runs the same idea internally. Gergely Orosz interviewed seven OpenAI engineering leaders about their software factory: Perf Factory watches production, an agent named Sevbot handles incidents, and the goal is autonomous SRE on every change. “Everything is now a coding agent,” said Andrew Ambrosino, who leads the desktop team. Venkat Venkataramani, VP of engineering for applied infrastructure, reported a roughly 10x increase in load on some systems in about six months. The audited version comes from Anthropic’s S-1, filed October 26: over 90 percent of September 2026 codebase contributions were written by Claude, and per-engineer daily code volume ran 45 times the 2024 baseline. Google has published its own number all along the curve — 25 percent of new code in late 2024, “well over 30” in early 2025, about 50 a year later, and 75 percent at Cloud Next in April 2026, all approved by engineers.

The three lines measure different things — accepted suggestions, generated code, merged contributions. Every company picks the metric that flatters it. The trend survives the pick. Microsoft’s Satya Nadella hedged at “maybe 20, 30 percent” in April 2025; Anthropic’s number is the one that carries SEC liability.

Under the marketing sits a vendor layer and an open-source floor. The vendor layer: Factory at $5 billion, Warp’s Oz, Cognition’s Devin ($2 billion raised at a $48 billion valuation, with its own SWE-2 model), and Poolside, reported at $12 billion after NVIDIA committed up to $1 billion. The platform giants rename their pipelines instead — GitHub calls it agentic DevOps, Salesforce calls its version the agentic enterprise, AWS ships Kiro. The floor is open source, and it is where most factories are actually assembled from: OpenHands, Princeton’s SWE-agent, OpenAI’s Codex CLI, Google’s Gemini CLI, LangGraph, CrewAI, Microsoft’s Agent Framework with AutoGen merged in, Spotify’s Backstage, n8n. Everyone pitches a factory; nearly every factory is rebuilt from free parts.

The skeptics have history. Jack Reeves argued in 1992 that source code is the design — which makes the factory the compiler, automated for decades. Rob West put the modern version of the objection plainly in September: agents “produce and revise the source, which is to say they produce and revise the design. An agent is not another robot on the assembly line. It is much closer to another designer.” John Wilger adds the economic version: factories exist because replication is expensive; copying a software build costs nothing.

The critics are right about the line and they miss the loop. What the new software factories produce is not code — code is approaching free. They produce evidence: which change, reviewed by which checks, deployed with which credentials, causing what in production. That is what Factory’s own architecture writing describes, what Warp measures, and what Anthropic’s 45x figure quietly assumes exists. Building and governing that loop — instructions, tests, review gates, scoped credentials, monitoring — is orchestration. It is the job this book is about. The factory metaphor earns its keep in exactly one place: not as a description of how agents work, but as a description of the system humans build around them.

So keep the term, and mean the loop. Factory’s own documentation states the constraint that matters: increasing the number of agent sessions will not repair a validation process that cannot tell a correct change from a plausible one. The factory runs either way. What decides whether it works is not the number of agents. It is whether somebody downstream can still tell a correct change from a plausible one. That somebody is the orchestrator.