Claude’s merge rate outgrew git, so Anthropic built Scion

Anthropic has moved its monorepo off git and onto Scion, a version control system it built in-house in five months. It made the switch after merges into that repo grew from around 2,500 a day in May to more than 30,000 a day in September, the company said in an October 13 post on Anthropic’s engineering blog. Anthropic still calls git’s design right for the vast majority of repositories and doesn’t expect many organizations to hit these problems in the very near term. Scion is built for one case: nearly every client is an agent or a CI job that is always online, so the server handles history, blame, commits and merges, and many jobs never check out the code at all.
The merge rate grew more than twelvefold in four months, and Anthropic doesn’t expect it to slow down. In the post’s words, “the latent demand for merging code is practically infinite, and every bottleneck we remove immediately leads to a further increase in the amount of code we produce.”
Where git ran out
The history of the main branch alone is almost 100 GB, and a compressed working copy is over 25 GB. CI performs on the order of 25 million checkouts a day, and that is before developer environments, agent sandboxes and research jobs. Fetched naively, that would be over 600 PB of git traffic a day.
Anthropic had already used git’s own tools for working with part of a repository: shallow clones, sparse checkouts and promisor remotes. It also used the usual monorepo workarounds, internal mirrors and repository snapshots called seeds kept in blob storage. At the peak it ran several hundred internal git mirrors. Those bought time but got harder to operate as the merge rate rose. Seeds fell further behind the tip of main between refreshes, keeping diff and blame working on partial clones took more and more care, and the mirrors stopped scaling once the repo outgrew their disks or memory.
Online by definition
The turn in the post is an observation about usage. Like most companies, Anthropic was running git as a centralized system with one authoritative copy, while nearly all of its clients were agents and jobs that are online by definition. Every git clone is a complete repository that can compute diffs, read blame and check out any revision offline. At this scale those properties were working against the company. Google’s Piper and Meta’s Sapling were the prior art the team drew on.
So Scion splits the work unevenly. The server answers questions about file history and blame, creates commits, and performs merges and rebases. The scn client keeps a bounded local object cache, lays out working-copy files on disk, watches for filesystem changes and gives users a way to work with the server. On its own it can compute very little. In exchange it needs far less data locally.
Every query the client uses is also exposed through an API, and that is where most of the savings come from. A CI job that needs the diff between a commit and its merge base asks the server for it, and many write workloads skip the checkout too. Anthropic says internal tools such as its automated bisect and revert pipelines wouldn’t be practical at scale without that cheap programmatic access. When a job does need files on disk, the protocol is built around sparse checkouts, which hold only the directories the client asks for, and virtualized checkouts, which materialize files on demand. The client pays only for what it actually reads.
Changesets instead of commits
The unit of work in Scion is a changeset, an entry in a write-ahead log. A git commit points to a whole tree. A changeset instead lists the files that changed relative to its first parent, with content-addressed pointers to the compressed file contents in blob storage. Content-addressed means each object is stored under a key derived from its contents, so it never changes once written. Changesets are created on the server, so nothing gets pushed. The design rule is that the cost of a commit scales with the size of the change, not the size of the repo.
Refs, git’s pointers such as branches and tags, are discouraged except for main and release branches, because global state that every server must agree on is a scaling problem. Where refs exist, moving one is a compare-and-swap on a single Spanner row, separate from creating changesets. There are no packfiles, git’s compressed bundles of objects, so the repository needs no maintenance. No server holds a fully materialized copy of the repo.
Questions a list of changed files can’t answer quickly, such as who last edited a line or which commits touched a file, go to what Anthropic calls derived data: blame and path-history structures and skip lists for the commit graph. Each type is defined recursively from a changeset’s parents. Each can be computed eagerly or deferred, and each can be reworked without touching the client, which never sees these internals. The team has added new types several times, including indices for copy detection and path-based file search.
Because stored data never changes, any server can cache it without coordinating with the others. Anthropic describes its small fleet of Scion servers as essentially large caches that can also compute derived data and write it back to Spanner. Fetching works the same way. Git’s negotiation starts from what the client already has. Scion’s client asks only for the trees and blobs it wants, recursively from a root tree, so any cache tier can serve each request. Transfers are resumable because no single multi-gigabyte packfile comes back, and Anthropic says the setup needs significantly less CPU than git servers. On fleet nodes, a scion-daemon process stores objects for every job on the machine.
Source control, builds and CI
Anthropic names the new bottleneck as developer infrastructure built for human scale: source control, builds and CI. Scion was only one of the systems built in those five months. The same period produced a code review surface called Antique, code search, a source control IAM system and new ways to land large amounts of reviewed code. In September, Anthropic described its CI test selection service running out of headroom: three successive fixes bought it 70 days, then 29 days, then less than a day, as CI jobs grew 25x over six months. Scion looks like the same failure one layer down. Each fix to human-scale tooling is quickly used up by more agent output, which is what Anthropic’s own forecast predicts.
The company presents Scion as a case study in that loop. Claude’s ability to write code, the post says, “was both what put us in this situation in the first place and how we were able to quickly build a high-quality, scalable system to deal with it.”
Up next
Gemini 4 Argon’s 1M tokens now cover prompt and answer, Video
“Unified 1 million input/output token limit” is how Google now describes Gemini 4 Argon’s budget, so 800,000 tokens of code leave just 200,000 for the reply. Has a long prompt ever left your model too little room to answer?
Related stories
- Anthropic’s CI buckled after Claude wrote 80% of the code
- OpenAI’s Pando cut monorepo push latency nearly 5x
- Claude Code team hands most code reading to Claude
- Anthropic’s Scion copies Mononoke, says one of its builders
- Open-source Scion clones only the slice you ask for
- Bun’s half-million lines of Zig became Rust in eleven days
Comments
No comments yet. Be the first.
Join the conversation
Sign in to leave a comment. It appears after moderation.

