IRIron Reinsinteractive autonomy atlasDeep research ↗
STEP 5 · DEEP RESEARCH

Open the evidence wall.
Keep the boundaries sharp.

This is the expert surface: the complete factory field guide, entity-class normalization, ownership boundaries, topology, authority planes, continuous change and the mechanism labs behind the beginner comparison.

HOW TO READ THE BENCH

Three ownership models.
One unforgiving question.

“Enterprise” does not mean “autonomous,” and “open source” does not mean “ready to operate.” Compare what the system owns, what it hands off, and who carries the failure when reality disagrees.

01PRIVATE PROGRAMSInternal factories18 candidates

Often the strongest evidence of real usage and domain fit. Their orchestration, safeguards, costs and failure rates are usually private.

Best question: what is actually running?
02ASSEMBLABLE PARTSOSS + references52 candidates

Inspectable mechanisms, runtimes and templates. You inherit integration, security hardening, identity, upgrades and the proof layer.

Best question: what must we own?
03PRODUCT SURFACESCommercial systems25 candidates

Usually the quickest path to a polished workflow. The hard edges are contracts, opaque internals, edition boundaries and vendor recovery.

Best question: what do we still control?
Read every row in this order:mission→artifact→Day 2→human residue→evidence
READ THIS BEFORE THE BENCH

Choose the family.
Then read the cliff.

The comparison is intentionally unforgiving. A factory may be excellent at producing a PR and still have no authority over deployment, data, identity, incident response or recovery. The matrix below explains the families; the workbench then lets you swap three candidates inside one family.

95factory candidates
0Day‑2 evidenced
47Day‑2 bounded
45stop before Day‑2
Start with the family strip below.Pick the kind of work first. Then compare only candidates doing that work; ownership, models, languages and topology stay secondary.
Day‑2, in this Atlas:detect a real signal→localize→diagnose causally→repair safely→verify independently→prevent recurrenceSee the full definition ↗
AXIS 1 · WHAT KIND OF THING IS IT?

Seven factory-shaped objects. Do not buy them as substitutes.

Class is scope—not ownership. Availability says whether you can adopt it. Maturity says how far this exact surface has progressed. Neither changes where its work stops.

19Operating factory

A persistent system accepts bounded demand and repeatedly hands off a reviewable artifact through an evidenced production workflow.

27Specialist factory

A repeatable factory owns one bounded transformation family such as fleet migration, modernization, or incident-to-fix work.

22Factory platform

A control plane supplies durable orchestration, workers, policy, or isolation so an organization can assemble multiple factories.

14Workflow kit

An inspectable framework or workflow library defines repeatable agent steps but leaves fleet operation, enterprise containment, or release ownership outside.

8Reference implementation / specification

Public code or specifications teach one factory pattern but are not the evidenced production system they describe.

2Assembled ecosystem

Several separately owned tools form the candidate path; no single product owns the complete state machine or outcome.

3Research prototype

A paper, experiment, or time-bounded demonstration establishes a mechanism without a durable generally available operating surface.

AXIS 2 · WHO OWNS AND OPERATES IT?

The label tells you what you inherit.

Ownership and scope are independent. An operating factory can be internal or managed; a platform or workflow kit can be open or commercial.

◈Enterprise internalObserved—not adoptable

Strongest company-specific proof; you cannot adopt the factory.

Primary ↗
{ }OSS / openFork and operate

You can inspect and fork it; you inherit operations and hardening.

Primary ↗
$Managed productBuy access

You buy the fleet and support; the control plane remains opaque.

Primary ↗
⌁Open referenceCopy an architecture

You inherit a design pattern—not maturity, security or support.

Primary ↗
▦Composable substrateScope—not ownership

You get machinery, not a complete factory or outcome authority.

Primary ↗
START HERE · THE AT-A-GLANCE FACTORY BENCH

Hold the work family still. Watch the systems diverge.

“Software factory” is not one product category. Choose the nearest work family first; then read each system’s green edge and red cliff. Systems inside a family can still accept different inputs and stop at different artifacts—that stopping point is the comparison.

internalStripe · Operating factory · internal only · production evidenced

Stripe Minions

Issue-to-PR maintainer

