Skip to content

Blog

Are 100x Productivity Gains Really Possible With Multi-Agent Workflows?

My commit count went from about ten a day to nearly a thousand on my busiest day. Here is what the studies, the vendors, the companies and the practitioners actually show about AI productivity, and what a 100x claim can and cannot mean yet.

A level balance holds a small marked tile on one side and a stack of wide plates on the other.A level balance holds a small marked tile on one side and a stack of wide plates on the other.
How much more work does the same effort buy?

My impression was that I went from about 10 commits a day to about 1,000 a day. That would be 100x. Before writing this post, I counted.

Across every repository in my company’s GitHub organization, after removing copied histories, I averaged 12 commits a day in November 2025. Over the last 30 days I averaged 265 a day. On my busiest day, Saturday, November 14, I authored 898. So the honest numbers are about 22x on average and about 74x on my best day, not 100x across the board. Most of those repositories are private, so I give totals only; the commands and counts are in this post’s research notes.

Twenty-two times more commits is still a different job. The question is whether that is a productivity gain, and whether anything like 100x is real. Here is what the evidence shows, in order of how much I trust it.

Commits are not productivity

Start with the unit. Agent workflows make commits smaller and more frequent. Every merged pull request adds a merge commit, and 1,870 of my last 30 days’ commits were merges. Without them, the increase is about 17x. Counting commits rewards exactly the behavior agents produce.

What shipped is better evidence. On November 14, I merged 141 pull requests in one day across four repositories, all written by agents and reviewed by other agents. Two posts on this site went from filed issue to live in 22 minutes each, cover image included. That is output I can show. It is still not a measurement of value, and I don’t have a controlled comparison of what I would have shipped without agents.

The neutral experiments: real, modest gains

The best evidence comes from randomized trials and field experiments run by researchers who don’t sell the tools. They mostly studied autocomplete and chat, not agents.

Study Design Finding
Cui and colleagues, Microsoft, Accenture and a Fortune 100 company (2025) Three field experiments, 4,867 developers 26% more completed tasks, more for less experienced developers
Brynjolfsson, Li and Raymond (NBER 2023, QJE 2025) Staggered rollout, 5,179 support agents 14% more issues resolved per hour; 34% for novices
Dell’Acqua and colleagues at BCG (2023) Preregistered experiment, 758 consultants Inside the AI’s competence: 12.2% more tasks, 25.1% faster. Outside it: 19 points less likely to be correct
Peng and colleagues (2023) Lab trial, 95 programmers, one task 55.8% faster writing an HTTP server

Cui and colleagues include Microsoft researchers, and the Peng trial was run by Microsoft Research and GitHub with MIT. The BCG study had BCG coauthors. The direction is consistent: tens of percent, not multiples.

The most important counterexample is METR’s July 2025 trial. Sixteen experienced open-source developers worked 246 real issues in repositories they knew well. With early-2025 AI tools they were 19% slower. They expected to be 24% faster and, afterward, believed they had been 20% faster. Perception is not measurement, and that includes mine.

METR then tried to repeat the study with 57 developers. In its February 2026 update, returning developers took 18% less time with AI, but the confidence interval ran from 38% faster to 9% slower. The design broke for a revealing reason: 30 to 50% of developers withheld tasks from the no-AI condition because they didn’t want to do them without AI, and timing became unreliable for developers running several agents at once. METR calls the result an unreliable signal and probably a lower bound. The control group is disappearing.

Large samples: faster individuals, harder systems

Telemetry and surveys cover far more people, with weaker designs.

  • Stanford’s software engineering productivity group studies Git data from more than 100,000 engineers at 600-plus companies. Its 2025 talk slides suggest 20 to 25% gains on simple work in popular languages and 10 to 15% on complex work. In one case, PRs rose 13.6% while effective output rose 1% and rework rose 2.6x. These are slides, not a peer-reviewed paper.
  • Faros AI, a vendor, measured more than 10,000 developers in July 2025. High-adoption teams merged 98% more PRs, but review time rose 91%, and it found no significant correlation with company-level outcomes.
  • Google’s DORA research found in 2024 that 25% more AI adoption was associated with 1.5% lower delivery throughput and 7.2% lower stability. Its 2025 report found throughput rising and instability still rising, and called AI “an amplifier.” Google funds DORA.
  • METR’s May 2026 survey of 349 technical workers found a median self-reported 3x speedup, and a 1.4 to 2x gain in value. METR thought several 10x-plus answers looked overstated.

The pattern is that individuals produce more, and the system around them absorbs part of it in review, rework and instability.

The economy-wide numbers are smaller still. The St. Louis Fed’s survey series puts time saved at 2.2% of all US work hours in mid-2026, up from 1.6% in late 2024. Danish administrative data show no measurable effect on earnings or hours two years after ChatGPT. US productivity grew 3.6% annualized in the third quarter, but no official statistic attributes any of it to AI. Brynjolfsson, Rock and Syverson’s productivity J-curve explains why this can be true while gains are coming: a general-purpose technology first absorbs investment in new processes, which hides its benefits in the measured statistics.

The vendors’ numbers: big, and interested

