Anthropic Builds Its Own Source Control After AI Agents Outgrow Git

Anthropic has moved its internal monorepo off Git and onto a version control system it built from scratch. The reason is simple. Its AI agents now write code faster than Git-based infrastructure can handle it.

In a post on its engineering blog, the company said it averaged about 2,500 merged code changes a day in May 2026. By September, it was merging more than 30,000 a day. Coding stopped being the bottleneck. Source control took its place.

The new system is called Scion. A team of seven engineers built it, along with a code review tool called Antique and several related systems. They finished the migration in five months.

Why Git Stopped Fitting

Git is decentralized by design. Every clone is a full repository that can compute diffs, read history, and check out any revision offline. That works for most teams. It breaks down when the repo is huge, and most clients are machines.

Anthropic’s main branch history is close to 100 GB. A compressed working copy is more than 25 GB. The company runs about 25 million checkouts a day for CI alone, before counting developer environments, agent sandboxes, and research jobs. Fetched naively, that would mean more than 600 PB of Git traffic every day.

The team tried the standard fixes: shallow clones, sparse checkouts, promisor remotes, snapshots in blob storage and internal mirrors. At its peak, it ran several hundred Git mirrors. That bought time. But the setup got harder to run as merge volume climbed.

Then the team noticed something. Like most companies, it used Git as a centralized system with one source of truth. Nearly all its clients were agents and jobs that were always online. Git’s biggest strength, offline work, wasn’t helping. It was getting in the way.

Built For Clients That Never Go Offline

Scion flips the model. The server does the heavy lifting: commits, merges, rebases, blame, and file history. The client keeps a bounded local cache, lays out files, and tracks changes. It needs far less data on disk.

The client also exposes every query through an API, so many CI jobs don’t need a local copy of the repo. A job that needs a diff just asks the server. Anthropic says its automated bisect and revert pipelines wouldn’t be practical at scale without that access.

Other design choices follow the same logic. Commits happen on the server as “changesets” that record only what changed, so their cost scales with the size of the change, not the size of the repo. Branches and tags are discouraged, because global state that every server must agree on becomes a scaling problem. Checkouts are sparse or virtualized, so a job only pulls the files it reads.

All data is content-addressed and never changes once stored. Any server or cache can answer a request without checking with the others. Scion uses three tiers: a daemon on each node, regional caches, and authoritative servers backed by Spanner and cloud storage. Anthropic says each tier holds a cache hit rate above 99%.

The company reports big gains. Scion uses 200 times less CPU and memory than the old Git mirror fleet. CI and research checkouts now take seconds instead of minutes. And CI got back 25% of its CPU capacity.

“Source control has joined the fight over agent-driven software delivery,” said Mitch Ashley, vice president and practice lead for CIO & Technology Buyers and Software Lifecycle Engineering at The Futurum Group. “Anthropic building Scion and NVIDIA’s deal for Hugging Face show AI leaders treating the place where code and models live as infrastructure they need to own, after a decade in which most companies handed it to GitHub.”

Prior Art, Plus An AI Assist

Custom systems for giant monorepos aren’t new. Google described a repository of roughly two billion lines of code across nine million source files back in 2016, run on its Piper system. Meta spent about a decade building Sapling because public source control tools couldn’t handle a repo of its size. Anthropic says it built Scion with their lessons in mind.

What’s different is the speed. Claude wrote most of the code. In one example, an early internal build of Claude Mythos Preview rewrote a handwritten ingestion pipeline. Anthropic says the new version used 20 times less memory and ran four times faster.

The engineers’ role changed, too. Everyone on the team said Claude now writes code better than they do. But they still owned system design and trade-offs. Often, their job was to tell Claude “no.” One example: agents that tried to brute-force a lookup by scanning the commit log instead of asking the code review tool. Reviewers now check each change’s intent rather than reading every line.

The team also runs Claude-based monitors it calls “superfans.” Each one watches the telemetry for a single component and flags subtle problems that standard alerts miss.

Rethinking the Merge Queue

The bigger lesson for DevOps teams may be what comes next. Anthropic says a traditional merge queue with a global lock doesn’t hold up at agent scale. When thousands of changes can land while tests are still running, CI’s meaning starts to shift. The company now leans on automated testing post-merge and pre-deploy. Conflicts happen. Claude usually fixes them fast.

That’s a big change for most shops. “Most enterprise pipelines still assume a human reviews each change before it merges,” Ashley said. “Teams adding coding agents should track merge volume now and plan for testing, rollback, and approval records that run after the merge.”

Not a Git Replacement

Anthropic is clear that Scion isn’t for everyone. It only makes sense for truly massive monorepos with tens of thousands of engineers or swarms of agents. It also requires its own code review, search, and CI. The company doesn’t plan to release it.

Instead, it wants to share ideas with GitHub, GitLab, and the open source community. Git servers don’t have to work like Git clients. Forges could offer richer server-side APIs. Fetch negotiation could change. And Git’s sparse and shallow features could be made to work better together.

Anthropic expects more teams to hit these limits in the next six to 12 months. Most won’t build their own system. But if agents are writing more of your code, it’s worth asking where your pipeline will break first. It may not be the build. It may be the repo.