Primary evidence ↗
needsame job
⚒CodeCan it produce reviewable software changes?● leading→
✓ProveCan a separate check reject it?● strong→
⌁OperateCan it close the loop in the live application?× absent→
⚖GovernCan identity, policy, audit and recovery contain it?● strong
×APP DAY 2no
WHERE THIS FACTORY ACTUALLY STOPSHuman-review-ready PR with CI evidence→NEXT ACCOUNTABLE OWNERStripe code reviewer / owning engineer
✓ GREEN EDGE · CHOOSE IT FORHigh-volume, well-scoped maintenance in a deeply instrumented monorepo with curated internal tools.
× RED CLIFF · NEVER DELEGATEPortable adoption, broad language conclusions, release ownership, and application operations.
♙ HUMAN RESIDUEHumans open/take over work, review every PR, and retain merge and release authority.
One row · one executive fingerprint✓ best use× fatal boundary↻ Day‑2 boundary♙ human residueEvidence is deliberately last. Documentation strength must not masquerade as suitability.
Factory / class / actual job✓ Best use× Fatal boundary↻ Application Day‑2 boundary♙ Human residueEvidencePrimary
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗

The visual rule: no amount of green in Code cancels a red cliff in Proof, live operations, governance, or recovery. Compare systems inside one job family before comparing ownership models.

AFTER THE FACTORY BENCH · EXPAND THE ECOSYSTEM

Factories first. Components second.

A reviewer, GitOps controller or SRE agent may be vital to a factory without being a software factory itself. Portfolio / build-buy-retire: Can it decide what to build, buy, retain or retire—and prove the real-world result? Demand / decide what matters: Can it turn noisy signals into one defensible priority—and stop work that fails?

THE 20-SECOND ANSWER · 95 NONINTERCHANGEABLE SYSTEMS

Enterprise and OSS factories, with their edges exposed.

Read great at, terrible at, then human. A factory earns only the narrow green job shown here. Its red edge and remaining operator outrank every average score or feature-list claim. The adjacent demand organ is separate: Similarity and record state do not prove dedupe, priority or outcome; Humans detect duplicates; votes are popularity, not priority. ServiceNow SPM Demand Management, Productboard + Pulse / Spark, OpenProject and Fider are decision-surface examples, not complete factories.

ACTUAL JOB FAMILIES6Compare within one firstFACTORIES IN VIEW95Internal · OSS · managedNO APP DAY‑245Stops before live operationBOUNDED / PLANNED DAY‑250Narrow loop or stated intentDOCUMENTED APP DAY‑20Still inspect its exact boundary
1Hold the job constantChoose one work family.→2Read green, then redThe cliff outranks the score.→3Inspect the residueWho still proves, merges, deploys and recovers?

opencommercialinternalSide rail: application Day‑2

Factory passportWhat it actually is✓ Great at× Terrible at / hard edge♙ Human still requiredApp Day‑2Evidence fingerprintPrimary
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
internalOperating factory · internal only · production evidenced

Stripe Minions

Issue-to-PR maintainer

BUY / BUILD IT FORHigh-volume, well-scoped maintenance in a deeply instrumented monorepo with curated internal tools.
NEVER INFER OR DELEGATEPortable adoption, broad language conclusions, release ownership, and application operations.
THE HUMAN WHO REMAINSHumans open/take over work, review every PR, and retain merge and release authority.
FACTORY STOP → NEXT OWNERHuman-review-ready PR with CI evidence→ Stripe code reviewer / owning engineer
WHY THE ROWS DIVERGE

The bench gives the verdict. Now open the machines.

Only after comparing the complete field do we descend into vendor product families. This prevents a public SDK, hosted worker, workflow dashboard or reviewer from lending capabilities to the rest of its logo.

THE MOST IMPORTANT COMPARISON CORRECTION

One company. Two different machines.

Vendor families often bundle an executor, orchestrator, enterprise control plane and open adapters. Each assessed row now names the exact surface. Read across to see what you get, what it is good at, and the hard edge where a different owner takes over.

Runtime ≠ factory

Factory.ai

⚙
GA commercial platform

Droid runtime

YOU GET
Resumable CLI / SDK / JSON‑RPC coding sessions
✓ GREAT AT
Embedding an agent in your own workflow
× HARD STOP
Caller must supply durable orchestration, acceptance and release
ACCESS / PRICE
$20–$200 individual plans; enterprise quote
Primary source ↗
▦
Private-preview lifecycle control plane

Software Factory

YOU GET
Coverage/health dashboard + configured automations that dispatch Droid
✓ GREAT AT
Managing lifecycle automations around Droid
× HARD STOP
Dashboard is not the executor; downstream owners still accept artifacts and effects
ACCESS / PRICE
Private preview; no public price
Primary source ↗
Engine ≠ fleet