The AI companies report much larger effects. They sell the tools, so I read them as interested parties.

  • Anthropic’s December 2025 study of its own staff found a self-reported 50% productivity gain and 67% more merged PRs per engineer per day. Its model-based estimate says Claude conversations save about 80% of task time, while noting that it lacks real-world validation.
  • OpenAI reports that its engineers who use Codex ship about 70% more merged PRs. Users and non-users are self-selected.
  • GitHub’s Octoverse 2026 found agents drafted more than 40% of pull requests in September 2026, up from 17% in March. That counts drafts, not value.
  • Google says 75% of its new code is AI-generated and approved by engineers, as of April 2026. Google’s own controlled trial in 2024 measured about 21% less time on a task.

Share of code is the weakest of these. A company where AI types 100% of the code can still be only slightly faster than before.

Companies at factory scale

Some companies now report throughput that looks like a factory. Stripe merges more than 1,300 pull requests a week with no human-written code, each reviewed by a person. Spotify reported 60 to 90% time saved on migrations and, by June 2026, 76% higher PR frequency. Ramp’s background agent started about half of the merged PRs in its main repositories. Cognition says 89% of the code its engineers commit is committed by Devin.

These are throughput counts without a published baseline, quality data or revert rates. They show that agent-run delivery works at scale. They don’t show how much more value it delivers.

Does multi-agent add anything?

This is the part I care about most, and the evidence is thinnest.

Anthropic found a lead agent with subagents beat a single agent by 90.2% on its internal research evaluation, while using about 15 times the tokens of chat. It also said most coding is less parallelizable than research. A controlled study from Google, MIT and others tested 260 configurations: multi-agent systems improved results by 80.8% on decomposable tasks and degraded them by 70% on sequential planning. Carnegie Mellon’s CAID found asynchronous multi-agent setups beat single agents by 14.7 to 25.6 points on two coding benchmarks. OpenAI’s Codex telemetry shows more than 10% of users run three or more agents concurrently each week.

None of these measures a person’s productivity. No study I found randomizes people to single-agent and multi-agent workflows. So the multi-agent increment is plausible, task-dependent and unproven.

My own reason to believe in it is structural, not statistical. A single agent speeds up the typing. A multi-agent workflow can take the issue, the code, the independent review, the revision and the merge, and run many of those loops at once. The bottleneck moves from writing code to deciding what to build and verifying it. That’s why I argued that verification is the new programming. The Faros and Stanford results point the same way: when output rises and review doesn’t, the gain disappears into the queue.

The anecdotes

In the absence of hard data, practitioners are publishing their own numbers. These are self-reported anecdotes, nothing more.

The high numbers come from people running many agents with their own tools. The cautious ones come from people who are mostly limited by how much they can review. Neither is a measurement.

Beyond software

The same shape shows up elsewhere in IT. In support, the best evidence is still the 14% gain from Brynjolfsson and colleagues, while Klarna’s claim that its assistant did the work of 700 agents was followed in 2025 by a return to hiring people. In security, Microsoft’s own trial found experienced analysts 22% faster and 7% more accurate, and DARPA’s AI Cyber Challenge systems found 54 of 63 planted vulnerabilities and patched 43. In operations, no frontier model scored even 50% on 59 Kubernetes root-cause tasks in May 2026. Gains are real where work is well-defined and checkable, and weak where it isn’t.

Can we even know yet?

Not with today’s measurements. Five problems stand in the way:

  1. Output is not outcome. Commits, PRs and share of code are easy to count and easy to inflate. Faros saw PRs nearly double with no company-level effect.
  2. Quality and rework hide the cost. Bigger PRs, longer reviews and more complex code can cancel the speed.
  3. Goodhart’s law. Once commits or PRs become the target, agents will happily produce more of them.
  4. Selection. Early adopters are enthusiasts, vendors survey their customers, and METR’s control group refused to work without AI.
  5. Time lags and incentives. The J-curve delays gains, and the largest numbers come from people selling the tools.

Better evidence would randomize workflows, not just tool access. It would measure outcomes at the team or company level: features shipped, defects, incidents, rework and revenue. It would pair throughput with stability, run long enough to clear the J-curve, and publish baselines.

My answer

Productivity is clearly rising. The neutral experiments show tens of percent for assisted work, and those studies mostly predate agents. Agents now draft two in five pull requests on GitHub, and some companies run agent-written code through production at hundreds or thousands of PRs a week.

Multi-agent workflows plausibly multiply that for people who invest in them: in independent review, tests, merge rules and the discipline to verify what the agents produce. My own record is one example, a 22x increase in commits and a day with 141 merged pull requests. I read that as a material change in how fast I can iterate on my software and on the workflow itself.

Is 100x possible? I think so, on some measures, for some people. My own record is approaching that order of magnitude: my busiest day was 74 times my average a year ago. That is a count of commits, not of value delivered. As a general, outcome-level number, 100x isn’t proven, and nobody has the data to prove it yet. Anyone who tells you the number is precisely 100x, or precisely zero, is guessing.

What to watch

  • A study that randomizes single-agent and multi-agent workflows on real work.
  • Outcome data from the factory-scale companies: defects, reverts, incidents and features delivered, not just PR counts.
  • METR’s next attempt at a measurement that survives developers refusing to work without AI.
  • Whether the US productivity statistics start bending, and whether anyone can attribute it.
  • Review capacity. If verification scales, the multiplier can keep growing. If it doesn’t, it becomes the ceiling.

I’m building Astrohacker for that last point. The gain is no longer in writing the code. It is in building the system that can trust it.