--- title: "Software Factories, by the Numbers" canonical: "https://www.guild.ai/blog/developer-insights/software-factories-by-the-numbers" --- # Software Factories, by the Numbers - **Category:** Developer Insights - **Author:** Cory Waddingham - **Published:** Sep 11, 2026 - **Reading time:** 5 min _The category is filling up with autonomous-coding claims. Here is what to measure, and what each player actually puts in public._ A year ago, "software factory" was a metaphor. Now it is a product category, and a crowded one. Devin, Factory.ai, and a growing list of newer entrants all promise the same outcome: hand the system an issue, get back a finished pull request, with less and less human touch in between. For a security leader evaluating any of them, that pitch is easy to find and hard to trust. Every vendor claims autonomy. Every vendor claims production-readiness. Almost none of them show you the number behind the claim. This post is about those numbers: what a software factory actually is, what is worth measuring, and what each of the main players puts on the record. Guild builds one of these, so read the Guild section with that in mind. Everything else here is public figures, cited as reported. ## What a software factory actually is Strip away the branding and a software factory is a pipeline. It takes a unit of work, a bug, a flaky test, a small feature, and moves it through the stages a human team would use: understand the issue, plan a change, write the code, review it, and land it in main. The ambition is that agents run the line and a person enters mainly to own the outcome. A single coding agent that writes a patch is one station on the line, not the line itself. And an agent platform that governs and observes agents, but never writes application code, sits adjacent to the category rather than inside it. Both are components to a larger factory but shouldn't be confused for one on their own. ## Why the category is commoditizing There's a risk in treating the factory as the whole product: the factory itself is the part that's commoditizing. Issue-to-PR automation is now something several vendors can demo, and the distance between those demos is shrinking every quarter. What does not commoditize is everything underneath the demo. Whether the pipeline is governed. Whether it is welded to a single model vendor. Whether you can audit what an agent did and what it spent. Whether it runs against your real codebase or a sanitized copy kept apart from it. The pipeline is the easy part to copy. The substrate that makes it safe to deploy is the hard part, and it is where the durable difference lives. So the interesting question is no longer "can it write a PR." Most of them can. The question is whether it can do that in a way a regulated enterprise can actually put into production, and whether the vendor will show you proof instead of a highlight reel. ## What is worth measuring If you are comparing factories, a demo is close to the least useful thing you can watch. Ask instead for the operating numbers, the ones that only exist once a system has run against a real repository for a while. The set worth requesting is short: - **Autonomous share:** of the pull requests that actually merged, how many did the system write without a human writing code. - **Merge and acceptance rate:** of what it opened, how much got into main. - **Human-commit rate:** how often a person had to commit on top of the agent's work to land it. - **Cost per unit of work:** model spend per merged PR, rather than a monthly seat price that hides usage. - **Time to fix:** how long from a problem appearing to a fix being ready to merge. - **Independently verified success:** a third-party reviewer checking the output, rather than the vendor grading its own. Two of those carry more weight than the rest, because they separate a governed factory from an impressive one. A system that reviews its own work and merges its own PRs has removed the only independent check in the process. And a system that quotes a monthly price instead of a cost per merged PR is quietly hiding the number that scales with how much you use it. ## What the field publishes Here is what each of the main players actually puts in public, cited as reported. **Guild Software Factory** is the one we build, used every day with our own codebase. Over a recent quarter of Guild building Guild we recorded: - 34% of merged PRs written autonomously - 56% of code fixes authored by the factory - A 75% acceptance-and-merge rate - 91% of merged factory PRs needing no human commit at all - Time to fix down about 97%, from roughly a month to about a day - Around $12 of model spend per merged PR **Devin (Cognition)** is the most mature of the coding agents and carries the deepest enterprise footprint. What it reports publicly: - Roughly a 67% merge rate in customer accounts - Around 4x faster delivery on bounded tasks - About 44% on SWE-bench - Independent reviewer-tested success from the high 70s to the mid 80s by task type - Pricing from near $500 a month plus usage It is a single agent that writes and reviews its own work, which is the tradeoff to weigh against the speed. **Factory.ai** owns much of the category narrative, including the "Software Factory 2.0" framing, and it supports multiple models with air-gapped deployment. On verifiable operating numbers it publishes very little. Strong logos, thin scoreboard. **Claude Managed Agents** is composable infrastructure for building and hosting agents on Anthropic's stack, with governance built in: - A reported lift of about 10 points on structured file generation - The strongest models paired with real distribution - Delivered as infrastructure you assemble into a factory rather than a turnkey one, and single-vendor by design Then the two that get miscompared into this list, **Databricks Agent Bricks** and **Glean**. Both are governed agent platforms with genuinely strong observability, and both will come up in these conversations. Neither is a software factory for application code: - Databricks' Genie Code is autonomous, but scoped to data engineering - Glean has no coding capability at all - Their published figures describe platform and business outcomes, a data-task benchmark for Databricks and a 141% three-year ROI for Glean, rather than factory output They overlap a control plane, not a factory, and treating them as head-to-head coding factories flatters everyone and informs no one. ## What the numbers add up to Line the six metrics up across the field and a pattern appears. Guild publishes five of them, and the one it doesn't claim, independent third-party verification, it names rather than hides. Devin publishes three. The rest publish two, one, or none, and much of what is public is self-reported rather than independently checked. Speed and price differences on any single row matter less than a blunter fact: most of the category asks you to take autonomy and production-readiness on faith. A number you cannot verify is a number you cannot govern, and no security leader can sign off on faith. The combination that survives that scrutiny is narrow. A factory that is governed and auditable by design. Neutral about which model and framework it runs. Honest enough to keep building separate from reviewing, and to never merge its own work. And willing to publish what it does in production, caveats included. That is the bar we built Guild to clear, and it is why we would rather hand you the numbers than the demo. _See the factory run at [app.guild.ai/factory](https://app.guild.ai/factory)._ _Methodology: competitor figures are public, vendor- or customer-reported unless noted, and cited as such. Guild figures are dogfooded on Guild's own codebase and audited internally. Public figures only. Updated September 2026._ ## See the factory run 34% of Guild's merged PRs are written autonomously, at roughly $12 per merged PR. Start your own factory in minutes. [Start your factory](https://app.guild.ai/factory)