OpenRewrite / Moderne

⚙
Apache‑2.0 specialist engine

OpenRewrite OSS

YOU GET
One-repository semantic recipe diff + data tables
✓ GREAT AT
Deterministic JVM/config transformations
× HARD STOP
No enterprise campaign plane, cutover or live operations
ACCESS / PRICE
Free OSS; recipe licenses vary
Primary source ↗
▦
GA commercial specialist factory

Moderne Platform + CLI

YOU GET
Serialized-LST search and governed multi-repo campaigns
✓ GREAT AT
Fleet-scale modernization and security work
× HARD STOP
No runtime-equivalence oracle, release or application operations
ACCESS / PRICE
Contract / license required; no public list price
Primary source ↗
Non-inheritance rulePublic SDK ≠ open runtimeparser source ≠ supported recipe surfaceGA executor ≠ GA factorycommercial fleet ≠ application operations
PRODUCT-FAMILY ANATOMY · CAPABILITIES DO NOT FLOW SIDEWAYS

A logo is not a system. Open the machine.

Select a family, then follow each independently assessed component. Interface, executor, computer, orchestrator, control room, verifier and production authority can come from the same vendor—or seven different owners. The exact artifact crossing each seam is the point.

prompt / event / PR→

Public adapters feed a proprietary executor; preview control surfaces manage automations; repository and production authority remain outside.

→reviewer, release system or service owner

Swipe the component chain → select any organ for its artifact, owner and hard edge.

→
→
→
→
→
→
→
↯
interface / adapter · public source · mixed licenses

SDKs · Action · plugins

Factory.ai

Primary source ↗
TERMINAL ARTIFACT / STATEtyped call, event stream or CI/plugin request
NEXT ACCOUNTABLE OWNERDroid runtime or calling application
× CAPABILITY CLIFFPublic wrappers do not expose or open the Droid executor.
LICENSE / EDITION BOUNDARYPython SDK Apache‑2.0; public source elsewhere must be licensed component by component.
Family non-inheritanceadapter ≠ executorexecutor ≠ orchestratorcomputer ≠ durable workflowdashboard ≠ verifierverifier ≠ release authorityrelease ≠ recovered application
THE FIRST DIFFERENCE · WHAT CAN YOU ACTUALLY ADOPT?

Five things called a factory. Five different bargains.

Read one row across. Internal systems have the strongest company-specific proof but cannot be bought. OSS exposes mechanics but transfers operations to you. Managed products sell the control plane but hide it. References teach. Substrates supply parts.

Same question →
◈Enterprise internalObserved—not adoptablePrimary ↗
{ }OSS / openFork and operatePrimary ↗
$Managed productBuy accessPrimary ↗
⌁Open referenceCopy an architecturePrimary ↗
▦Composable substrateScope—not ownershipPrimary ↗
✓ Best at

Deep company context, curated tools and the strongest real throughput evidence.

Inspectable mechanics, model choice and composable building blocks.

Hosted fleet, integrations, administration and vendor support.

Forkable architecture and a concrete starting grammar.

Reusable worker, workflow, sandbox or coordination machinery; a substrate may itself be OSS or managed.

× Terrible at

Portable adoption, independent reproduction and transfer of its private context.

Turnkey enterprise safety, support, recovery or proof merely because source is visible.

Reproducible scheduler semantics, easy exit or independent replay of vendor claims.

Production maturity, security and operational outcomes from a template alone.

A complete outcome, acceptance oracle, release plane or technology department.

⚠ Hard edge

Do not infer that an adjacent public SDK, agent or blog diagram is the internal factory.

Source availability is not a hostile-code sandbox, protected verifier or durable production control plane.

A contractual control is not source-visible behavior; edition, region and plan boundaries can change the actual system.

A reference implementation is evidence of a design—not a qualified multi-tenant service or support contract.

More agents and better scheduling can produce slop faster unless an independent authority can reject and recover effects.

↻ Application Day‑2

Mostly repository work. Ramp and Dropbox expose bounded telemetry-to-fix loops, still without production authority.

Usually keeps workers running—not the deployed application. Operations agents remain separate organs.

The vendor operates factory workers. Most products still stop before deployed-application operation and recovery.

No inherited application Day‑2. The adopter must build scheduling, policy, telemetry, release and recovery.

Worker/session recovery may be strong; application Day‑2 is generally outside the substrate.

