# What is a software factory?

A software factory is a repeatable process in which coding agents take work from a queue, build it, check it, and ship it, while people direct the work.

Last updated November 19, 2026, 10 min read

## Learning objectives

After reading this article you will be able to:

-   Define a software factory
-   Explain how work moves through a factory
-   Identify what a factory still needs from people

## Related content

-   [What is a software factory process?](https://specstory.com/learning/software-factories/software-factory-process)
-   [What is verification in a software factory?](https://specstory.com/learning/software-factories/software-factory-verification)
-   [How to build a software factory](https://specstory.com/learning/software-factories/building-a-software-factory)
-   [What is a software factory operator?](https://specstory.com/learning/software-factories/software-factory-operator)
-   [What is the difference between a bespoke and a packaged factory?](https://specstory.com/learning/software-factories/bespoke-vs-packaged-software-factory)

## Key points

-   A software factory is a fixed process that coding agents run and people direct.
-   Each change passes the same stages, and one stage runs the finished software.
-   A team can build its factory or buy one, and it still writes its own checks.

## What is a software factory?

A software factory is a repeatable process in which coding agents take work from a queue, build it, check it, and ship it. People decide what to build and try what comes out. The process is fixed in files and scripts, so each change takes the same route.

The term is older than [coding agents](https://specstory.com/learning/ai-coding/coding-agent). [A 1991 history](https://hdl.handle.net/1721.1/2345) by Michael Cusumano dates the first working definition to R. W. Bemer of General Electric in 1968. The same history says that Hitachi was the first company to call a software facility a factory, when it founded its Software Works in 1969. Those factories organized people around standard methods and tools.

The meaning changed when agents began to write the code. In February 2026, [StrongDM's AI team](https://factory.strongdm.ai/) described a factory in which specifications and scenarios drive agents that write code and run checks, with no human review. Most published factories keep a person in the work, at code review or at the two ends. That wider meaning is the one this page uses.

Agents now start a large share of changes. [GitHub's Octoverse report](https://github.blog/news-insights/octoverse/octoverse-commits-pushes-reach-new-highs-in-2026-as-developers-build-with-agents/) for 2026 says that by September 2026, more than 40% of pull requests on GitHub started with an agent's first draft, up from 17% in March. A software factory is a way to turn that volume of drafts into shipped changes that something has checked.

## How does a software factory work?

The steps below follow [one operator's published log](https://www.meditationsontech.com/p/what-its-like-to-operate-a-software), and other factories differ in the details. One change moves through that factory in seven steps:

1.  An operator asks for a change in a sentence or two.
2.  The request waits in a queue, which can be a file in the repository.
3.  A coordinating agent picks up the request, writes a goal with rules, and starts a workflow.
4.  Agents in the workflow split the work, write the code, and run the tests.
5.  At the check stage, an agent runs the software and reports pass or needs work, with evidence.
6.  A fixer agent fixes each finding, a recheck confirms the fix, and a release script ships the change.
7.  The operator tries the result, and what the operator finds joins the queue.

A coordinating agent is the agent session that turns an operator's request into a written goal, starts a workflow of other agents, and reports the result. It is also called an orchestrator.

Diagram: How work moves through a software factory

People sit at the two ends of the loop. Agents do the steps between, and the check stage runs the software before anything ships.

Three files can hold a small factory together:

-   **A rules file.** The file states the standing rules, e.g. which command runs the tests. A rule in the file reaches each later agent.
-   **A queue file.** The file lists the pending requests in order. It survives a restart, and each agent can read it.
-   **A workflow script.** The script runs the stages in a fixed order, so no agent can skip one.

A larger factory can replace the files with services, and the roles stay the same. Designing those roles and their limits is part of [agentic engineering](https://specstory.com/learning/ai-coding/agentic-engineering).

## What are the types of software factory?

Software factories differ in two ways. One is whether a person checks the work, and the other is who built the factory.

### Attended factory

An attended factory keeps a person at a fixed point in each change. That person reviews the code, or approves the goal before the work starts and tries the result after it ships. Both are [human-in-the-loop](https://specstory.com/learning/ai-coding/human-in-the-loop) work.

### Dark factory

A dark factory has no person who writes the code, reviews it, or tries each change. Automated checks are the only check that a change gets. People still write the specifications and choose what to build.

### Bespoke factory

A bespoke factory is one that a team assembles for its own product, from a rules file, a queue, agent workflows, and its own checks. Its process fits one codebase, and the team owns each part of it.

### Packaged factory

A packaged factory is a product that supplies the pipeline, the agent runners, and the review steps. A team configures it for its own repositories. The team still writes its own acceptance checks and decides what may ship.

## What is an example of a software factory?

Here is an illustrative example. Acme Co. sells furniture online and runs a small attended factory for its store. An operator at Acme adds one line to the queue, "Let customers edit their delivery address during checkout." The factory handles that line in six steps:

1.  The coordinating agent writes a goal and reads back 2 open decisions. The operator accepts the defaults and says go.
2.  Two builder agents change the checkout code, and an integrator agent runs every test.
3.  A checker agent starts the store, changes the delivery address during checkout, and opens the cart.
4.  The checker reports needs work. The address saved, but the cart emptied.
5.  A fixer agent corrects the code, and a recheck agent repeats the same steps and passes the change.
6.  A release script deploys the change, and the operator tries it in the store.

The operator typed one sentence and made one decision. The agents did the rest, and the check stage caught a failure that the builders' tests missed. This example is simplified. A real factory would also keep a record of each step, so a person can see later why a change shipped.

## What are the limits of a software factory?

A software factory has five limits:

-   **A factory ships what its checks allow.** With weak checks, a factory produces broken changes faster than a team did by hand. Using the running software is the job of [runtime verification](https://specstory.com/learning/verification/runtime-verification).
-   **The changes can be too large to read.** In that operator's log, a software factory deployed to production 72 times in 31 days. Its median change touched 4,578 lines of code across 47 files.
-   **A factory costs tokens and attention.** Each stage spends tokens, and a person still has to answer the open decisions.
-   **A factory can depend on one person.** That log describes a factory of one. With one operator, nobody else orders the queue.
-   **A factory can build the wrong thing.** A factory that is measured by output can ship features that no user asked for. The decision about what deserves to be built stays with people.

## How is a software factory different from a CI/CD pipeline?

A [CI/CD](https://specstory.com/learning/ci-cd/ci-cd) pipeline starts when a change already exists. It builds the change, runs the tests, and deploys it. A software factory starts earlier, with a request, and its agents write the change that the pipeline then carries.

The two work together, and they differ on four points:

| Point | CI/CD pipeline | Software factory |
| --- | --- | --- |
| Starts from | A commit or a pull request | A request in a queue |
| Who writes the code | A developer or an agent, before the pipeline | Agents, inside the factory |
| Main check | The project's tests | A stage that uses the running software |
| Role of people | Write, review, and approve | Ask, decide, and try the result |

In most teams, [code review](https://specstory.com/learning/code-review/code-review) sits between writing and the pipeline. A factory either keeps that review or replaces it with checks.

## What does the software factories section cover?

The section covers how factories work, who runs them, and how a team gets one:

-   [A software factory process](https://specstory.com/learning/software-factories/software-factory-process) is the fixed order of stages that each change passes.
-   [Verification](https://specstory.com/learning/software-factories/software-factory-verification) in a software factory is the stage where a separate agent runs the software and reports evidence.
-   [A software factory operator](https://specstory.com/learning/software-factories/software-factory-operator) is the person who asks for changes, answers open decisions, and tries the result.
-   [Build a software factory](https://specstory.com/learning/software-factories/building-a-software-factory) by starting with a rules file, a queue file, and one workflow.
-   [Your own software factory](https://specstory.com/learning/software-factories/build-or-buy-a-software-factory) suits a team whose process is specific to its product, and a bought one suits a team that needs scale first.
-   [A packaged factory](https://specstory.com/learning/software-factories/bespoke-vs-packaged-software-factory) is bought as a product, and a bespoke factory is assembled by the team that uses it.
-   [Examples of software factories](https://specstory.com/learning/software-factories/software-factory-examples) range from one operator with a queue to companies whose agents account for most pull requests.
-   [A dark factory](https://specstory.com/learning/software-factories/dark-factory) is a factory in which no person writes or reviews the code.
-   [Software factories fail](https://specstory.com/learning/software-factories/software-factory-failures) when no stage runs the product, when work is lost or the queue stalls with no alert, or when the codebase gets worse.

[See every Software factories article](https://specstory.com/learning/software-factories)

## How does RunStory help with a software factory?

A factory's own agents build each change and check it, so the builder and the checker work from the same goal and rules. A check from outside those agents adds a second view, in a factory that a team built or in one that it bought.

RunStory checks your software by running it. RunStory independently runs the software against your change and returns evidence to the coding agent. The [workflow guides](https://docs.specstory.com/runstory/workflows) show where that check fits in each way of working.

The operator cited on this page runs the factory that builds RunStory. Your team keeps the final release decision.

[Join the RunStory alpha →](https://specstory.com/runstory#alpha)

## FAQs

### Who first used the term software factory?

The term software factory is decades older than coding agents. A history by Michael Cusumano credits R. W. Bemer of General Electric with the first working definition. The same history says that Hitachi was the first company to call a software facility a factory.

### Does a software factory replace developers?

A software factory changes what developers do more than it removes them. Agents write the code, and people decide what to build, answer the open decisions, and judge the result. Someone also has to design the factory and keep its rules and checks up to date.

### How many agents does a software factory need?

A small software factory can run with a coordinating agent, a builder, and a checker that is a different agent from the builder. A larger factory can add agents that split the work, integrate it, fix findings, and recheck them. The fixed order counts for more than the number of agents.

### Can one person run a software factory?

One person can run a software factory. The published log cited on this page describes a factory of one, with a single operator who asks, decides, and tries the result. That operator is also the one person who orders the queue.

### What does a software factory cost to run?

A software factory costs tokens at each stage, plus the attention of the person who operates it. The checks add to the cost, because a checker has to start the software and use it. The operator's attention is the part that cannot be bought.

---

Source: [What is a software factory? | AI agents | SpecStory](https://specstory.com/learning/software-factories/software-factory)
