● Compare
Agents write good code. The work around it is what fails.
Which work to take, how to check it, who decides, when to stop, what it may cost, and how main stays green when many changes merge at once. That is your process. Here is how the usual ways of running agents handle it, and what the factory adds.
“AI doesn’t fix a team; it amplifies what’s already there.”
01 A coding agent on its own
It writes the change. The rest lands on your team.
An engineer hands an agent a task in a terminal or an editor and gets back a branch. For one change, nothing is faster. It says nothing about which change comes next, whether this one is safe to merge, or what a hundred of them cost.
Reads your codebase, writes the code and its tests, and fixes what it is told to fix. One engineer with a good agent gets a lot done.
At the pull request. A person still picks the work, reviews the result, decides when to give up and merges without breaking main. Code written in a minute that waits a week for review is not faster delivery.
- Keep the agent: Claude Code, Codex, OpenCode and Pi run inside the factory.
- Work picked by intake rules from your tracker, CI and alerts.
- An agent reviewer on each change, with review rounds capped.
- A budget per task. At the cap, the agent stops and asks.
- A merge queue that keeps main green.
02 An agent platform that runs tasks
It runs many agents. Your process still lives in people’s heads.
A platform that runs agent tasks gives you parallel runs and one place to watch them. Its unit is the run: a task goes in, a pull request comes out. What happens between runs, such as what comes next, who approves and what merges first, is still decided by people and scripts.
Runs many agents at once, away from engineers’ laptops, and shows what each one is doing right now.
At the edge of the run. When the unit is a run, the order of steps, where a person signs off and how many tries a change gets stay in prompts and habits, where nobody can version them or measure them.
- Your workflow as a graph of steps and decisions, kept in versions.
- A change to the rules previewed on last week’s work before it goes live.
- Decision requests with the evidence and a recommended answer.
- What each merged change cost, with the cost of every run behind it.
- A flag when the build on main breaks or a person waits too long.
03 Build it yourself around CI
The first version is easy. The rest is a product.
A script that turns a labelled issue into a pull request is quick to write. Then come the parts nobody plans for, and each one is found when it fails.
You own every piece, and it fits your stack exactly. Your CI already knows how to build and test your code.
After the demo: stopping a runaway loop, waiting days for an answer without losing the work, retrying without starting the same task twice, testing changes together before main moves, and showing whether any of it helped.
- A stop keeps the work: the answer continues the same run.
- Retries, review rounds and repair rounds counted and capped.
- A repeated call or webhook never starts the same work twice.
- Changes merged in batches, and a failing batch split and checked again.
- Run and change it all from your own agent, with your permissions.
● Before you choose
Questions to ask before you choose
Put them to any vendor, or to your own team. Under each one is how the factory answers it today.
- 01
What happens when two changes that pass alone break main together?
Each change is checked on the exact main it will join before main moves. Changes are checked in batches, and a failing batch is split so one bad change does not hold the rest.
- 02
Who chooses the next piece of work, and by what rule?
Rules per source: labels, filters, priorities between sources, and which workflow each kind of work goes to. A dry run shows where a task would go and why.
- 03
What stops an agent that keeps trying?
Caps on new plans, review rounds and repair rounds, and a budget per task. When the budget runs out, the next agent turn does not start and a person is asked.
- 04
When a person has to decide, what do they see?
Why the work stopped, the evidence, what each answer will do to the work, and a recommended answer. The answer continues the same run.
- 05
What did each merged change cost, and how long did it take?
Cost per merged change and cycle time at p50 and p90, next to changes merged per week and how often a person had to step in.
- 06
How do you change the process without breaking the work in flight?
Every change is a new version with a note, and a change to the rules is previewed on the last seven days of work. Work in flight stays on the version it started with; rolling back means switching to the previous one.
- 07
Can we change agent vendors later?
Yes. Claude Code, Codex, OpenCode and Pi can each run a step, and the workflow, its checks and its limits stay the same whichever one does.
- 08
What happens to problems an agent notices outside its task?
They are filed as separate work instead of being fixed silently. Reviewers block only on an agreed list, and the rest becomes follow-up work.
● Proof
Not a demo. The factory ships itself.
We build this product on itself, with the same queue, checks, budgets and decisions described above.
- 1,753
- changes merged in six weeks
- 87%
- merged with no person stepping in
- 1.0M
- lines of TypeScript, about 40% of them tests
- 10,116
- files in the repository
Our own numbers on our own products: 1,726 of the changes are on the factory’s own code. “No person stepping in” means no human decision, review verdict, recovery or hold on that change. This is not a forecast for your team.