Skip to main content
MindStudio
Pricing
BlogAbout
My Workspace

5 Types of AI Software Factories: Dark, Fleet, PR, Release, Self-Improving

A clear breakdown of the five AI software factory models for coding agents, their tradeoffs, and which one actually scales safely.

Edited by Luis Chavez-Mattos, Director of Product RSS
5 Types of AI Software Factories: Dark, Fleet, PR, Release, Self-Improving

What is an AI software factory?

An AI software factory is a system for running coding agents on a batch of issues at once instead of one ticket at a time. Instead of babysitting an agent through a single GitHub issue, you plan a group of tickets up front, let agents handle dependency mapping, parallel builds, and iteration in the middle, and then review the output before it ships. The five main variants (dark, fleet, PR, release, and self-improving) differ mainly in how much human review sits between the agent’s work and production.

TL;DR

  • Software factories batch work by having humans plan upfront and validate at the end, while agents handle dependency mapping, building, and iterating in the middle.
  • Dark factories remove humans entirely and route agent output straight to production, which sounds ideal but breaks down because people rarely communicate intent perfectly every time.
  • Fleet factories use the same zero-review workflow as dark factories but restrict scope to tasks with a clear, testable outcome, like migrations, refactors, and maintenance work, which is why Spotify’s internal tool (called Honk) could merge millions of automated maintenance pull requests.
  • PR factories keep a human reviewing every single pull request, which maximizes reliability but reintroduces a human bottleneck similar to working without a factory at all.
  • Release factories sit in the middle, batching multiple tickets into a scoped release that a human plans upfront and validates before deployment, without reviewing every individual PR.
  • A rough industry study found that about half of test-passing agent pull requests submitted to open-source projects got rejected by maintainers, largely because the agents didn’t understand project direction or intent, the same failure mode that limits dark factories.
  • The right factory type depends on the task, not just on how capable the underlying model is: judgment-heavy work needs more human review, while easily-testable work can run with far less.
Self-host
Remy.
On-prem or in your private cloud. Remy and every app you build stay inside your walls.

How does a software factory actually work?

The core loop is the same across all five types. A human or team plans a batch of work upfront, usually a group of tickets, issues, or a feature set. Coding agents then take over dependency mapping (figuring out what needs to happen in what order), building each piece, running build loops to catch and fix errors, and pushing the result to some kind of staging environment or directly toward production. The human re-enters at the validation stage to review the output before it goes live.

The reason this differs from traditional agent use isn’t the agent’s capability, it’s the scope of autonomy granted in the middle of the loop. Traditionally, a developer stays in the loop for an entire ticket: planning, building, and validating together with the agent. A software factory removes the human from the middle step (the build loop itself) while keeping them firmly in the planning and validation steps. The amount of trust placed in that middle step is what separates the five factory types.

What is a dark factory and why doesn’t it fully work?

A dark factory is the version where an agent manages an entire application. You send in a loosely structured request, and the system plans, builds, reviews, and merges straight to production with no human review at any point. It’s the most autonomous (and most discussed) form of software factory, and it remains mostly a pipe dream for full applications.

The problem isn’t model capability. It’s that communicating intent perfectly, every time, with zero human checkpoint, is nearly impossible. Any gap between what you meant and what you said turns into a shipped mistake, because nothing catches it before production. A public dark-factory experiment demonstrated this directly: a full pipeline with agents building, a separate review agent, and automerge on a passing review worked mechanically, but small misunderstandings about intent still accumulated into real problems in the live application.

Dark factories aren’t worthless. For prototypes and proofs of concept where speed matters more than precision, and where mistakes are cheap to catch and fix later, a dark factory is the fastest way to get something built.

What is a fleet factory and how is it different from a dark factory?

A fleet factory uses the exact same zero-human-review workflow as a dark factory. The difference is scope: instead of trying to manage an entire application, a fleet factory is restricted to tasks that have an unambiguous goal and a clear way to measure success automatically, things like migrations, refactors, and routine maintenance.

This is the “dark factory that actually works,” because the fundamental weakness of the dark factory (ambiguous intent) mostly disappears when the task itself is unambiguous. If a passing test suite can confidently confirm the work is correct, there’s little room for the kind of miscommunication that sinks a dark factory.

Developers have their tools.Enterprises have Remy.
Developers> add rate limiting to the API
● Reading src/server.ts
● Editing 3 files
+ import { limit } from 'rate'
- app.use(cors())
✓ Tests passed · ready for PR
Enterprises
Loan Approvals● Live
SOC 2Role-based accessSelf-hosted
Mortgage · $412,000Approved
Small business · $85,000Approved
Auto · $31,500Approved

Spotify’s internal tool, referred to by them as Honk, is a real-world example: they’ve reportedly merged millions of automated maintenance pull requests and used similar automation for complex migrations. Airbnb has also publicly described migrating thousands of test files in a period of weeks using a similar approach. Bun’s rewrite from Zig to Rust is another cited example of large-scale work handled through this kind of agent automation.

This is also where a widely cited negative study on coding agents fits in. Research into agent-submitted pull requests on open-source projects found that a large share of test-passing PRs still got rejected by maintainers, generally because the agents misunderstood the project’s direction or failed to communicate intent correctly. That’s a dark-factory-style failure: it shows up when agents are given judgment-heavy work without enough scoping or human checkpoints, not when they’re confined to fleet-factory-appropriate tasks.

What is a PR factory and when is it worth the bottleneck?

