Anthropic replaces Git with Scion as AI agents push 30,000 merges a day
On October 13, 2026, Anthropic published an engineering post explaining how it replaced Git with an in-house version control system called Scion, after daily merges grew from 2,500 in May to over 30,000 in September. For most teams, Git remains the right choice; the signal to take away is that agent-written code shifts the bottleneck from humans to infrastructure.
October 13, 2026. Anthropic publishes an engineering post documenting how it replaced Git with an in-house version control system called Scion. May 2026. The monorepo absorbs about 2,500 merges a day. September 2026. That number passes 30,000, peaking at 30,401 on September 9. Why it matters: this is the first quantified account from a major lab of what happens to developer infrastructure when agents write most of the code — and Anthropic’s conclusion fits in one line: “coding is no longer the bottleneck.”
When Git becomes the weak link
The climb is steep. Roughly 1,000 merges a day in January, an acceleration through spring, then a sharp rise from July, interrupted by a “quiet week” in early August. The September 9 peak hits 30,401 merges. At that volume, the very properties that make Git an excellent tool for offline human work turn against an organization that is, in practice, running it as a centralized system.
The monorepo numbers are unambiguous: the history of the main branch alone is nearly 100 GB, a compressed working copy exceeds 25 GB, and roughly 25 million checkouts run each day for CI, before counting developer machines, agent sandboxes and research jobs. A naive fetch would mean over 600 PB of traffic per day.
Anthropic first exhausted the standard playbook: shallow clones, sparse checkouts, promisor remotes, internal mirrors, seeds in blob storage. At peak, several hundred internal mirrors were running. It bought time, but the seeds drifted from the tip of main, and operations like diff and blame on partial clones demanded ever more care. Anthropic’s conclusion is architectural: Git is decentralized — every clone can compute diffs and read history offline — while its clients are now agents and jobs that are, by definition, always online.
What Scion actually changes
Scion embraces the opposite of Git. Where every clone computes, Scion centralizes: the server answers history and blame, creates commits, and performs merges and rebases. The client keeps only a bounded object cache, lays out working files and watches for filesystem changes — it computes almost nothing itself. The post credits two predecessors: Google’s Piper and Meta’s Sapling.
The unit of work is no longer a commit pointing at a tree, but a changeset: an entry in a write-ahead log that stores only the list of files changed relative to its first parent, plus content-addressed pointers to compressed contents in blob storage. A changeset is created server-side and available everywhere instantly; moving a ref becomes a compare-and-swap on a single Spanner row. The checkout path requests only immutable objects, served by three interchangeable tiers — a node-level daemon, a regional cache, then the authoritative server — each keeping a cache hit rate above 99%.
The subtlety lies in what Anthropic calls “derived data.” Because a changeset records only what changed, answering “who last edited this line” needs extra structures: file blame, path history, skip lists for the commit graph. Each type is defined recursively from its values at the changeset’s parents, which makes it easy to add new ones — copy detection, path-based search — without touching the client. This is the exact opposite of the Git model, where those answers are recomputed locally by every clone.
The published results are vendor figures, but they match the thesis: a footprint 200 times smaller than the old mirror fleet, checkouts two orders of magnitude faster — seconds instead of minutes — and a 25% CI CPU capacity win.
Seven people, five months, and Claude in the loop
The team that built Scion, the Antique review tool and half a dozen related systems numbered seven people, and the full monorepo migration took five months, while merge volume grew tenfold. That is the speed lesson, but it is not the most interesting one.
The most interesting one is where Claude sat in the build. The Git-to-Scion ingestion pipeline had first been written by hand. Anthropic then handed its rewrite to an internal snapshot of Claude Mythos Preview, with no further instructions: the result used 20 times less memory and ran 4 times faster, while preserving implicit invariants around ordering and data structures. The engineers, the post says, would now rate Claude as better than themselves at writing code — but their job was often to tell it “no,” because agents sometimes violate core constraints, for example by reading the commit log linearly instead of asking the review tool. Human review now examines the intent of a change rather than every line.
The post also slips in a security note that matters directly to teams: Scion carries access control per repository and per directory, and the review tooling can express semantic constraints on approvals — for example, separating a comment-only change from one that touches sensitive logic. That is the kind of guardrail human review can no longer hold manually at 30,000 merges a day, and it becomes essential once half the code is not written by a human.
The broader market is already moving in the same direction. Cursor has pitched its own agent-native hosting, Origin, on the argument that AI agents need version control designed for them rather than adapted from Git. The pattern is the same one that played out a decade ago, when monorepos pushed companies toward Piper-style centralized systems: once the client stops being a human with a laptop, the assumptions that made a distributed model optimal quietly invert. Anthropic’s post is the clearest public evidence yet that the inversion is already happening inside the labs that build the agents themselves.
The post also documents a telling tooling shift: between June and July, the merge chart moves from pull requests to the in-house Antique change requests — the mark of an organization reasoning in terms of changes to land rather than repositories and branches. Quality improved in measurable ways too. Anthropic built hermetic simulations of every non-trivial infrastructure interaction, plus fuzzing and rate limiting, and Claude found an algorithmic optimization to ancestry queries that had missed an index — work the post estimates would have taken a human expert days or weeks. At agent scale, the wins are no longer in writing more code, but in the review, simulation and tooling that decide whether that code is safe to merge.
Verdict
Do not rewrite your version control system, and Anthropic says so itself: Git remains the right design for most repositories, and Scion is not a product — no release plan is announced, and it leans on Spanner and Google blob storage, not generic building blocks. If your agents merge a few dozen changes a day, your problem is not Git; it is review quality and the guardrails around your agents. If you are approaching thousands of agent-generated merges daily, watch instead for “server-centric” features from repository hosts, which will inevitably follow — the real signal of this post is that agent-written code shifts the bottleneck from humans to infrastructure, and those who understand that are already investing in the plumbing. The lesson scales well beyond one lab: when agents write most of your code, the systems that store, review and ship it become the product.