--- title: "Introducing Guild Software Factory" canonical: "https://www.guild.ai/blog/product/introducing-guild-software-factory" --- # Introducing Guild Software Factory - **Category:** Product - **Author:** Guild.ai - **Published:** Sep 03, 2026 - **Reading time:** 5 min - **34% of merged PRs at Guild are written autonomously by the Factory** - **56% of all code fixes now come from the Factory** - **91% of merged Factory PRs require no engineer commits** Engineering teams spend too much time on work that matters but rarely deserves their best engineers' attention: production bugs, flaky tests, noisy logs, small fixes, and maintenance work. That's why we built Guild Software Factory: a system of specialized agents that continuously and autonomously finds, plans, implements, reviews, triages, and maintains engineering work. We built it for ourselves first. Now it has become a meaningful part of how Guild ships software. 34% of merged PRs at Guild are now written autonomously by the Factory. 56% of all code fixes come from it. And 91% of merged Factory PRs require no additional engineer commits. This isn't about replacing engineers. It's about removing the ditch digging: the constant tax of work that is small, bounded, verifiable, and expensive to keep interrupting a person to do. And the impact is starting to show up in ways that matter. ## Real work. Real results. Software Factory isn't generating demo code. It works autonomously against our production codebase every day. Today: - 56% of all code fixes now come from the Factory. - 70% of fixes for auto-detected issues come from the Factory. - 81% of log-triage fixes are written by the Factory. - 80% of code changes to the Guild CLI are written by the Factory. - 75% of Factory pull requests are accepted and merged. - 91% of merged Factory PRs require no engineer commits. - 25% of alerts have a fix PR up within 90 minutes of firing. - A merged Factory PR costs roughly $12 in model spend to create. - For some workflows, time-to-fix has fallen by 97%, from roughly a month to a day. ![](https://images.prismic.io/guild-ai/XDfiVLio6s_iLenx_factory-compare-5-.png?auto=format,compress) The important part isn't any one metric. It's what they add up to. The Factory is no longer just helping engineers write code faster. It is autonomously taking entire categories of work off the team. ## The Factory is particularly good at the work that piles up Much engineering drag comes from problems that are individually small but collectively expensive. Software Factory is particularly effective at: - Fixing production bugs: addressing well-scoped issues surfaced through logs and alerts. - Maintaining code health: finding duplicated code, dead code, inconsistent implementations, and edge cases. - Improving log hygiene: reducing noisy, redundant, or oversized logging. - Shipping small features and fixes: working through important backlog items that rarely become urgent enough to justify interrupting an engineer. - Resolving test failures: separating flakes, regressions, and infrastructure issues and creating the right follow-up work. - Routine maintenance: keeping branches current and resolving straightforward conflicts. ![](https://images.prismic.io/guild-ai/EJE2VPrVj-fuWDAK_factory-compare-8-.png?auto=format,compress) Production log triage is a good example. Our log-triage agent continuously looks for problems in production and creates issues when it finds them. Software Factory can automatically pick up those issues and take them through implementation and review. Today, 81% of log-triage fixes are written by the Factory, and 70% of fixes for auto-detected issues overall come from Factory agents. Instead of an engineer spotting an alert, opening an issue, finding context, writing a fix, running tests, and opening a PR, much of that chain can now happen autonomously. In 25% of cases, a fix PR is already up within 90 minutes of the alert firing. That's the kind of change that starts to alter how an engineering organization operates. ## Software Factory isn't one giant coding agent This works because Software Factory isn't a single autonomous coding agent with an enormous prompt. It's a pipeline of specialized agents, each responsible for a narrow part of the software development lifecycle. ![](https://images.prismic.io/guild-ai/RM87zHQnhZ5mNgg-_factory-compare-6-.png?auto=format,compress) A GitHub or Jira event can start the process. From there, work moves autonomously through planning, implementation, automated review, and ultimately to a human for final approval. ### Dispatcher Routes GitHub and Jira events into the appropriate workflow. Add guild-auto to a well-scoped issue, and the full Factory process can begin automatically. ### Planner Reads the issue, explores the relevant code and context, and creates an implementation plan. The better the problem is scoped, the more reliably the Factory can execute it. ### Implementer Writes the code inside a sandboxed environment, runs the repository's existing linters, type checks, and tests, then opens a draft pull request. ### Reviewer A separate agent reviews the implementation before a person spends time on it. Once it is satisfied, it removes the draft status and marks the PR factory-approved. That separation matters. The agent writing the code isn't also responsible for deciding whether its own work is correct. ### Guild Auto Add guild-auto to an issue, and Software Factory can take it through planning, implementation, and review autonomously. Other agents can also create issues and trigger the Factory, so the system can respond to work discovered elsewhere: production logs, tests, code-health analysis, or other automated systems. That's how you move from a coding agent to an engineering system. ## Maintenance agents matter as much as coding agents Getting an AI agent to write code is becoming easier. Keeping an autonomous engineering system operating reliably over weeks and months is harder. That is why some of the most important agents in Software Factory don't write product code at all. They maintain the Factory itself. ### Conflict Resolver Keeps Factory branches synchronized with main and resolves routine conflicts so work doesn't stall unnecessarily. ### Janitor Finds stale or stuck jobs, retries them when appropriate, and escalates after a defined number of attempts. ### Code Health Continuously looks for duplicate helpers, dead code, inconsistent implementations, and other maintainability problems. Well-scoped issues can be routed directly back into the Factory. ### Test Triage Investigates CI failures to determine whether they represent a flake, regression, or infrastructure problem, then creates appropriately scoped follow-up work. These agents are part of why the system can keep running autonomously without an engineer constantly babysitting it. We can see that in the results: 75% of Factory pull requests are accepted and merged, and 91% of merged Factory PRs require no additional engineer commits. ## Humans still own the outcome Software Factory does not merge its own pull requests. That's deliberate. Agents can autonomously plan the work, write the code, test it, review it, and get it ready to ship. But a human still makes the final decision. As agents take more actions inside production systems, accountability becomes more important, not less. Our rule is simple: Agents do the work. People own the outcome. That model has allowed us to automate much more aggressively without giving up control. ## The economics are starting to get interesting Another part of the Factory matters: cost. Our model spend to operate the Factory works out to roughly $12 per merged PR. ![](https://images.prismic.io/guild-ai/1gjbdX-0pW47Lg5J_factory-compare-7-.png?auto=format,compress) We don't think that number is fixed. One benefit of running the Factory on Guild is that we can see exactly how its agents use models, prompts, tools, and context, and continuously optimize them. As models improve, and as the Factory gets better at routing work to the right model and moving deterministic steps into code, we expect the cost per unit of engineering work to keep falling. That creates a very different economic model for the long tail of engineering work. A bug that might previously have sat in a backlog for weeks can now be autonomously investigated, fixed, tested, and brought to an engineer for review for a nominal amount of model spend. In some workflows, we've already seen time-to-fix fall by 97%, from roughly a month to a day. That doesn't mean every engineering problem should be handed to an agent. It means the threshold for what is worth fixing changes dramatically. ## Software Factory works for your codebase We separate the general behavior of the Factory from the knowledge that is specific to Guild. Planning, implementation, review, retrying, escalation, and auditing are reusable. Your coding standards, architecture, testing conventions, migration patterns, and repository-specific rules belong to your team. Those become Skills that the Factory can use. That separation lets the same Factory architecture operate across very different codebases without turning into a collection of hand-tuned prompts. Underneath it all is Guild: sandboxed execution, governed credentials, permissions, integrations, observability, cost controls, and the infrastructure required to let agents safely act against real systems. ## From coding agents to engineering systems Coding agents have already changed how engineers write software. We think the next step is bigger. The opportunity is to build systems that continuously and autonomously find work, route it, execute it, review it, maintain themselves, and hand validated results back to people. That is what Software Factory has become for us. 34% of merged PRs. 56% of all code fixes. 81% of log-triage fixes. A 97% reduction in time-to-fix for some workflows. The point isn't that AI can write code. The point is that engineering organizations can start operating differently. Every engineering team will have its own Factory. Guild is the control plane to run it. ## Build your own Software Factory Every engineering team will have its own Factory. Guild is the control plane to run it. Talk to us about bringing the Factory to your codebase. [Book a demo](https://guild-ai.cal.com/gtm/meeting-with-guild.ai)