♙ Human residue

Company engineers own intent, monitors, review, merge, release and incidents.

Platform, security and service owners supply policy, credentials, qualification and recovery.

Customers retain intent, review, release, risk acceptance and vendor governance.

Adopters become the platform team and own every unstated production contract.

Architects choose the organs; operators own semantic completion, external effects and recovery.

You inherit

You cannot inherit the factory; its scheduler, data, policy and integrations remain private.

Hosting, isolation, identity, secrets, upgrades, integrations, support and control-plane recovery.

Vendor availability, metered costs, data-residency choices, opaque upgrades and lock-in.

Hardening, durability, tenancy, authorization, support and the full operating model.

Composition, cross-component identity, handoffs, observability, effect closure and failure ownership.

◈
Enterprise internalObserved—not adoptable
Primary ↗
✓ Best at

Deep company context, curated tools and the strongest real throughput evidence.

× Terrible at

Portable adoption, independent reproduction and transfer of its private context.

⚠ Hard edge

Do not infer that an adjacent public SDK, agent or blog diagram is the internal factory.

↻ Application Day‑2

Mostly repository work. Ramp and Dropbox expose bounded telemetry-to-fix loops, still without production authority.

♙ Human residue

Company engineers own intent, monitors, review, merge, release and incidents.

You inherit

You cannot inherit the factory; its scheduler, data, policy and integrations remain private.

{ }
OSS / openFork and operate
Primary ↗
✓ Best at

Inspectable mechanics, model choice and composable building blocks.

× Terrible at

Turnkey enterprise safety, support, recovery or proof merely because source is visible.

⚠ Hard edge

Source availability is not a hostile-code sandbox, protected verifier or durable production control plane.

↻ Application Day‑2

Usually keeps workers running—not the deployed application. Operations agents remain separate organs.

♙ Human residue

Platform, security and service owners supply policy, credentials, qualification and recovery.

You inherit

Hosting, isolation, identity, secrets, upgrades, integrations, support and control-plane recovery.

$
Managed productBuy access
Primary ↗
✓ Best at

Hosted fleet, integrations, administration and vendor support.

× Terrible at

Reproducible scheduler semantics, easy exit or independent replay of vendor claims.

⚠ Hard edge

A contractual control is not source-visible behavior; edition, region and plan boundaries can change the actual system.

↻ Application Day‑2

The vendor operates factory workers. Most products still stop before deployed-application operation and recovery.

♙ Human residue

Customers retain intent, review, release, risk acceptance and vendor governance.

You inherit

Vendor availability, metered costs, data-residency choices, opaque upgrades and lock-in.

⌁
Open referenceCopy an architecture
Primary ↗
✓ Best at

Forkable architecture and a concrete starting grammar.

× Terrible at

Production maturity, security and operational outcomes from a template alone.

⚠ Hard edge

A reference implementation is evidence of a design—not a qualified multi-tenant service or support contract.

↻ Application Day‑2

No inherited application Day‑2. The adopter must build scheduling, policy, telemetry, release and recovery.

♙ Human residue

Adopters become the platform team and own every unstated production contract.

You inherit

Hardening, durability, tenancy, authorization, support and the full operating model.

▦
Composable substrateScope—not ownership
Primary ↗
✓ Best at

Reusable worker, workflow, sandbox or coordination machinery; a substrate may itself be OSS or managed.

× Terrible at

A complete outcome, acceptance oracle, release plane or technology department.

⚠ Hard edge

More agents and better scheduling can produce slop faster unless an independent authority can reject and recover effects.

↻ Application Day‑2

Worker/session recovery may be strong; application Day‑2 is generally outside the substrate.

♙ Human residue

Architects choose the organs; operators own semantic completion, external effects and recovery.

You inherit

Composition, cross-component identity, handoffs, observability, effect closure and failure ownership.

The non-transfer rulePrivate adoption ≠ portable productsource visible ≠ production safemanaged ≠ independently proventemplate ≠ servicesubstrate ≠ factory
FOUR GREEN LIGHTS THAT MEAN FOUR DIFFERENT THINGS

What exactly is allowed to say “go”?

Scan left to right. Every row has a real green zone. The last column is the cliff: none may inherit application, data or user truth merely because its own object is green.

● explicit◐ bounded× not ownedMarks describe the exact plane—not the vendor’s total feature list.
Control plane / accepted objectPins workPolicy gateCrash recoveryNative receiptApp / data truthHard stopPrimary
↗
↗
↗
↗
◎
AGENT RUN

