# What is an AI software factory? A guide for engineering teams

A software factory is a repeatable system for turning requests into shipped software. The idea dates to the late 1960s. In 2026 it usually means a delivery loop where AI agents do much of the building while engineers design, supervise, and own the system. This guide explains the term, where it came from, and how teams build one.

- Canonical: https://replicas.dev/resources/what-is-a-software-factory
- Start a free trial: https://app.replicas.dev/auth?mode=signup
- What is an AI software engineer?: https://replicas.dev/resources/ai-software-engineer

## What is a software factory?

A software factory is an organized, repeatable way to produce software: standard inputs, standard tools and environments, checks at every step, and a record of how each change was made. The goal is predictable output as volume grows.

An AI software factory, sometimes called an agentic software factory, applies that idea to coding agents. Agents pick up tasks, write and test code, and open pull requests, while engineers define the work, set the constraints, review the output, and improve the system itself.

## Where the term comes from

The phrase is older than any of the tools now using it.

- **Late 1960s:** Bob Bemer, at General Electric, argued for a software factory with standard tools and a database of past projects.
- **1969:** Hitachi opened its Software Works, organizing software development like a factory with standardized processes and quality control. Toshiba, NEC, and Fujitsu followed.
- **1991:** MIT professor Michael Cusumano documented the Japanese approach in his book Japan's Software Factories.
- **2004:** Microsoft architects Jack Greenfield and Keith Short published Software Factories, about assembling applications from patterns, models, and frameworks.
- **2017:** The US Air Force launched Kessel Run, and "software factory" became the defense sector's name for teams that ship software continuously.
- **2025 to 2026:** Coding agent companies adopted the term for delivery loops where agents do much of the implementation. Factory, Warp, and Augment Code each publish their own definition.

## How an AI software factory works

Most definitions describe the same loop. Agents do more of the middle; people own the ends.

- **Signals:** Work enters from issues, customer reports, error alerts, failed builds, and scheduled maintenance.
- **Triage and plan:** Tasks are scoped, prioritized, and written up with acceptance criteria an agent can check its work against.
- **Build:** An agent implements the change in a prepared environment with the repository, dependencies, and services it needs.
- **Verify:** Tests, linters, CI, and checks of the running application decide whether the change works. The agent fixes what fails before asking for review.
- **Review:** A person, often helped by a review agent, reads the diff and the evidence, then approves, comments, or rejects.
- **Ship and monitor:** Approved changes merge and deploy through the existing pipeline, and production signals feed new work back into the loop.

## What you need to run one

Each part of the loop needs something to run it. Use these questions to assess your setup or a vendor's.

| Component | What it does | Questions to ask |
| --- | --- | --- |
| Task intake | Collects work from the tools where it already starts | Can tasks start from your issue tracker, chat, source control, CI, alerts, and schedules? |
| Environments | Gives each task a reproducible machine with code, dependencies, and services | Is each task isolated, and how long does an environment take to start? |
| Agents | Plan, implement, and fix the work | Which agents and models can you use, and can you change them per task? |
| Verification | Proves the change works before a person looks at it | Can the agent run the test suite, the application, and a browser? |
| Review and approval | Keeps a person accountable for what ships | Where do people approve: the plan, the pull request, the merge, or the deploy? |
| Records and analytics | Shows what was done, by which agent, from which trigger, at what cost | Can you trace a merged change back to the task and session that produced it? |

## What engineers do in a software factory

The work shifts from writing every change to running the system that produces them.

- Write tasks an agent can finish: a clear scope, acceptance criteria, and a way to verify the result.
- Maintain the environments, instructions, and checks that agents work within.
- Review changes and decide what merges, especially where compatibility, security, or production risk is involved.
- Watch where agents fail and fix the cause, such as a missing dependency, an unwritten convention, or a flaky test.
- Decide what to build. A factory makes output cheaper; it does not decide what is worth producing.

## How to start building one

Teams rarely build a software factory in one step. The step-by-step guide covers each stage in detail; in short:

- **Pick one kind of work:** Choose something frequent and easy to verify, such as review follow-ups, CI failures, or dependency upgrades.
- **Make the environment reproducible:** Define the repository setup, dependencies, services, and credentials once, so every task starts the same way.
- **Connect intake:** Let that work start where it already appears, such as a Linear issue, a Slack message, or a failed build.
- **Keep a person on every merge:** Require review of everything agents produce until the results for that kind of work earn trust.
- **Measure, then widen:** Track merge rate, rework, and review time, then add the next kind of work.

## Where Replicas fits in a software factory

Replicas covers the intake, environment, agent, and review parts of the loop. Tasks start from Slack, Linear, GitHub, GitLab, schedules, failed CI runs, webhooks, or the API. Each one runs in its own Linux VM prepared from an environment the team defines once, with the repository, dependencies, services, and integrations ready before the agent starts.

Teams choose Claude Code, Codex, Cursor, OpenCode, or another supported agent per task, so the factory is not tied to one vendor's agent. Reviewers can watch the session, take over the desktop or browser, comment on the diff, and have the agent continue in the same workspace. Your existing CI/CD pipeline still decides what ships.

## FAQ

### Is a software factory the same as CI/CD?
No. CI/CD builds, tests, and deploys changes once they exist. A software factory includes CI/CD but also covers where work comes from, who or what writes the change, and how it is reviewed.

### Is "software factory" the same as Factory, the company?
No. Factory is a company that builds coding agents called Droids and uses the term for its product, and Warp also calls its product a software factory. The idea dates to the 1960s and is not tied to one vendor.

### What is a software factory in the military?
In the US Department of Defense, a software factory is a team and platform that builds and ships software continuously, usually on a shared DevSecOps pipeline. Kessel Run, started by the US Air Force in 2017, is the best-known example.

### Do you need AI agents to have a software factory?
No. The original software factories had no AI at all. Agents change how much of the building can be automated, which is why the term is back.

### How is an AI software factory different from an AI software engineer?
An AI software engineer is one agent working on one task. A software factory is the system around many such tasks: intake, environments, verification, review, and records.

## Start with one kind of work

Replicas includes a 14-day free trial with no credit card required. Connect a repository, define the environment once, and route one kind of work, such as CI failures or review follow-ups, to an agent. Each task runs in its own cloud workspace and comes back as a pull request for your team to review.

## Related docs

- [How to build an AI software factory](https://replicas.dev/resources/how-to-build-a-software-factory): A step-by-step guide from the first kind of work to scaling across a team.
- [What is an AI software engineer?](https://replicas.dev/resources/ai-software-engineer): How a single coding agent takes a task from ticket to pull request, with eight options compared.
- [Agent orchestration for software teams](https://replicas.dev/resources/agent-orchestration): Patterns and platforms for coordinating many coding agents.
- [Multi-agent orchestration for coding agents](https://replicas.dev/resources/multi-agent-orchestration-for-coding-agents): Worktrees, containers, and VMs compared, with a reference architecture for a fleet.
- [Background coding agents](https://replicas.dev/resources/background-coding-agents): How asynchronous coding agents fit into a team's workflow.
- [Software factories (Microsoft)](https://en.wikipedia.org/wiki/Software_factory_(Microsoft_.NET)): Background on the 2004 Microsoft approach by Greenfield and Short.