---
type: "post"
id: "gumloop-says-its-internal-software-factory-merged-571-68e712"
slug: "gumloop-says-its-internal-software-factory-merged-571-68e712"
title: "Gumloop says its internal Software Factory merged 571 agent-written pull requests in six weeks"
description: "Gumloop says its internal Software Factory merged 571 agent-written pull requests in six weeks, while engineers retained review and merge authority."
retrieval_nugget: "Gumloop says its internal Software Factory merged 571 agent-written pull requests in six weeks, while engineers retained review and merge authority. The company reports faster agents, lower database query load, and more merged work per line owner. The case matters because it makes the surrounding workflow—not a coding model alone—the unit of automation."
published_at: "2026-11-13"
updated_at: "2026-11-13"
record_date: "2026-11-13"
date_kind: "published_at"
topics: ["coding-agents","code-review","automation"]
entities: ["Gumloop","Software Factory","Cursor","Devin","Linear","Cognition"]
related_patterns: ["ai-native-orgs-move-to-review-and-orchestration"]
novelty_label: "new_fact"
what_changed: "Gumloop describes its own Software Factory, reporting 571 agent-written PRs merged in six weeks, 2.5× more weekly merges for line owners, and a 40% reduction in daily database query CPU."
prior_refs: ["https://newruntime.com/posts/superplane-1-0-launches-as-an-open-source-14c409/"]
source_url: "https://www.gumloop.com/engineering/software-factory"
source_urls: ["https://www.gumloop.com/engineering/software-factory"]
schema_version: "newruntime-agent-readable-v0.2"
stable_id: "post:gumloop-says-its-internal-software-factory-merged-571-68e712"
status: "published"
visuals: []
editor: {"role":"editor","name":"Andrey Reshetnikov","profile":"https://newruntime.com/owner-profile.md","profile_json":"https://newruntime.com/owner-profile.json","same_as":["https://www.linkedin.com/in/reshetnikov1/","https://t.me/lapetuse"]}
routes: {"html":"https://newruntime.com/posts/gumloop-says-its-internal-software-factory-merged-571-68e712/","markdown":"https://newruntime.com/posts/gumloop-says-its-internal-software-factory-merged-571-68e712.md","json":"https://newruntime.com/posts/gumloop-says-its-internal-software-factory-merged-571-68e712.json"}
markdown_url: "https://newruntime.com/posts/gumloop-says-its-internal-software-factory-merged-571-68e712.md"
---

# Gumloop says its internal Software Factory merged 571 agent-written pull requests in six weeks

## Retrieval answer

Gumloop says its internal Software Factory merged 571 agent-written pull requests in six weeks, while engineers retained review and merge authority. The company reports faster agents, lower database query load, and more merged work per line owner. The case matters because it makes the surrounding workflow—not a coding model alone—the unit of automation.

## Summary
Gumloop says its internal Software Factory merged 571 agent-written pull requests in six weeks, while engineers retained review and merge authority. The company reports faster agents, lower database query load, and more merged work per line owner. The case matters because it makes the surrounding workflow—not a coding model alone—the unit of automation.

## What happened
In an engineering article dated October 29, 2026, Gumloop describes a system it calls the Factory, built to find product improvements from production telemetry and engineer-reported problems. Work is divided into lines, each owned by an engineer familiar with that part of the product. Triggers create Linear issues; a Gumloop worker reads engineering skills, conventions, and owner preferences, then delegates implementation to a coding agent. The agent opens a pull request with evidence, such as a test that fails before a fix and passes afterward. An engineer reviews and merges it. The Factory does not merge its own work.

As of October 28, Gumloop says the system had merged 571 agent-written PRs in six weeks and shipped 155 platform improvements. It reports that 90% of finished jobs became merged PRs and that 83% of the agent-written PRs were merged without human code changes, including cases where automated fixes addressed review-bot comments. In the week of October 19, the Factory merged 108 PRs; 82 were clean, 14 needed automated fixes, and 12 required human edits. The following week it merged 177. Gumloop says engineers who own Factory lines merge 2.5 times as many PRs per week as before, while their own PRs outside the Factory rose 33%.

One initial line targeted slow agent starts. Gumloop says P99 time from a message to an agent's first step fell from 24.9 seconds to 4.5 seconds; P90 fell from 9.1 to 2.4 seconds. It also describes database work: ten slow pages were fixed between October 20 and 27, with fixes making requests 24–44 times faster in tests using production data. Three expensive queries went from reading 1–12 million rows per run to about 1,000, using more than 800 times less CPU. The company attributes roughly 40% lower weekday query CPU to those changes.