BoundFlow

A checkpointed workflow operation under declared runtime/lifecycle policy.

✓ GREEN EDGEOpen durable execution and runtime governance for unattended Python agent workflows: leases, checkpoints, cost/tool/token/latency limits, approvals, model switching and auditable lifecycle actions.
× FATAL EDGENo target-system transaction or independent application outcome.
♙ HUMAN RESIDUEAuthors policy and target idempotency; verifies the external effect.
DAY‑2Agent lifecycle onlyEDITION / PRICEApache-2.0 backend + MIT SDK · Cloud early access · v0.5.0 preview

Composition rule: join these planes with artifact, target, principal, policy revision and source-native effect receipts. Never propagate a boolean “success” downstream.

THE AT-A-GLANCE MACHINE FINGERPRINT

Every factory has a different stopping point.

Scan every enterprise, OSS, reference and substrate system in one wall. A role can be one more prompt, another model session, a process, a container or a VM. That says nothing about who owns work, what survives a crash, or who may say done. Unknown stays visible.

● yes◐ bounded× absent? undisclosed

Factory / actual execution unitSTATEDurable stateCLAIMClaim / lease / fencingCODEWorkspace and execution isolationHANDValidated handoff contractWORKERWorker crash recoveryCTRLController crash recoveryDONEIndependent completion authority
⌘
open · Developer preview

Owain Lewis Factory

durable controller → leased worker attempts

① WHAT ACTUALLY RUNS?

Go workers launch Pi, Codex or Claude locally or on remote VMs, each in a managed git worktree.

Mixed: Multiple worker forms. Each path needs its own qualification result.
② WHAT SURVIVES?

Runs, work items, attempts, heartbeats and publish state persist in SQLite.

Scheduler: Go control plane with SQLite state
③ WHAT CAN STILL LIE?

It solves fleet mechanics unusually well but does not prove that the resulting code is correct, safe to release or operationally healthy.

Completion: Repository checks and humans remain the semantic oracle; the attached agent reports success.
●yesDurable state

Runs, work items, attempts, heartbeats and publish state persist in SQLite.

●yesClaim / lease / fencing

Leases, heartbeats, retries and reclaim are explicit source-visible mechanics.

◐partialWorkspace and execution isolation

Worktrees and optional VMs isolate revisions; local host-user execution is not a hostile-code sandbox.

◐partialValidated handoff contract

Attempts, branch/ref/head-SHA and publish records are structured; semantic agent output is still self-reported.

●yesWorker crash recovery

Heartbeats, lease expiry, retries and cancellation support recovery.

●yesController crash recovery

Durable SQLite state lets the controller reconstruct work, subject to crash-window qualification.

×noIndependent completion authority

Repository checks and humans remain the semantic oracle; the attached agent reports success.

PUBLIC REPOSITORY ≠ PUBLIC FACTORY

What can you actually take home?

The recent enterprise factories expose radically different public slices. Select one company: green is reusable or learnable, black remains inside the company, and red is the failure boundary that prevents capability inheritance.

✓ PUBLIC SURFACE

AI Playbook + separate MIT payment MCP

Factory doctrine, skill contracts and readiness gates are inspectable. The Go MCP connector is reusable code—but defaults write-capable and lacks a server-side approval/compensation contract.

Primary: Playbook commit 2ccaa865 ↗
▦ PRIVATE FACTORY

Razorpay Slash

Slash scheduler, worker isolation, Compass plugins, model policy, knowledge graph, merge gate and recovery controller.

Primary: Slash architecture ↗
× PRODUCTION CLIFF

A Slash-authored DepGuard workflow self-merged, then failed at network, runner, hostname and branch-policy boundaries before a complete bot-authored rollback.

Inspect the hard edge ↗

The comparison rule: score the public component and the private factory separately. A shell does not inherit Temporal, a doctrine repository does not inherit a scheduler, an OSS sibling does not inherit Flux, and an architecture article does not become runnable code.

INTERNAL vs OSS vs MANAGED · SAME ROWS, NO MARKETING CATEGORIES

Compare fingerprints—not feature lists.

The defaults expose three different ownership models. Change any selector; every column keeps the actual job, green zone, hard stop, Day‑2 boundary and human residue aligned.

