Earlier this year, OpenAI open-sourced a spec for a daemon that watches your Linear board, picks up tickets, spins up isolated environments, and ships pull requests without a human in the loop. They called it Symphony. A separate project called Paperclip lets you model entire autonomous companies (org charts, reporting lines, budget controls) where every employee is an agent.
I spent a few weeks pulling apart how six engineering organizations are running background coding agents in production. Stripe merges over 1,300 agent-written PRs a week. Spotify's agent has merged more than 1,500 pull requests, on top of a migration system that already automates about half of its PRs. OpenAI's internal team, three engineers initially, shipped a million lines of code in five months with zero manually-written code.
These are factories.
An assembly line showed up while we were arguing about copilots
Most of the AI-in-software conversation is still stuck on copilots: autocomplete, chat-in-IDE, tab-tab-tab. That's the craft era. A skilled worker with a better tool. Background agents are something else. They run on cloud infrastructure, triggered by Slack messages or ticket assignments or cron schedules, and produce finished pull requests that humans review asynchronously. The developer doesn't need to be awake.
Ona, a company working on developer infrastructure, draws a direct parallel to Henry Maudslay's precision lathes in early 19th-century London. Before Maudslay, factories relied on skilled machinists operating lathes by hand. He built machines that produced other machines, and accuracy moved from the worker's hands into the tooling itself.
The same shift is happening in software. When Cursor let their multi-agent research system run on its own for a week, it peaked at a thousand commits per hour. The agents were running a production line.
What the factory looks like
Despite building independently, these organizations converged on the same architecture. A trigger fires into a sandboxed environment with the full toolchain. Context gets injected. An agent loop runs. Verification gates check the output with linters, tests, builds, and sometimes an LLM judge. If it passes, a PR opens for human review.
Symphony codifies this into a spec anyone can implement. Its core is a WORKFLOW.md file (checked into git, version-controlled, diffable) that defines both the agent's prompt template and all runtime configuration: polling cadence, concurrency limits, workspace hooks, sandbox policies. The entire factory floor is code-reviewable. Paperclip takes it further: agents get titles, reporting lines, and job descriptions. Work cascades from company mission to project goals to individual tasks. The human operates as a board of directors.
Factories speed up the end of features
In The End of Features, I wrote that features are depreciating faster than teams can ship them. Code generation dropped the cost of building toward zero, and feature differentiation went with it. Background agents compress this timeline further. When a single engineer can dispatch ten agents in parallel, each working an isolated ticket, a startup ships something Monday and six clones exist by lunch.
The strategic matrix I laid out (bits vs. atoms, easy to copy vs. hard to copy) gets starker. Features and code are now the output of an automated production line. Networks, data flywheels, relationships, physical infrastructure survive because you can't point a factory at them. You can't manufacture a social graph.
For product people, this changes the job. If features are factory output, the PM decides what the factory should produce and why. That means choosing which problems to aim at, what quality bar to enforce, what constraints to set. The backlog stops being a list of features and starts being a list of bets on user problems. The feature is the cheapest part. The bet is what matters.
Context becomes factory infrastructure
I wrote about how individual AI productivity breaks down at team scale through context redundancy, context decay, and capability silos. Five engineers with five personal setups producing five slightly different realities.
Background agents solve this by making shared context mandatory. You can't run a factory on personal preferences. When agents execute autonomously — no human watching, no one steering — the context has to be versioned and mechanically enforced. Wiki pages and prompt libraries don't work when nobody's in the room.
OpenAI discovered this when they tried a monolithic AGENTS.md file. It rotted immediately, and too much guidance became non-guidance. They replaced it with a lightweight table of contents pointing to structured docs that agents navigate as needed. Linters and CI jobs enforce it, and a recurring agent finds stale documentation and opens fix-up PRs. The documentation maintains itself because the factory depends on it.
Who steers the factory
I wrote about the steersman, the engineer who moves from inside execution loops to above them and keeps problem selection, constraint definition, and drift correction. Background agents make this concrete. Every organization in the research describes this pattern.
OpenAI: "Humans interact with the system almost entirely through prompts." Their engineers' job became designing environments, specifying intent, and building feedback loops.
But the PM version of the steersman looks different. The engineer-steersman asks: did the agent produce correct code? The PM-steersman asks: are we aimed at the right problems? Would a customer want this? That second question gets harder in a factory model. When code is cheap, the temptation is to build everything and see what sticks. Ona identifies this as "the false summit." You rolled out agents, PRs flood in, yet cycle time doesn't budge and DORA metrics stay flat. Undirected production creates inventory. Someone has to decide what gets manufactured. That's product work.
Anyone can download the blueprint
Symphony's README tells you to paste its spec into your coding agent and ask it to build an implementation. Paperclip is a single npx command. Both are permissively licensed. The orchestration layer, the thing that turns a coding agent into a factory, is commoditizing. Before these projects, this required a platform team at a company the size of Stripe. A motivated engineer with a weekend can get something running now.
This compresses the remaining human advantage further toward taste, judgment, and the non-code moats I described in "The End of Features." The factory doesn't eliminate the PM role any more than the Industrial Revolution eliminated managers. Factories still need someone deciding what to produce, maintaining quality standards, watching for drift between output and intent. But the PM who thinks in features is working in the quadrant that matters least. The PM who thinks in problems, verification criteria, and compounding advantages is designing the factory.
Norbert Wiener's anti-aircraft gunners kept target selection. For now, so do we. The factory just made the guns faster.