A PR factory flips the autonomy model: every single pull request gets reviewed by a human before it merges. Because of that checkpoint, a PR factory can be trusted with far more judgment-heavy work than a fleet factory, since a human catches miscommunicated intent before it ships.

Unlike the other factory types, which batch issues together and review output in bulk, a PR factory focuses on one issue at a time, even if multiple agent sessions run in parallel behind the scenes. Tools built around this model (Stripe’s “minions” is one cited example of an open-source implementation of this pattern) typically run an agent through separate planning, building, and iterating sessions per ticket.

The tradeoff is that the human becomes nearly as much of a bottleneck as working without a factory at all. You’re mainly automating the orchestration between planning, building, and iterating, not removing yourself from the review process. Still, it’s a reasonable starting point: it’s the easiest way to test a core build loop at low risk before expanding into a factory with less per-ticket review.

What is a release factory and why is it the recommended middle ground?

A release factory batches a scoped set of tickets into a release, with heavy human involvement in planning upfront and validation before deployment, but without requiring a human to review every single pull request individually. This gives it more scale than a PR factory (since review happens in batch rather than ticket by ticket) while avoiding the unreliability of a dark factory (since a human still validates the release before it ships) and the narrow scope limits of a fleet factory (since it isn’t restricted to only highly-testable tasks).

This middle position is presented as the practical recommendation for most teams: enough automation in the build loop to meaningfully scale output, enough human oversight at the planning and validation stages to catch miscommunicated intent before it reaches production. Releases in this model are kept small and scoped rather than resembling old-school waterfall planning cycles, which keeps the review burden manageable even as the batch size grows.

Where does the self-improving factory fit in?

The enterprise platform for building software with AI.
Vendor Risk Portal✓ SOC 2✓ HIPAA✓ Audit log
VendorsApprovalsContractsReportsSettings
Active vendors1,284
In review37
High risk6
VendorTierRiskApprovalNEW
Northwind SupplyTier 1LowApproved
Acme LogisticsTier 2MediumApprove
Helios DataTier 1HighPending
Granite FreightTier 3LowApproved
Pinecrest LabsTier 2LowApprove
You → RemyAdd an approval step for new vendors

The fifth type extends the same batching and review structure but adds a layer where the factory itself gets refined over time, using evidence from how agents actually performed (what failed, what required rework, what patterns of miscommunication kept showing up) to adjust how future batches are planned, scoped, or validated. It represents a further maturity step on top of whichever base model (fleet, PR, or release) a team is already running, rather than a wholly separate workflow.

Frequently Asked Questions

What’s the main difference between a dark factory and a fleet factory?

Both skip human review entirely before merging. A dark factory applies that to an entire application, which fails because intent gets miscommunicated. A fleet factory restricts the same zero-review approach to tasks with a clear, testable outcome, like migrations and maintenance work, where miscommunication is far less likely.

Which software factory type should a team start with?

A PR factory is the lowest-risk entry point because every pull request still gets human review, which lets a team validate that the core build loop works before expanding autonomy. From there, teams can move toward a release factory for more scale.

Why do AI coding agents fail on some open-source pull requests even when tests pass?

Passing tests confirm the code works, not that it matches the project’s intended direction or unwritten conventions. Research into agent-submitted PRs on open-source projects found a large portion of test-passing submissions still got rejected by maintainers for exactly that reason, a miscommunicated-intent problem rather than a code-quality problem.

Is a fully autonomous “dark factory” realistic for most applications?

Not currently, according to the pattern described across real implementations and experiments. The limiting factor isn’t model capability, it’s that people don’t communicate intent perfectly every time, and without any human checkpoint, those gaps ship straight to production.

What kinds of tasks are best suited to a fleet factory?

Tasks with an unambiguous goal and an automatic way to verify correctness, such as code migrations, large-scale refactors, dependency updates, and routine maintenance. These are the tasks where a passing test suite can reliably confirm the agent’s work is correct.

Editorial standards

Related Articles

How to Build a Release Factory for AI Coding Agents

A practical guide to the release-factory workflow: batching tickets, running coding agents in parallel, and reviewing in staging before deploy.

release factorycoding agent workflowAI agent pull requests

Herder 0.9.5: What's New for Running Coding Agents Across Machines

Herder 0.9.5 adds multi-machine SSH support, faster reconnects, reboot-proof persistence, and agent self-reporting. Here's what changed.

Herderterminal multiplexercoding agents

Inside an AI Software Factory Dashboard for Autonomous Coding Agents

How builders track autonomous coding agents with a mission-control dashboard covering workflows, decisions, failures, and version rollbacks.

AI software factoryautonomous coding agentsArchon workflow

Panda Orchestrator: A 32M-Parameter Model That Routes Your AI Coding Tasks

A tiny local router model picks the cheapest capable AI model for each coding task, cutting cost while nearly matching perfect routing in tests.

Panda OrchestratorPanda RouterAI model routing

GPT-6 Astra vs Fable 5.1: A Week of Head-to-Head Testing

A week of hands-on coding and reasoning tests pits GPT-6 Astra against Fable 5.1. Here's what actually separates the two models.

GPT-6 AstraGPT-6 Astra reviewFable 5.1 comparison

Turnstone: Orchestrating AI Coding Agents Across Local Hardware

Turnstone lets you distribute AI coding agent tasks across DGX Station, GB10 clusters, and RTX Pro 6000 rigs. Here's how it actually works.

Turnstone AIDGX Stationlocal AI agent orchestration

Presented by MindStudio

No spam. Unsubscribe anytime.