Choose factoriesDefault: internal · OSS · managed
Public-evidence fingerprint0–5; ? means unknown
Build5Proof4Day 21Ent.4Open0Evidence4
Build4Proof5Day 20Ent.1Open5Evidence2
Build4Proof4Day 22Ent.4Open3Evidence3
Primary jobThe main work pattern—not every feature it advertises.
Issue → PROne-shot issue → reviewed PR
Factory substrateRole-separated TDD/architecture swarm
Factory substrateFactory-as-code control plane
Entity classWhat kind of system this exact assessed surface is; ownership is separate.
Operating factoryStripe · internal
Workflow kitUncle Bob / community · open
Factory platformWarp · commercial
Availability / maturityWhether this exact surface can be obtained and how far it has progressed are independent facts.
internal onlyproduction evidenced · Mature internal
open implementationpreview · Open local swarm
commercial productpreview · Early access
Excellent zoneThe narrow reason to choose it.

High-volume, well-scoped maintenance in a deeply instrumented monorepo with curated internal tools.

A source-visible role-separated specification/TDD/QA option for teams that want explicit handoffs—especially Go, Clojure, and Java; no evidence it beats a single agent.

Multi-harness, multi-model cloud workers with event/schedule intake, human steering, and versioned skills.

Hard stopThe inference or duty it cannot safely inherit.

Portable adoption, broad language conclusions, release ownership, and application operations.

Unattended cloud scheduling, enterprise authorization, broad language equality, and production operations.

Being called fully open or production-proven five days after launch; transparent audit of the managed scheduler/control room.

Application Day 2Operating the deployed application, not keeping factory workers alive.
noRepository maintenance and CI repair, not deployed-service incident ownership.
noLocal software construction, not application operations.
plannedMonitoring-to-issue is in the design; broad production remediation is not demonstrated.
Human residueThe person who still supplies judgment, authority, or recovery.

Humans open/take over work, review every PR, and retain merge and release authority.

Human observes/intervenes in tmux and owns acceptance.

Versioned checkpoints, session steering/handoff, human spec review and merge in the reference flow.

Anti-slop mechanismHow the system tries to prevent plausible but weak output.

Conditional repository rules, targeted lint, selective CI, curated MCP tools, and at most two repair rounds.

Gherkin, red/green/refactor, mutation testing, CRAP/DRY, architecture review, property tests, final QA.

Specs, repository checks, browser/computer-use evidence, structured review, trusted workflow revisions, and review-skill PRs.

Open / paid boundaryThe source-visible part and the part you must trust or buy.

Proprietary internal factory. stripe/ai is adjacent, not Minions source.

Open local orchestration and tool ecosystem.

Open workers, SDKs, environments, skills, and examples; proprietary hosted orchestration and enterprise gates.

Language realityObserved or documented coverage, not runtime-image inference.

Strongest evidence: Ruby/Sorbet backend. Broader support is undisclosed.

Canonical mutation/CRAP/DRY packs: Go, Clojure, Java. Other languages are editable but lack equivalent factory packs.

Stock images: Node/TS, Python, Go, Rust, Java, .NET, Ruby, browsers; runtime presence is not competence proof.

Model realityPublished use or controlled comparison—not a generic list of APIs it can call.

Undisclosed; no public controlled model matrix.

Roles can use Codex, Claude, Copilot, and Grok; no controlled best backend.

Warp Agent, Claude Code, Codex, Gemini CLI, Copilot/OpenCode paths; BYO inference at enterprise tier.

Outcome evidenceWhat has actually been published, including the denominator that is still missing.

Stripe reports 1,000+ wholly Minion-authored, human-reviewed merged PRs per week; no reproducible factory artifact.

Runnable source and explicit language-specific quality tooling; Sep. 2026 author statements favor one-agent use personally, but neither those statements nor the repository provide a controlled comparison, accepted-production denominator, or benchmark.

Public reference factory and worker/source graph are substantial; independent quality and long-horizon evidence remain open.

95 systems
Factory / mechanismExcellent atHard stopDay 2Build?Proof?Day 2?Ent.?Open?Evidence?
EXCELLENT AT

High-volume, well-scoped maintenance in a deeply instrumented monorepo with curated internal tools.

TERRIBLE AT / DO NOT INFER

Portable adoption, broad language conclusions, release ownership, and application operations.

HARD EDGES⚠ Private implementation⚠ Ruby/Sorbet is the strongest disclosed target⚠ No public defect or cost denominator
LANGUAGES

Strongest evidence: Ruby/Sorbet backend. Broader support is undisclosed.

MODELS

Undisclosed; no public controlled model matrix.

