Anthropic replaced git with Scion, version control built for AI coding agents

Writing code stopped being the bottleneck

According to an engineering post from Anthropic, generating code is no longer what slows the company down. Claude can now run research loops on its own, fine-tune complex programs and stand up new services faster than the surrounding tooling can absorb the output. The constraint has shifted to infrastructure built for human-paced work: version control, builds and CI.

The scale is stark. Anthropic says it averaged about 2,500 merged changes per day in May 2026 and passed 30,000 per day by September, and it expects the curve to keep climbing because the appetite for landing code is effectively unbounded: remove one constraint and more code simply flows through.

To keep up, the company built Scion, an in-house version control system, and finished moving its monorepo off git in five months. In the same period it also shipped a code review surface called Antique, code search, a source-control IAM layer and new methods for landing large volumes of reviewed code.

Where git broke down

Anthropic is upfront that its workload is unusual, since it relies on Claude more heavily than almost any other company and therefore hits the limits of human-scale tools first. Even so, it expects other organizations adopting AI coding tools to reach the same pressure points before long.

The numbers explain why. The history of the main branch alone is close to 100 GB, a compressed working copy exceeds 25 GB, and CI performs on the order of 25 million checkouts per day before counting developer machines, agent sandboxes and research jobs. Fetched naively, that would translate into more than 600 PB of git traffic each day.

Anthropic tried the standard remedies: shallow clones, sparse checkouts, promisor remotes, internal mirrors and snapshot seeds kept in blob storage. At peak it ran several hundred mirrors. That bought time but became harder to operate as the merge rate climbed, with seeds drifting behind the tip of main between refreshes and history-dependent operations such as diff and blame growing fragile on partial clones.

The turning point was a realization: like most companies, Anthropic was already running git as a centralized system with a single authoritative copy, while nearly all of its clients were agents and jobs that are online by definition. The properties that make git strong for offline, distributed work were working against scalability. So the team asked what source control would look like if connected clients were the starting assumption.

The principles behind Scion

Drawing on prior art such as Google's Piper and Meta's Sapling, Anthropic built Scion around a handful of ideas:

• Clients are assumed to be online. The protocol centers on a reachable server, with clients fetching data when they need it rather than holding a full copy.
• Client and server are asymmetric. The server answers history and blame questions, creates commits and performs merges and rebases; the client keeps a bounded local cache, lays out working files, watches the filesystem and does very little computation itself.
• Source control doubles as a service. Every query the client can issue is also exposed via an API, so CI jobs and internal tools often skip a local repository entirely. Anthropic notes that its automated bisect and revert pipelines would not be practical at scale without this cheap programmatic access.
• Everything scales horizontally. Repository data is distributed, components scale independently, no complete copy of the repo exists in any one place, not even on the server, and there are no packfiles, so repository maintenance disappears.
• Commits are cheap, incremental and lock-free. Commits, rebases and merges happen server-side, so there is nothing to push, and their cost scales with the size of the change rather than the repo. Refs such as branches and tags are discouraged outside the main and release branches, since globally shared state is a looming scaling problem.
• Working copies are optional and sparse. Jobs that only need a diff can ask the server for it, and many write workloads can operate purely through the API. When files on disk are required, sparse and virtualized checkouts mean clients only pay for what they actually read.

Inside the system

Scion's unit of work is a changeset, recorded as an entry in a write-ahead log and carrying most of what a git commit would. Anthropic frames the project as a case study in AI's dual role: the same coding capability that overloaded its infrastructure also let it build a scalable replacement quickly.

Why it matters

Scion is one of the clearest signals yet that agentic coding does not just accelerate development, it reshapes the toolchain. Mainstream version control assumes a human at a keyboard, an offline-capable clone and a branch-heavy workflow. When always-online agents author and land tens of thousands of changes a day, those assumptions invert and the infrastructure built on them becomes the limit. Anthropic says its situation is extreme today but believes the same pressure points are coming for other heavy users of AI coding tools. With Piper and Sapling as precedent for very large monorepos, Scion is an early example of source control redesigned agent-first, and a preview of what other stages of the development lifecycle may need to rethink next.