Skip to content

Should you build your own software factory?

Building a software factory in house suits a team whose process is specific to its product, while buying one suits a team that needs scale first.

Last updated , 9 min read

Should you build your own software factory?

A team should build its own software factory when its way of working is specific to its product. A team should buy one when it needs many agents running soon and has nobody free to build the infrastructure. In both cases, the checks that decide what ships stay the team's own work.

A software factory is a repeatable process in which coding agents take work from a queue, build it, check it, and ship it. A team can assemble that process in house or buy it as a product.

The choice is smaller than it sounds. A factory that a team builds can start as a few files, and a factory that a team buys still needs the team's own rules and checks. A team can also do both, with a bought runtime and a process it wrote.

Two questions that decide whether a team builds or buys a software factory Do you need many agents soon, with nobody free to build? Is a default process enough to start? yes no no yes Build your own start with a rules file, a queue file, and one workflow Do both buy the runtime and write the process yourself Buy a packaged factory runtime, intake, and a default pipeline, ready made The team's own work on each path rules, tests, acceptance criteria, a scripted way to run the app, and the release decision
The two questions change who supplies the infrastructure. They do not change who writes the rules and the checks.

What causes a team to build its own software factory?

Published accounts give four reasons.

Why does a process specific to one product lead a team to build?

A factory holds the way one team ships one product. When the codebase or the tooling is unusual, a general pipeline can need many changes before it fits.

Stripe's engineering blog says that over a thousand pull requests merged each week at Stripe are produced by its coding agents. People review them, and they contain no code that a person wrote. Stripe built those agents itself. The same post calls its backend "a relatively uncommon stack" and says its custom agent harness connects to tooling Stripe already had.

Why can a team start without a platform?

The first version of a factory can be mostly written process. One operator's factory started as a rules file, a queue kept in one file, and a coding agent that runs workflows in a loop. The rules file had 347 lines when the operator wrote about it.

Why do the checks stay with the team?

The stage that decides what ships needs the team's own account of correct behavior. No vendor has that account, so a team writes or approves those checks whether it builds or buys.

A separate check also earns its place. In 35 of 51 recent phases of one operator's factory, the build step reported the work done and the verify step still found a problem. That verify step is a form of independent verification, because the agent that checks did not write the change.

Why does one operator doubt that a factory is hard to build?

The same operator's post asks who gains when a factory sounds hard to build. Its answer is that a seller of platforms gains a customer, and a buyer gains a reason to ask for headcount and a long roadmap. The post also grants that the largest companies need more infrastructure.

What does a factory that a team built look like?

Here is an illustrative example. Acme Co. sells furniture online. A developer at Acme builds a factory inside the store's repository. It is four files:

AGENTS.md            the rules that each agent reads
docs/BACKLOG.md      the queue, one line for each change
workflows/phase.js   the script that runs the stages in order
checks/checkout.md   the acceptance criteria for the checkout

The developer adds one line to the queue, "Let customers edit their delivery address during checkout." The script then runs five steps:

  1. A coordinating agent reads the rules and writes a goal for the change.
  2. Builder agents change the checkout code, and the store's continuous integration and delivery (CI/CD) pipeline passes.
  3. A checker agent starts the store in an ephemeral environment and follows the checkout criteria.
  4. The checker reports needs work. The address saved, but the cart emptied.
  5. A fixer agent corrects the code, the checker repeats its steps, and one agent commits the change.

Acme wrote the rules, the queue, the script, and the criteria. It bought the coding agent and reused the pipeline it already had. This example is simplified. A real factory would also need a release step and a way to restart a stopped workflow.

When does buying a software factory make sense?

Buying makes sense when a team lacks the infrastructure and a default process is enough to start. A packaged factory supplies the runtime, intake from a team's tools, a default pipeline, measurement, and governance. Three situations favor it:

  • The team needs scale first. Many agents at once need machines and isolation before they need a refined process.
  • Nobody is free to run the infrastructure. A team that maintains its own agent servers has less time for its product.
  • The company needs audit records now. Access roles and a log of each run are available in the product.

Cursor's account of one customer gives an example. Faire, an online commerce company, first built its own cloud agent system on infrastructure it hosted. The account says that getting the developer experience right "requires substantial investment." Faire then chose Cursor's cloud agents, and for one migration "the team built an agent coordination system on top of Cursor called Swarm."

A tool built in house can also become a product that others buy. Ramp says that by October 2026 its internal coding agent, Inspect, accounted for 74% of the company's merged pull requests. The same post opens early access to Inspect for other companies.

How can a team keep the cost of building low?

A factory that a team builds costs engineering time to write and maintain, and tokens to run. Four habits keep that cost low:

  • Start with files. A rules file, often named AGENTS.md, and a queue file work with a coding agent the team already has.
  • Buy the general parts. The coding agent, the models, and the machines are the same for most products.
  • Use open standards for tools. A server written for the Model Context Protocol (MCP) works with each agent that supports it.
  • Write a rule after each failure. Each mistake becomes a line in the rules file, and choosing those lines is context engineering.

Most of this work is harness engineering, and a team that uses coding agents has already started it. The guide on how to build a software factory gives the steps, and the software factory examples show what other teams built. The cost also grows with scale, e.g. a large company needs a gateway for its model requests.

How is building a factory different from buying one?

Building and buying differ in what a team spends and what it controls. A team that builds spends engineering time and can change any stage the same day. A team that buys spends fees and setup time, and does not build the infrastructure.

The parts that describe the product stay in house under either choice. Those are the rules, the tests, the acceptance criteria, a scripted way to run the app, and the release decision. The page on a bespoke software factory and a packaged one compares the two in a table.

What does a factory need whether a team builds or buys it?

A factory of either kind needs one stage that runs the finished software and reports evidence. The agent that wrote the change should not run that stage. A team that builds adds the stage itself, and a team that buys supplies the acceptance criteria. The workflow guides show where such a check fits.

RunStory checks your software by running it. RunStory independently runs the software against your change and returns evidence to the coding agent. The operator cited on this page runs the factory that builds RunStory. Your team keeps the final release decision.

Join the RunStory alpha →

FAQs

Is a software factory hard to build?

One operator's post argues that a software factory is not hard to start, because its first version is mostly written process. A rules file, a queue file, and one workflow script can move a change through fixed stages. Upkeep and scale add work later.

How much does it cost to build a software factory?

The cost to build a software factory is engineering time to write and maintain it, and tokens to run it. A small factory can start with a few files and a coding agent the team already has.

Can a team buy a factory and keep its own process?

A team can buy a factory's runtime and keep its own process. Cursor's account of Faire describes that split, with bought cloud agents and a coordination system that Faire built on top.

Which parts of a factory should stay in house?

The parts of a factory that describe the product should stay in house. Those are the rules, the tests, the acceptance criteria, a scripted way to run the app, and the release decision. A team can buy the coding agent, the models, and the machines.

Who gains when a software factory sounds hard to build?

A seller of platforms gains a customer when a software factory sounds hard to build. A buyer gains a reason to ask for headcount and a long roadmap. One operator's post makes this point and grants that the largest companies need more infrastructure.