DAY 2 REALITY

Repository maintenance and CI repair, not deployed-service incident ownership.

WHERE HUMANS REMAIN

Humans open/take over work, review every PR, and retain merge and release authority.

HOW IT FIGHTS SLOP

Conditional repository rules, targeted lint, selective CI, curated MCP tools, and at most two repair rounds.

OSS / COMMERCIAL BOUNDARY

Proprietary internal factory. stripe/ai is adjacent, not Minions source.

PUBLIC EVIDENCE

Stripe reports 1,000+ wholly Minion-authored, human-reviewed merged PRs per week; no reproducible factory artifact.

DEEP COMPARISON LABS

Now isolate one mechanism at a time.

The wall above answers which systems differ. The labs below explain why: write authority, deployment authority, telemetry judgment, Microsoft estate control, recovery, topology and verifier independence.

THE SLOP-TO-AUTHORITY MAP

Read-only agent. Write-capable system.

Follow the artifact—not the marketing label. A model may hold no write token while a downstream broker publishes exactly what it asked for. Select any row to see where the factory earns trust and where its authority must stop.

untrusted need→reason→edit→prove→privileged broker→merge→deploy

Swipe the matrix → tap a factory → read its exact stopping point below.

Factory / control patternReasonEditVerifyPublishMergeDeployFatal edgePrimary
↗
↗
↗
↗
↗
↗
✓ GOOD AT

Exact-commit sessions plus externally selected validation are excellent for repeatable monorepo toil.

× TERRIBLE AT / CLIFF

Publication identity, scheduler recovery and security are private; the human still decides whether code reaches production.

♙ WHO TAKES OVER

Nova hands a validated branch to review, CI/release policy and the accountable service team.

The rule: job green, PR opened, reviewer passed, merge complete and production healthy are five different claims. No factory inherits the next one.

THE PRODUCTION LAST-MILE MAP

Green deployment. Unknown outcome.

Delivery is six separate jobs. Compare the controllers using identical columns, then select a row to see the exact claim it earns—and the attractive lie its green dashboard can still tell.

signed artifact→promote→converge→expose cohort→prove effect→recover

Swipe the matrix → tap a controller → inspect the exact stopping point.

Controller / actual jobArtifactPromoteConvergeExposeJudgeRecoverFatal edgePrimary
↗
↗
↗
↗
↗
↗
✓ EARNED GREEN ZONE

Continuously compares approved Git-rendered intent with Kubernetes objects and reconciles a declared application boundary.

× FALSE-COMFORT CLIFF

Synced and Healthy are controller-specific state claims, not artifact provenance, user success, data correctness or safe rollback.

♙ NEXT AUTHORITY

CI/signing owns artifact identity; a rollout controller owns exposure; independent probes and service owners judge effects and recovery.

The failure that teaches the map: Git can be correct while the cluster is stale; the cluster can be healthy while the canary is misrouted; the canary can be green while users or data are wrong; a rollback can restore code while leaving irreversible effects behind.

THE JUDGE-OF-THE-JUDGE MAP

Green metric. Red reality.

These systems are sold beside one another but do four different jobs. Read across identical columns: the yellow and red cells expose exactly where a plausible green result stops being evidence.

exact artifact+actual cohort+complete fresh evidence+user · data · security · business+independent verdict+proved recovery

Swipe the matrix → tap a system → inspect its dangerous green default.

System / actual jobBind changeProve cohortAbstainIndependentUser/data/businessRollbackProve recoveryDangerous green defaultPrimary
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
↗
✓ WHAT IT ACTUALLY PROVES

A vendor-neutral language for exchanging service-level objectives and alert conditions.

! DEFAULT THAT CAN LIE

There is no runtime default: the specification does not collect, judge, gate or recover anything.

× WHAT IT CANNOT CLOSE

A valid SLO document proves neither that observations exist nor that a release had the intended effect.

♙ REQUIRED HANDOFF

A runtime evaluator, exact release/cohort ledger, protected policy and recovery authority must implement the contract.

The universal hard edge: none of these eleven independently binds the exact change to the actual population, proves complete fresh user/data/security/business outcomes, rejects ambiguity, causes safe rollback and proves whole-system recovery.

ONE MICROSOFT ESTATE · FIVE NON-EQUIVALENT VERBS

Seeing drift is not fixing it. Fixing it is not recovery.

This is the operation-level lens the marketing categories hide. Select a row: green cells are source-backed authority, half cells are conditional, and red cells are a hard stop.

