---
title: "AI software factory: five stages and one human queue"
description: "An AI software factory runs coding agents from triggers through 5 stages to a person at the merge gate, and review is where the queue builds."
url: "https://aldena.ai/blog/ai-software-factory"
---

# AI software factory: five stages and one human queue

Published 2026-11-09.

## An AI software factory starts agents from triggers and ends at a person

An AI software factory is a delivery system where [triggers such as a new issue or a CI failure start coding agents](https://www.aihero.dev/ai-coding-dictionary/software-factory), and a team chooses which decisions stay human.

I ship Aldena with one. It's a pipeline in the repo's `.claude/` folder, and it isn't a product you can buy from me yet. I approve the spec, then I decide only what needs me. It also wrote and merged the first version of this post without me.

Every vendor writing about factories sells a layer of one. CircleCI sells validation, Encore sells deployment, LaunchDarkly sells runtime control, and I sell the agents and the inbox. Each vendor draws the factory with its own layer in the middle.

![Flow from a trigger, a new issue or a CI failure, to coding agents to a person for the decisions that stay human, above four cards for the layer each vendor sells: validation from CircleCI, deployment from Encore, runtime control from LaunchDarkly, and the agents and the inbox from Aldena](https://cdn.aldena.ai/images/blog/ai-software-factory-1-20261112.png)

The name is older than the agents. [CircleCI points out](https://circleci.com/blog/software-factory/) that organizations ran software factories long before coding agents existed. Agents changed how much work shows up at the far end.

## An assistant waits for you, and a factory waits for a trigger

Matt Pocock's [AI Hero dictionary](https://www.aihero.dev/ai-coding-dictionary/software-factory) separates a coding assistant from a factory by who starts the session, and in a factory it's an issue, a schedule or a CI failure. [Firecrawl](https://www.firecrawl.dev/blog/ai-software-factory) calls the factory the system around a coding agent.

|                           | Coding assistant         | AI software factory                               |
| ------------------------- | ------------------------ | ------------------------------------------------- |
| Who starts a session      | You, at a prompt         | A trigger                                         |
| Where it runs             | Your checkout            | An isolated workspace                             |
| How many run at once      | As many as you can watch | As many as review can absorb                      |
| Where your attention goes | Every step               | The decisions that stayed human                   |
| What catches a bad change | You, watching            | Automated checks, then a person at the merge gate |

The agent can be identical in both columns. [Claude Code or Codex](https://aldena.ai/blog/ai-coding-agents-guide) in my terminal is an assistant, and the same binary in a sandbox, started by a webhook, is part of a factory. A second agent only helps if somebody has time to read what it opens.

## Published factories share the same five stages

Firecrawl's [teardown](https://www.firecrawl.dev/blog/ai-software-factory) of the factories Stripe, Spotify, Shopify, Uber and Ramp published finds the same 5 stages, each with a gate that decides one thing.

1. **Intake** decides which work is worth starting. Sentry's Seer scores each incoming issue for actionability first.
2. **Isolation** keeps parallel agents from colliding. Stripe boots pre-warmed devboxes in about 10 seconds.
3. **Tools** set what an agent can reach. Stripe's Toolshed exposes roughly 500 internal tools over MCP.
4. **Verification** checks that the change is right. Spotify's LLM judge vetoes about 25% of agent sessions.
5. **The merge gate** says who is accountable. Faire requires two human reviews on agent-authored pull requests.

Firecrawl finds that most published factories keep a human gate on anything that isn't mechanical. Those companies have more engineers than I will ever point at this, and they still kept a person at the last step.

![The five factory stages from Firecrawl's teardown, each with its gate and an example: Intake with Sentry's Seer, Isolation with Stripe's devboxes in about 10 seconds, Tools with Stripe's roughly 500 tools over MCP, Verification with Spotify's LLM judge vetoing about 25% of sessions, and the merge gate with Faire's two human reviews](https://cdn.aldena.ai/images/blog/ai-software-factory-2-20261112.png)

## Review is where the queue builds

Faros's 2026 AI Engineering Report tracked 22,000 developers and, in [LaunchDarkly's summary](https://launchdarkly.com/blog/what-is-an-ai-software-factory/), found pull requests 51% larger and review time nearly tripled at high AI adoption.

Merges per developer rose only 16%. Those figures come through LaunchDarkly, not the report itself. CircleCI's blog [cites its own 2026 State of Software Delivery](https://circleci.com/blog/software-factory/), which points the same way, with feature-branch activity up 15% and throughput on main down almost 7%.

The cleanest numbers are Stephen Toub's write-up of ten months with Copilot's coding agent on Microsoft's `dotnet/runtime`, which Firecrawl calls [the only public like-for-like dataset](https://www.firecrawl.dev/blog/ai-software-factory). Agent pull requests merged 67.9% of the time, against 87.1% for Microsoft's engineers. With a human commit added they merged 86.2% of the time, and fully autonomous ones 55.1%. Revert rates held at 0.6% against 0.8%, so what lands holds up. The waste is everything that doesn't land, and somebody has to read it to find out.

![Faros figures via LaunchDarkly, pull requests 51% larger, review time nearly tripled and merges per developer up 16%, above a bar chart of dotnet/runtime merge rates: Microsoft's engineers 87.1%, agent with a human commit added 86.2%, all agent pull requests 67.9%, fully autonomous agent 55.1%](https://cdn.aldena.ai/images/blog/ai-software-factory-3-20261112.png)

Joe McLean [ran a factory for two weeks](https://medium.com/@islandlife/2-weeks-running-an-ai-software-factory-0378e3ec52b1) to build a music-making app and came away calling review his biggest problem. So the job, so far, leans toward reading code. I have no forecast past that, and I wrote the longer version on [whether AI is replacing software developers](https://aldena.ai/learn/is-ai-replacing-software-developers).

## My factory merged the first version of this post on its own

The marketing pipeline in Aldena's private repo wrote the first version of this post on November 9, 2026, and merged it as pull request #304 about 95 minutes after the run started.

It picked the keyword, drafted the post, ran a content audit and a review for AI tells, and marked its pull request ready. The first CI run failed on one end-to-end test. It came in when Aldena's agents were renamed for what they do, and it fails any blog link whose text ends in "role" or "roles". The draft had linked "the roles" to my post on building an agent team. In its one fix round the pipeline reworded the link, the second run went green, and the pull request merged at 13:36 UTC with no review.

Every gate passed, including the build, an audit of all 60 content pages and the full CI suite. I read the post after it merged. It had no images, six of its ten sections opened on the keyword, and "I'd" turned up nine times. The openers were the pipeline's own doing, since its check for AI tells wants each section to open on a named subject and a fact.

![Timeline of pull request #304 on November 9, 2026: the pipeline picked the keyword, drafted, ran a content audit and an AI tells review, marked the pull request ready, failed the first CI run on one end-to-end test, reworded the link, went green and merged at 13:36 UTC with no review, beside what I found after the merge: no images, six of ten sections opening on the keyword and I'd nine times](https://cdn.aldena.ai/images/blog/ai-software-factory-4-20261112.png)

So the checks caught the mistakes a rule could describe. Whether anyone would want to read the thing needed a person, and the person arrived after the merge. This version waited for me as a draft.

## A factory needs a queue for people too

re:cinq's [autonomy table](https://re-cinq.com/topics/software-factory) sorts changes into four classes: documentation auto-merges, application code needs a human approval, migrations need two keys and regulated work never runs unattended.

I like it because it swaps one big question about autonomy for four small ones. It leaves out the plumbing, though. Once a class stays human, something has to carry each decision to a person with its context.

In Aldena that's the [approval gate](https://aldena.ai/features/human-in-the-loop) and a team inbox. Aldena's own tools, such as project memory, web access and the MCP servers you add, run under an allow, ask or deny policy set per project. Claude Code and Codex agents use their own shell and file tools without asking, so that policy covers Aldena's tools, not every command they run. Asking a person a question is the one tool nobody can switch off.

A chat waiting on a person lands in the inbox, where any member can answer. When an agent stops on questions and approvals at once, they arrive together and you answer them in any order. Here the Project Setup agent has asked which channel launch announcements go to and wants three memory entries approved.

![Aldena inbox card for a Project Setup chat in the Launch Plan project, waiting 5 minutes with 1 of 4 answered: the announcement channel question is answered, a note is typed under the first add project memory approval, Allow all covers the 3 approvals still open, and a second Launch Plan chat with 3 asks waits below](https://cdn.aldena.ai/images/features/human-in-the-loop/inbox-batch-20261108.png)

The agent resumes once, after the last answer. Answer an hour later and the run picks up with everything it had, which matters more to me than anything else on that screen.

## Token price is the wrong number for a factory's cost

A cost-to-merge comparison that [re:cinq cites](https://re-cinq.com/topics/software-factory) found the cheapest coding model spending about $0.05 on generation and $2.81 to $5.73 in total, because 97% of it landed on the review gate.

Automated review costs money too. re:cinq also cites 30 days of Cloudflare's AI review gate at $1.19 per review, with engineers overriding the result 0.6% of the time. Subscriptions hit a different wall. McLean ran Anthropic's Max plan at 20x and ChatGPT Pro at 5x together, and the factory still [hit limits after about 48 hours](https://medium.com/@islandlife/2-weeks-running-an-ai-software-factory-0378e3ec52b1).

Budget per merged change, because a cheap model isn't cheap when its changes don't merge. Aldena's share of the bill is flat, at [$20 a month for Solo, $99 for Team and $249 for Business](https://aldena.ai/pricing), and your model and sandbox providers bill you directly with nothing added on top.

![Bar chart of the cheapest coding model's cost per merged change, about $0.05 for generation against $2.81 to $5.73 in total with 97% landing on the review gate, beside Cloudflare's AI review gate over 30 days at $1.19 per review with 0.6% of results overridden by engineers](https://cdn.aldena.ai/images/blog/ai-software-factory-5-20261112.png)

## A dark factory is a decision per class of change

A dark factory is [a codebase, or part of one, where no human reviews the output](https://www.aihero.dev/ai-coding-dictionary/software-factory), and re:cinq's version keeps people only at [intent and acceptance](https://re-cinq.com/topics/software-factory).

My blog ran dark for the first version of this post. A post is cheap to fix after it ships. Application code is different. Fully autonomous pull requests merged [55.1% of the time](https://www.firecrawl.dev/blog/ai-software-factory) on `dotnet/runtime`, and a team with customers should keep a person at the merge gate until its own numbers say otherwise.

## Build the factory, or buy the layers

Encore's [map of the market](https://encore.dev/articles/best-ai-software-factory-platforms) splits it into coding agents, sandboxes such as e2b and Daytona, deployment platforms and CI/CD, and says most teams combine a coding agent with a platform.

At the open-source end, [coleam00/ai-software-factory](https://github.com/coleam00/ai-software-factory) takes GitHub issues in and puts reviewed, merged pull requests out, on Archon workflows. At the packaged end, [Augment Code's Cosmos](https://www.augmentcode.com/product/software-factory) sets up triggers and agents with checkpoints you choose for an engineer to review. [Factory](https://factory.com/) sells its coding agents to enterprises as the foundation for a software factory.

A team of five should buy most of it, and I know how that sounds coming from me. In [Aldena](https://aldena.ai/features/agents), each agent runs on your team's Anthropic, OpenAI or OpenRouter key, or as Claude Code or Codex in the conversation's sandbox, where [Claude Code can use a member's own Claude plan](https://aldena.ai/blog/claude-code-for-teams).

| Stage        | In Aldena today                                                                                                                                   |
| ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| Intake       | Events in GitHub, Bitbucket, Slack, Gmail, Jira, Linear, Notion, Sentry and Vercel start a run                                                    |
| Isolation    | Each conversation in a [project](https://aldena.ai/features/isolated-projects) gets its own sandbox on a provider your team connects, such as Boat                 |
| Tools        | Aldena's tools and your MCP servers run under a per-project policy, while Claude Code and Codex use their own shell and file tools without asking |
| Verification | The Code Review agent reviews the diff across five lenses, and the Bug Fix agent pins its fix with a regression test                              |
| Merge gate   | The Delivery agent opens the pull request and stops                                                                                               |

Verification is the weak row. Those agents report and test, and they don't replace a CI system you trust. The factory that ties the stages into one pipeline is still my `.claude/` folder, so in Aldena you [pick the agents for your team](https://aldena.ai/blog/how-to-build-an-ai-agent-team) and [wire them into a chart](https://aldena.ai/features/org-chart) yourself.

![Aldena project canvas where each agent card lists its tasks, with the Intake agent on Gemini 3.8 Flash at the top, the Delivery and Requirements agents on Kimi K3 wired to it, the Backend Build and Frontend Build agents on Kimi K3 wired to Delivery, and the line from Backend Build to Delivery lit green while work moves along it](https://cdn.aldena.ai/images/features/org-chart/work-in-flight-20261108.png)

## Start with one trigger and count what reaches you

One trigger on one repository, such as a new GitHub issue, is enough for a first factory, since the first lesson is how many decisions come back to a person each week.

In Aldena, set the project's tools to ask on day one. That policy covers Aldena's tools, so the pull request is still where you check the code. On ask, the agent stops before the call. In this chat Alex asked the Project Setup agent to record three launch facts, and it waits on an approval for each.

![Aldena chat where Alex asks the Project Setup agent to record three launch facts in project memory, one entry each, and the agent waits on three add project memory approvals with 0 of 3 answered, the first open with Allow once, Always allow, Deny and Add note](https://cdn.aldena.ai/images/features/human-in-the-loop/approval-prompt-20261108.png)

When the same approval comes up twice, choose always allow, which writes the policy back so that question stops coming. Then watch the count. If it stops falling, a second agent only lengthens your queue, and that week is better spent on your specs and your checks.