Anthropic's Agents Broke Git at 30K Merges a Day
In May 2026, Anthropic merged about 2,500 code changes per day into its monorepo. By September, that number was 30,000. A 12x surge in four months — driven almost entirely by Claude agents writing, testing, and shipping code. The developer infrastructure that had served human engineers for years buckled under the weight. Git, the version control system that underpins nearly every software team on the planet, could not keep up.
📖 Read the full version with charts and embedded sources on ComputeLeap →
So Anthropic did something radical: it replaced Git entirely. A seven-person team spent five months building Scion, a custom version control system designed from scratch for agent-scale development, plus Antique, a companion code review tool. They migrated their entire monorepo — nearly 100 GB of main-branch history — off Git and onto the new system.
This is not a theoretical exercise or a conference talk about what might happen. This is a production migration at one of the most important AI companies in the world, and it carries a clear signal for every engineering team running coding agents: your infrastructure was built for humans. When agents arrive at scale, something will break. The question is what, and whether you have planned for it.
What Actually Broke
Git's core design dates to 2005, when Linus Torvalds built it for Linux kernel development. Its fundamental assumption is that every clone is a complete, offline-capable copy of the repository. That is elegant for distributed human teams. It is catastrophic for thousands of always-online agents.
Here is what Anthropic hit as merge volume climbed:
The mirror problem. To serve thousands of concurrent agents, CI jobs, and research workloads, Anthropic ran several hundred internal Git mirrors. Each mirror holds a full copy of the repo. As merge rates climbed, keeping mirrors in sync became untenable — seeds drifted from main between refreshes, diff and blame on partial clones produced incorrect results, and mirrors started exceeding their disk and memory limits.
The checkout explosion. At peak, Anthropic's CI infrastructure ran roughly 25 million checkouts per day — excluding developer environments, agent sandboxes, and research jobs. A naive fetch model implied over 600 petabytes of Git traffic daily. Standard workarounds (shallow clones, sparse checkouts, promisor remotes, blob-stored seeds) helped temporarily but became increasingly fragile.
The merge queue bottleneck. A traditional merge queue uses a global lock: changes enter a serialized queue, CI validates each one, and they merge to main in order. At human scale (tens of merges per hour), this works. At agent scale (30,000+ per day), a global lock becomes a throughput ceiling. As Amplify Partners noted, Git's reconciliation algorithms max out at roughly 2-3 merges to main per second in baseline configurations.
Read the full engineering post on Anthropic →
Scion: What Anthropic Built
Scion inverts Git's core assumptions. Where Git assumes clients work offline and keep full copies, Scion assumes clients are always online — because nearly all of them are agents and CI jobs.
Server-side operations. The Scion server handles history queries, blame, commits, merges, and rebases. Clients keep a bounded local cache, track filesystem changes, and provide the user interface — but the heavy computation stays server-side. Creating a commit scales with the size of the change, not the size of the repository.
API-first design. Every source control query goes through an API. This means many CI jobs and automated pipelines never need a local checkout at all. Automated bisect and revert pipelines depend entirely on API calls, not local clones.
Three-tier caching. Scion uses a layered cache architecture:
- scion-daemon — one per compute node, shared by all jobs on that node, bootstrapped from periodic snapshots
- scion-cache — regional caches that stream objects from memory
- scion-server — authoritative, backed by Google Spanner and cloud storage
All three tiers share the same RPCs, so clients do not need to know the topology. Each tier maintains over 99% cache hit rates. Failure domains are strictly isolated — a regional cache failure cannot overwhelm upstream servers.
Changesets, not commits. Scion's unit of work is a changeset — an entry in a write-ahead log that records files changed relative to the first parent, with content-addressed pointers to compressed blobs. In trunk-based development, mainline history is what matters most, and Scion's data model reflects that.
Refs are discouraged. Unlike Git, where branches and tags are cheap and abundant, Scion actively discourages refs beyond main and release branches. The reason: globally shared state creates scaling problems when thousands of agents are operating concurrently.
The Results
Anthropic's performance claims are striking, though they come from Anthropic itself and have not been independently verified:
💡 Scion uses approximately 200x less CPU and memory than Anthropic's previous fleet of several hundred Git mirrors. CI checkouts dropped from minutes to seconds — roughly two orders of magnitude faster. CI alone gained a 25% CPU capacity win. Every cache tier maintains over 99% hit rates with no long-lived state.
Perhaps the most telling detail: Claude itself rewrote the Git-to-Scion ingestion pipeline. Anthropic reports the Claude-written version used 20x less memory and ran 4x faster than the handwritten prototype, while preserving ingestion-ordering invariants. Claude also found an algorithmic optimization to ancestry queries that had eluded the human engineers — it noticed an existing index that was not being used.
The Self-Referential Loop Nobody Is Talking About
Here is what most coverage of Scion misses: this is a story about AI building its own infrastructure.
Claude agents generated the code volume that broke Git. Claude agents then helped build the replacement. Claude agents now monitor Scion's health through "superfan" bots that watch individual components' telemetry and logs, supplementing traditional alerts. And Claude agents are the primary users of the new system.
The Register framed it bluntly: the bottleneck was self-inflicted. Claude generated the code volume, and Claude was then used to fix the tooling. That is not criticism — it is a preview of what agent-driven engineering looks like. The toolchain becomes part of the product's own feedback loop.
This matters because it changes the economics of developer infrastructure. When your agents generate enough load to justify custom infrastructure, and your agents can help build that infrastructure, the ROI calculation shifts dramatically. The seven-person team that built Scion was leveraging Claude throughout — engineers focused on system design and trade-offs while Claude handled implementation.
Read the full analysis on DevOps.com →
GitHub's Response: Rebuilding in Place
Anthropic had the luxury of a clean-sheet design. GitHub does not. With over 200 million developers (and an exponentially growing population of agents) on its platform, GitHub is rebuilding its Git backend in place — while keeping the service running.
The numbers tell the same story from a different angle. Brian Celenza, a principal engineer on GitHub's storage team, published the scale of what they are facing:
- Pushes grew 4.9x year over year, from 0.69 billion to 3.35 billion per month
- 7.38 billion commits in September 2026 alone, over 5x the prior year
- GitHub Actions ran 3.26 billion times in September, also 4x year-over-year
- Total Git activity more than doubled, from 218.2 billion to 473.3 billion events per month
GitHub's COO Kyle Daigle told Latent Space he expects 14 billion commits for 2026, up from about 1 billion in all of 2025.
GitHub's architecture fix mirrors some of Scion's principles. The current Spokes system stores full replicas on local disks, with every replica participating in every write. The new architecture decouples storage (Azure Blob Storage) from compute (stateless cache workers), with internal benchmarks showing up to 35x higher write throughput. Losing a compute worker becomes a cache miss, not a data loss event.
The key difference: GitHub must preserve backward compatibility with Git's protocol, ecosystem, and user expectations. Anthropic threw all of that away.
The Broader Version Control War
Anthropic and GitHub are not alone in rethinking version control for agents. A small but serious cohort of startups is attacking the problem from different angles.
GitButler, founded by GitHub co-founder Scott Chacon, raised $17M from a16z to build agent-optimized version control. Their bet: Git's porcelain (the user-facing commands) is the bottleneck, not the plumbing. GitButler supports parallel branches, agent-specific CLI commands, and rich metadata tracking. Their experimental project Grit — a from-scratch rewrite of Git in Rust, largely built by AI agents — demonstrates the approach.
East River Source Control (backed by Amplify Partners, led by Steve Klabnik) is building a new backend that swaps Git's storage engine for a horizontally scalable alternative while keeping the Git protocol and Jujutsu as the interface. Their argument: Git's distributed model is right, but its storage ceiling is the constraint.
Entire is building a distributed repository network with synchronized mirrors closer to agents, arguing that centralized hosting platforms are themselves the bottleneck. Their Field CTO Karthik Rameshkumar's WeAreDevelopers talk titled "Fixing Git for Agents" summarized the position: traditional version control is fundamentally broken for AI coding agents.
What the Community Is Saying
The developer community's reaction has been split between admiration and skepticism.
The Hacker News thread — 873 points and nearly 1,000 comments — became one of the most active engineering discussions of the week, with practitioners debating whether Scion validates or undermines the case for Git at scale.
View the full discussion on Hacker News →
On Bluesky, developer Nick Gerakines wrote: "Git had been and continues to be bad for mono repo development at large scale." Tim Kellogg noted that Anthropic's decision to abandon the single global merge queue was the most significant architectural choice.
Read the full coverage on AI Weekly →
On X, the announcement drew wide commentary. AGTP Insights summarized the split: some see Scion as the end of Git for large-scale agent operations, while skeptics question whether anyone can meaningfully track 30,000 changes per day.
On the skeptical side, developer Austin Parker observed: "You can sure do neat stuff when you buy tokens by the truckload." And that is a fair point — Anthropic's internal token spend far exceeds typical business usage, which is part of why a clean-sheet VCS redesign is practical for them and not for most teams.
Mitch Ashley of The Futurum Group put it in strategic terms: "Source control has joined the fight over agent-driven software delivery." He drew a parallel to NVIDIA's Hugging Face deal, arguing that AI leaders are racing to own infrastructure — not just models.
⚠️ The "git is dead" narrative is premature. Anthropic built Scion for a monorepo approaching 100 GB with 30,000+ daily merges — a problem roughly seven companies on Earth actually have. For 99.9% of teams, the real bottleneck is not Git itself but the human review workflows wrapped around it. GitHub is already rebuilding its backend with 35x higher write throughput while preserving full backward compatibility. Bet on Git adapting before betting on Git dying.
Prior Art: This Is Not New Territory
Anthropic is not the first company to outgrow Git. Google built Piper, a centralized VCS holding over two billion lines of code, described publicly in 2016. Meta built Sapling, later open-sourced, which keeps Git's conceptual model but redesigns the storage and user interface. Both were responses to the same fundamental tension: Git's distributed model assumes each user maintains a full copy, which becomes untenable at extreme scale.
What is new is the speed. Google and Meta evolved their systems over years as human engineering teams grew. Anthropic hit the wall in four months because agents do not ramp up gradually — they scale with compute.
What This Means for You
Most teams will not build their own VCS. But if you are running coding agents today — Claude Code, GitHub Copilot, Cursor, Codex — Anthropic's experience is an early warning. Here is the infrastructure audit:
💡 Three questions every team running coding agents should answer:
Merge queue serialization: Can your merge process handle 100+ concurrent merges? If you are using a single-threaded merge queue, it will become your bottleneck before anything else does.
CI fan-out ratio: Each agent push triggers CI, which triggers clones, which triggers read amplification. What is your read fan-out per write? At agent scale, this can be 1,000:1 or higher.
Repository growth rate: Agents checkpoint constantly, inflating commit history. Track your repo size growth weekly. If it is accelerating, you need a strategy — shallow clones, sparse checkouts, or periodic history rewriting.
Anthropic's post suggests that Git platforms could adopt some of Scion's ideas — server-side RPCs, novel negotiation protocols, and sparse/shallow features that compose better. GitHub is already moving in this direction. The gap between "what Git was designed for" and "what agents demand" will only widen.
Read the detailed analysis on CellCog →
The era of developer infrastructure designed for human-speed collaboration is ending. What replaces it is still being built — by seven-person teams at Anthropic, by GitHub's storage engineers, and by a growing cohort of startups who see version control as the next battleground. For practitioners, the takeaway is simpler: audit your infrastructure now, while you still have time to adapt.
For more on how coding agents are reshaping developer workflows, see our guides on AI coding agents and startup productivity and the Claude Code agentic development stack.
Originally published at ComputeLeap
Top comments (0)