see→compare→change→keep changed→recoverEach arrow needs a different contract.
System / actual roleObserveDiffApplyReconcileRestoreFatal hard edgePrimary
↗
↗
↗
↗
↗
✓ THE GREEN ZONE

Cross-workload snapshots and property drift for documented resources.

× THE CLIFF

Its only monitor mode is monitor-only; seven-day snapshots are not restore state.

♙ THE HANDOFF

Administrator chooses another actuator and keeps external immutable evidence.

The universal rule: ticket complete, monitor green, export complete, workflow success and restore job success are all different claims. None inherits the next verb.

CONTINUOUS CHANGE / UPGRADE LAB

Seven organs. One chain nobody closes.

These are organs—not full software factories. Most are excellent before merge and absent after deployment. Choose a lane to see the earned strength, the fatal edge, and the human authority that remains.

● Strong◐ Bounded× MissingStatus means public evidence for this lane—not model potential.
⌁
SELECTED ORGAN

Application dependencies

Excellent PR factory; absent runtime operator

EXCELLENT AT

Keeping known package, image and infrastructure references current across a heterogeneous repository fleet, with explicit grouping and merge policy.

FATAL HARD EDGE

A green or merged update PR proves neither production compatibility nor recovery. Renovate is policy-rich through conditional merge; Dependabot is GitHub-bound and PR-only; Updatecli propagation depends on verification you build.

HUMAN GATE

Own required checks, review major and grouped updates, protect update-time credentials, approve promotion, and judge production rollback.

REPRESENTATIVE OSS / OPEN PIECES
RenovateDependabot CoreUpdatecliOSV-Scanner
ENTERPRISE / MANAGED PIECES
Mend Renovate EnterpriseGitHub Dependabot + Code Security
THE BALL-OF-MUD REALITY

Modernization is five organs—not one magic agent.

Step through the Liferaft chain. Each station knows something different. The red card names the exact inference it cannot support.

THIS STATION CAN DO

Map repositories, tokens, paths, history and observed cross-references at fleet speed.

THIS STATION CANNOT DO

Text matches do not establish type identity, runtime behavior, business purpose or safe removal.

THE REVIEWER TRAP

A second opinion is not automatically proof.

Pick a reviewer. The picture shows how far its public evidence travels. A release-grade verifier needs a separate identity, model/context boundary, read-only review, clean runtime and protected oracle.

✓AUTHORmakes the change→
✓REVIEWERdifferent pass→
?SEPARATIONidentity + runtime→
?VERIFIERprotected oracle
UNUSUALLY GOOD AT

Multi-agent review, rules and broad SCM support

HARD EDGE

Closed routing; vendor-run comment benchmark; no protected execution

Noise control
balanced
Fix path
suggests
Repository authority
comment
Independence
level 2/4
Open primary evidence for Qodo ↗
Iron Reins release ruleAI review supplies evidence.Protected CI decides whether the exact artifact may progress.Canary effect decides whether production is healthy.
THE GREEN CHECK IS NOT THE FINISH LINE

Five stations. Five different claims.

Choose a station. The yellow card says what it can prove; the red card shows the exact false-green it leaves behind.

THIS STATION CAN SUPPORT

A model found a plausible concern or improvement in the context it received.

DANGEROUS GREEN

The reviewer shares the author's misconception, misses hidden behavior, or returns a neutral check.

IRON REINS BOUNDARY

Evidence only; read-only identity; no merge authority.

Open representative primary source ↗
THEN LEARN THE MACHINERY

Same promise. Different mechanism.

The field guide compares named factories. These picture lessons compare the underlying design choices they assemble.

THE SIMPLE LESSON

A factory is a chain of custody, not a large prompt.

5 approaches
☁⚙
needproof?
LAB TRIALhosted + open infrastructure

Warp Factories / Oz

A cloud workshop that provisions and coordinates coding agents.

BEST WHEN

Teams wanting flexible cloud workers and an agent runtime.

THE TRAPDOOR

Cloud execution is not production authority; enterprise boundary and longitudinal proof remain incomplete.

Long-horizon4/5
Independent proof3/5
Day 22/5
Model freedom4/5
Enterprise controls3/5
①Do not compare names.

Compare authority, mechanism, postconditions and human work.

②Do not transfer evidence.

OSS, hosted, enterprise and internal editions are separate systems.

③Do not average away a fatal gap.

Great code generation cannot compensate for unsafe release authority.