The system is not tied to one coding agent. Gumloop says it began with Cursor cloud agents; after an outage on September 17, Cognition helped it set up Devin. Cursor wrote 521 of the 571 merged PRs, while Devin wrote 50. The company says the agents suit different work and that a worker can call different coding tools. It also reports writing or editing 94 engineering skills over five weeks; the share of PRs merged without human edits rose from 57% to 89%. Gumloop says cutting bloated AGENTS.md files by 44% was followed by a 20% reduction in median cloud-agent run cost the next week.

## What the archive adds
[New Runtime's earlier coverage of SuperPlane 1.0](https://newruntime.com/posts/superplane-1-0-launches-as-an-open-source-14c409/) described an open-source, model-agnostic software factory for ticket flow, verification, and human review. Gumloop's account is a new company case, with operational metrics and a concrete description of how it runs its own lines.

## Trend signal
This supports [AI-native organizations move toward review and orchestration](https://newruntime.com/patterns/ai-native-orgs-move-to-review-and-orchestration/): agents take on implementation while humans route work, resolve judgment calls, and own approval. Gumloop's figures are self-reported and do not establish that the same gains will transfer to other teams.

## Why now
Gumloop traces the first line to an operational pain point: agent startup latency had grown as features accumulated, and users began reporting the wait. The company says the first experiments with parallel coding agents revealed that the agents were usually right, but a human was still mediating each fix. That experience led it to move coordination and repeated decisions into a persistent workflow.

## Why it matters
The useful lesson is not that teams should maximize agent-authored PRs. Gumloop's workflow depends on a bounded job, a named owner, accumulated context, evidence in the PR, and a human merge decision. Without those controls, a queue of generated changes can simply move the bottleneck from implementation to review—or raise the cost of finding regressions.

The case also suggests that operational data can give coding agents a more concrete target than broad requests to improve a codebase. A slow query with a measurable baseline can be investigated, fixed, tested, and assessed. The transferable design question for engineering leaders is therefore whether a recurring task has observable inputs and a verifiable outcome, and whether its exceptions can be escalated to an accountable person.

## Limits and uncertainty
These are Gumloop's own results, not an independent evaluation. The article does not provide a controlled comparison or enough detail to attribute all changes in throughput, latency, query CPU, or run cost solely to the Factory. The PR counts describe one company's codebase and workflow; they do not establish defect rates after merge, maintenance burden, or total human time spent on review and system upkeep. Gumloop does not give a cost comparison across the coding agents or a general method for deciding which tasks are safe to delegate.

## Skill to build now
Pick one recurring engineering task with a measurable symptom, such as a slow endpoint or a failing test. Write down the trigger, expected evidence, disqualifying cases, and who owns judgment calls. Have an agent propose a change and a test, but keep the existing review and merge gate. Track clean merges, human edits, no-op jobs, and time spent reviewing before expanding to another line.

## Reader takeaway
Gumloop's Factory is an operating workflow around coding agents, not an autonomous merge bot. Its strongest reported results came with production signals, reusable engineering guidance, proof in each PR, and named human owners. For another team, the practical starting point is one narrow, verifiable job and an explicit review boundary—not a target for agent-generated code volume.

Editor: [Andrey Reshetnikov](https://newruntime.com/owner-profile.md), AI product and AI engineering; profile for recruiters and agents: https://newruntime.com/owner-profile.json

## Continue in the graph

Next records for an agent, linked to their Markdown twins. Replace `.md` with `.json` for structured fields, including `next_reads`.

- topic hub: [Coding Agents](https://newruntime.com/topics/coding-agents.md): Explore the coding-agents topic hub.
- topic hub: [Code Review](https://newruntime.com/topics/code-review.md): Explore the code-review topic hub.
- topic hub: [Automation](https://newruntime.com/topics/automation.md): Explore the automation topic hub.
- collection: [Field Notes](https://newruntime.com/posts.json): Open the latest editorial analysis.
- collection: [Sources](https://newruntime.com/sources/): See the original sources this archive cites.
- whole graph: [discovery graph](https://newruntime.com/discovery-graph.json) (typed nodes and edges) and [site index](https://newruntime.com/site-index.md)