Why Anthropic Replaced Git With Scion: Reasons, Architecture and Lessons
Engineering deep dive · Version control
Why Anthropic Replaced Git With Scion: The Reasons, the Architecture, and What Every Developer Should Learn
AI agents now write code faster than Git was built to move it. Here's the full story of why Anthropic built its own version control system, how Scion works layer by layer, and which ideas you can use in your own repo today.
The short version
On October 13, 2026, Anthropic published an engineering post explaining that its monorepo no longer runs on Git. It runs on Scion, a version control system the company built itself in five months with a team of seven. Alongside it, the same team shipped a code review tool called Antique, code search, a permission system for source code, and new ways to land reviewed changes.
The reason is simple to state. Claude now writes so much of Anthropic's code that the bottleneck moved. Writing code got cheap. Storing it, checking it out, reviewing it and merging it did not.
Why Anthropic built Scion: 6 reasons
Most coverage stops at "Git couldn't keep up." That's true, but it hides the actual mechanics. Here are the specific pressures, as I read them in Anthropic's write-up.
1. The repository got physically huge
The main branch history alone is close to 100 GB, and even a compressed working copy is over 25 GB. Git's core promise is that every clone holds everything. At this size, that promise turns into a tax every machine has to pay.
2. Checkouts exploded
Anthropic runs roughly 25 million code checkouts a day just for CI, before counting developer machines, agent sandboxes and research jobs. If every one of those fetched the repository the naive way, it would add up to more than 600 petabytes of Git traffic a day. No mirror fleet survives that.
3. Merges grew 12x in four months
Every merge changes the tip of main. More merges means caches and snapshots go stale faster, and every downstream system has to catch up more often.
4. Almost every client is a machine that's always online
This is the insight I find most interesting. Git's design shines for humans working offline on laptops. But Anthropic's clients are mostly agents and CI jobs, which are online by definition. They were paying for an offline capability nobody used.
5. Git was already being used as a centralized system
Like most companies, Anthropic had one authoritative copy of the repo and treated everything else as a follower. So Git's decentralization was cost without benefit. The obvious question became: what would source control look like if you designed it for always-online agents from day one?
6. Tools needed answers, not repositories
A CI job that only wants to know "who last changed this line" or "how are these two commits related" shouldn't need a full clone. With Git, it usually does. Anthropic's automated bisect and revert pipelines only became practical once those questions could be answered by an API call.
The Git workarounds that stopped working
Anthropic didn't jump to a rewrite. It used every standard trick for big Git monorepos first: shallow clones, sparse checkouts, promisor remotes (partial clones), internal mirrors and repository snapshots ("seeds") stored in blob storage. At the peak, it ran several hundred Git mirrors.
Three things broke down. Seeds drifted further from the tip of main between refreshes. Mirrors hit the limits of their disks and memory. And operations that depend on history, like git diff and git blame, took more and more care to keep working on partial clones.
The six design principles behind Scion
Anthropic wasn't starting from zero. Google's internal system Piper and Meta's Sapling, especially its server Mononoke, had already proved many of these ideas. Anthropic credits Mononoke's data model as an inspiration. Scion's principles, in plain English:
| Principle | Git assumes | Scion assumes |
|---|---|---|
| Connectivity | Clients work offline with a full copy | Clients are always online and fetch on demand |
| Who does the work | Every client can be a full server | The server does history, blame, commits, merges and rebases. The client stays thin. |
| Access for tools | Tools need a local clone or a vendor API | Every query the client uses is also a public internal API |
| Scaling | Scale by copying the repo (mirrors) | Data is distributed and every component scales horizontally. No full copy exists anywhere, even on the server. |
| Commits | Commit locally, then push | Commits happen on the server, cost scales with the change size, and they're lock-free |
| Working copy | Required | Optional, sparse by default, and can be virtualized |
Scion system architecture, layer by layer
Here's how the pieces fit together, from the agent on a CI node down to the storage layer.
The scn client
Thin by design. It keeps a bounded local cache, lays files out on disk, watches for file changes, and gives people and agents a friendly interface. It computes very little on its own, which is exactly why it needs so little data.
scion-daemon (one per machine)
Jobs on the same node mostly need the same files, so one daemon stores objects for all of them. It boots from a regularly refreshed snapshot, then only talks to its regional cache.
scion-cache (one tier per region)
These servers stream trees and blobs straight from memory, already in the format the daemon expects. They don't compute what a client is missing and don't do delta compression, so they're cheap to run. Anthropic reports a hit rate above 99% at every tier.
scion-server (authoritative)
A small fleet that answers every source control question: changesets, diffs, merge bases, blame, history. Because all data is content-addressed and never changes once written, any server can cache anything without coordinating with the others. Think of them as big caches that can also compute.
Storage: Spanner and blob storage
Changeset metadata lives in Google Cloud Spanner. File contents live compressed in cloud blob storage. Moving a ref, like main, is a single compare-and-swap on one Spanner row, kept separate from creating commits.
The data model: changesets vs Git commits
Scion's unit of work is a changeset, an entry in a write-ahead log. It holds most of what a Git commit holds, with one key difference in how it points at files.
A changeset alone can't quickly answer "who last edited this line?" So Scion builds extra structures from the changesets: blame indexes, path history and skip lists for the commit graph. Anthropic calls all of this derived data, and every type is computed the same recursive way: its value for a changeset comes from its values for that changeset's parents.
That one mechanism pays off three ways. New index types are easy to add. Each type can be computed eagerly or lazily. And because clients never see these internals, the team can optimize them without touching the client. They've added new types several times since launch, such as indexes for copy detection and path search.
How a Scion checkout actually works
Git's fetch starts with negotiation: the client tells the server what it already has, and the server computes a packfile of what's missing. That's CPU-heavy on the server and produces one giant response. Scion turns it around.
Many jobs skip the checkout entirely. A CI step that needs a diff between a commit and its merge base just asks the server. A lot of write workloads also work purely through the API.
Results in numbers
| Metric | Before (Git + mirrors) | After (Scion) |
|---|---|---|
| Infra CPU and memory | Several hundred mirrors | 200x smaller footprint |
| CI and research checkouts | Minutes | Seconds (about 100x faster) |
| CI CPU capacity | Baseline | 25% freed up |
| Cache hit rate | N/A | Over 99% at each tier |
| Repo maintenance (repacking) | Required | None, since there are no packfiles |
How Claude helped build the system that replaced Git
There's a nice irony here. Claude created the problem by writing so much code, and Claude also helped solve it.
The team had hand-written the first pipeline that imports Git history into Scion. When an early internal snapshot of Claude Mythos Preview arrived, they asked it to rewrite the pipeline with no extra guidance. Its version used 20x less memory and ran 4x faster, while keeping all the hidden rules about ordering and data structures intact.
The engineers on the project now rate Claude as better than themselves at writing code. But their role didn't disappear. They owned the architecture and the trade-offs, and very often their job was to tell Claude "no." Two examples from the post: some systems tried to find when a change merged by scanning the whole commit log instead of asking the code review tool, and an overly cautious automated review pushed Claude toward unnecessary validation. Humans still review every change, but they focus on its intent rather than reading every line.
Lessons that go beyond source control
Small teams can now do multi-year projects in months
Seven people built Scion, Antique and about half a dozen related systems, then migrated everything in five months while merge volume grew 10x. Projects like this used to take years and much larger teams.
Quality went up, not down
Because Claude can write so much code, the team built hermetic simulations of every tricky infrastructure interaction, plus fuzzing and rate limiting. Anthropic calls Scion one of its best-tested codebases.
Security can be finer-grained in a monorepo
Scion supports permissions on individual directories, so sensitive code stays protected without splitting the monorepo. Antique can tell a comment-only change from a sensitive logic change, so human reviewers spend time where it matters.
"Superfan" agents watch the system
Using Claude Tag in Slack, the team gave individual Claude agents a single component each to obsess over, with access to telemetry and logs. These "superfans" catch subtle, unusual issues that fixed alert thresholds miss.
The merge queue might be a human-era idea
When hundreds or thousands of changes can land while tests run, a global lock on the merge queue stops making sense. Anthropic moved toward testing after merge and before deploy. Concurrent changes sometimes conflict, but Claude usually fixes them faster than a person would notice them.
What you can apply to Git today
Anthropic is clear that Scion isn't a general Git replacement and won't be released. It only makes sense for enormous monorepos with tens of thousands of engineers or swarms of agents. But Anthropic expects this class of problem to become common within six to twelve months, and many of the ideas map onto Git right now.
1. Make CI checkouts lighter
# Only the latest commit, no file contents until needed
git clone --depth=1 --filter=blob:none --no-checkout https://github.com/your-org/your-repo.git
cd your-repo
# Pull only the folders this job needs
git sparse-checkout init --cone
git sparse-checkout set apps/web packages/ui
git checkout mainFor large repos, Git's built-in scalar command sets up many of these optimizations for you.
2. Ask the server instead of cloning
If a job only needs metadata (changed files, a diff, who touched a line), use your platform's API instead of a checkout. The GitHub REST API and GitLab Repository API cover a lot of these cases.
3. Prepare for agent-scale pull requests
If you use Claude Code or other coding agents, PR volume can jump quickly. Set up a merge queue, use CODEOWNERS for sensitive folders, and add automated checks so humans review intent, not every line.
4. Keep branches few and short-lived
Scion discourages most refs for scaling reasons. For smaller teams, trunk-based development with short-lived branches gives a similar benefit: less shared state and fewer painful merges.
5. Watch what Git platforms do next
Anthropic wants GitHub, GitLab and the open source community to adopt the transferable parts: richer server-side RPCs (maybe standardized across hosts), a new negotiation protocol, and sparse and shallow features that work well together. If that happens, most teams get Scion's benefits without leaving Git.
My take as a full stack developer
Most of my client work lives in normal-sized Next.js and eCommerce repos, and Git is nowhere near its limits there. What changed my thinking is the direction. With AI coding tools, my own PR count already goes up every month. The lesson I'm taking from Scion is to treat CI time, review time and merge conflicts as the real costs, not typing time. Lighter checkouts and better review rules are cheap to set up now and pay off fast.
Glossary
| Monorepo | One repository holding many projects or a whole company's code. |
|---|---|
| Changeset | Scion's version of a commit. It stores only the files that changed. |
| Derived data | Indexes such as blame and path history, computed from changesets. |
| Content-addressed | Data stored under a hash of its contents, so it never changes and can be cached anywhere. |
| Sparse checkout | Putting only selected folders on disk. |
| Virtualized checkout | Files appear present but are downloaded only when read. |
| Packfile | Git's compressed bundle of objects. Scion has no equivalent. |
Frequently asked questions
What is Anthropic Scion?
An in-house, server-centric version control system that replaced Git in Anthropic's monorepo. It was announced on October 13, 2026.
Why did Anthropic replace Git?
Daily merges grew from about 2,500 to over 30,000 in four months, the repository's history reached about 100 GB, and CI ran around 25 million checkouts a day. Git's offline-first, full-copy design made that expensive, even with hundreds of mirrors.
Is Scion open source? Can I download it?
No. Anthropic says it would be hard to package in a way that helps other companies, because it needs its own code review, code search and CI. It's sharing the design ideas instead.
What is Antique?
Anthropic's internal code review tool, built by the same team alongside Scion. It supports rules that separate low-risk changes from sensitive ones.
Is Scion based on Google Piper or Meta Sapling?
It isn't a fork of either, but Anthropic credits both as prior art. In particular, Meta's Mononoke server pioneered many of the techniques Scion uses.
Should my team stop using Git?
Almost certainly not. Scion solves a problem very few teams have today. Start with shallow and sparse checkouts and better PR workflows.
References
- Anthropic Engineering: Redesigning source control at Anthropic (primary source)
- Sapling SCM by Meta and its Mononoke server
- Piper (Google's source control system)
- Git docs: partial clone · sparse-checkout · scalar
- Analytics India Magazine coverage
- Developers Digest: applying the lessons to your repo
Prefer a shorter read in your language? Read the developer guide on my portfolio, available in English, Urdu, Spanish, Hindi, Russian and German.
Need a developer who understands modern AI workflows?
I'm Zubair Hussain, a Full Stack Developer. I build fast Next.js apps, eCommerce stores and AI-powered products, and set up CI that doesn't slow your team down.
Hire Me View my portfolio →
コメント
コメントを投稿