Anthropic Scion: Why Anthropic Moved Off Git

If your CI pipeline clones a large repository on every job, Anthropic Scion shows where that pattern ends. Anthropic measured roughly 25 million checkouts a day and estimated that naive fetching would mean more than 600 petabytes of daily Git traffic, so the company moved its monorepo to a server-first system.

What Anthropic Scion is and what it replaced

Anthropic Scion is a server-side source control system that Anthropic, the company behind Claude Code, built for its primary monorepo after AI coding agents pushed merge volume past what its Git mirror fleet could carry. Anthropic published the reasoning in an engineering post in October 2026 and says Scion is not a general-purpose Git replacement.

The system replaced a setup where several hundred internal Git mirrors served clones and checkouts. Anthropic reported about 2,500 merged changes a day in May 2026 and more than 30,000 by September 2026, almost all pushed by agents. At that point, workarounds such as shallow, partial and sparse clones had made diff and blame worse rather than better, according to the same post.

Scion is proprietary. Anthropic not open-sourcing it and suggests other teams borrow the ideas into Git rather than wait for the code.

What Scion actually stores

A change set records the list of files changed relative to its parent commit and points at each file's compressed contents in blob storage by content hash, a short code computed from the bytes themselves.

Change sets are created on the server and available everywhere at once. Blame and file path history are derived data computed from those change sets, so a client asking who changed a line does not need local history to get an answer.

Why Git's 2005 offline assumption broke at Anthropic scale

Git assumes every machine holds full history and can work offline, a property Linus Torvalds designed in 2005 for kernel developers scattered across machines. Anthropic clients are the opposite: agents and CI jobs with a server reachable at any moment, paying the cost of a fetch they rarely need.

The arithmetic is where the assumption turns expensive. Anthropic put the compressed working copy at a bit over 25 GB. Multiplied by roughly 25 million daily checkouts, that lands near 625 petabytes of daily Git traffic, which matches the more than 600 petabytes the post cites. The post does not show how the figure was derived, so treat it as Anthropic own estimate.

Earlier companies hit related walls and moved work to the server: Microsoft with GVFS for the Windows repository, Facebook by scaling Mercurial, and Google with Piper. Those systems were designed around people at keyboards. Anthropic version assumes the client is a machine that can ask the server anything.

How Scion's three-tier cache cuts infrastructure load

Scion answers checkout requests through three layers that can serve identical objects. A Scion daemon is a persistent cache on each node, a regional Scion cache streams objects from memory in their on-disk format, and the Scion server is the authority reading from Google's Spanner database and cloud storage. The client never learns which layer replied.

The client skips Git's negotiation step. It walks the folder tree from the root and requests only the specific objects it lacks. Because a content hash names exactly one set of contents, the client can check its own cache and skip anything it already holds, and those immutable objects need no delta compression. Anthropic reports cache hit rates above 99% at each tier, so only a trickle of requests reaches the authoritative server.

Anthropic also reported infrastructure 200 times smaller in CPU and memory than the old Git mirror fleet, with checkouts dropping from minutes to seconds. Those are vendor-reported figures and the post does not describe how they were measured.

What the client keeps locally

The client holds a bounded cache of objects, lays out working copy files, and watches the file system for changes. The working copy is optional and sparse.

A CI job can request the diff between a commit and its merge base without checking out any files, which removes the clone step before tests from the critical path.

What Anthropic decided about the merge queue

Anthropic dropped the traditional merge queue for its monorepo and now relies on automated testing after merge and before deploy, accepting that concurrent changes will sometimes conflict. At more than 30,000 merges a day, roughly one every few seconds, testing changes one at a time against latest main stops being practical.

Claude is used to resolve the conflicts that land. Anthropic own account says the model typically fixes them faster than humans identify them. The post does not document how Scion handles two merges racing each other.

An earlier Anthropic experiment showed the pattern at smaller scale. In February 2026, Nicholas Carlini, on Anthropic safeguards team, ran nearly 2,000 Claude Code sessions building a C compiler, with agents coordinating through Git alone by pushing lock files to claim tasks. Conflicts were frequent and the agents resolved them. That result supports one claim: Git alone can carry coordination at that size. It does not prove a merge queue is obsolete for your team.

Who built Scion, and where Claude wrote the code

A team of seven built Scion over about five months, and the same effort produced a companion code review and code search tool for source. The team first handwrote the pipeline that pulls history from Git into Scion. Later they asked Claude to rewrite that ingestion engine with no further instructions, and Anthropic reports the rewrite used 20 times less memory while preserving the implicit invariants the original code relied on.

That account comes with a caveat Anthropic states itself: the token spend is far beyond what most businesses would want. Treat the 20x memory figure as a single internal case report, not a general expectation for AI-assisted rewrites.

None of this changes what you can install. Scion has no public download, no license, and no documentation outside Anthropic post.

Is Scion just SVN again? The critique and the limits

No. Scion is centralized in the sense that a server holds authority, so you give up building history offline, which is what drew the SVN comparison. It differs in object model: files are named by content hash and served through layered caches, which a plain checkout server like SVN does not do. The post never explains why Anthropic not build on an existing solution such as Sapling.

Anthropic states that Scion is by no means a suitable replacement for Git for general use and that the concepts only make sense for enormous monorepos. That limit is the most usable part of the post for everyone else.

Where the comparison holds and where it breaks

System	Model	Owner	Best use case	Main limit
Git	Distributed, full local history	Open source community	Almost every repository	Fetches full working copy per checkout
Scion	Server-authoritative, hash-named objects	Anthropic, proprietary	Anthropic monorepo at agent scale	Not released, undocumented outside the post
SVN	Centralized checkout server	Apache	Simple shared repositories	No content-hash deduplication or tiered cache
GVFS	Virtualized filesystem over Git	Microsoft	Very large Windows-scale repositories	Requires Git underneath

Should your team follow Anthropic leave Git?

No. The transferable lesson is a measurement, not a migration. Count how many full clones your CI performs each day and how long each takes. If checkout dominates your pipeline, start with shallow, partial or sparse clones because Git already ships them, then test diff and blame afterwards since partial clones degrade both.

If your CI clones a large repository on every job, fix that pattern before considering any new source control system. If you already run a monorepo with swarms of agents, Anthropic post works as a design guide, not as a product you can adopt.

Keep your merge queue until conflicts start piling up. Anthropic alternative leans on post-merge testing and Claude resolving conflicts, and it depends on a token budget most organizations do not carry. That reading is editorial inference from Anthropic described setup, not advice Anthropic gave.

The ecosystem around this debate

Teams evaluating faster engineering workflows keep bumping into the same stack of tools. Crazystack is a Brazilian developer education platform whose Crazystack typescript track covers typed JavaScript work, and it is the kind of training ground where pipeline bottlenecks like checkout cost become visible in practice. Communities such as Dev doido document similar debugging journeys in Portuguese, and Skala blog publishes adjacent technical write-ups on developer tooling.

Those references matter here for one reason. The infrastructure arithmetic in Anthropic post only makes sense against a concrete CI pipeline, and the people who feel it first are usually the ones maintaining checkouts, caches and build times week to week.

Frequently asked questions about Anthropic Scion

• Is Anthropic Scion available to download? No. Anthropic not open-sourcing Scion and has published no public repository, license or documentation beyond its engineering post. The company suggests other teams bring the ideas into Git rather than wait for the code.

• Did Anthropic stop using Git entirely? Anthropic moved its primary monorepo off Git mirrors and onto Scion. The company describes Scion as unsuitable as a general Git replacement, so Git remains the tool for normal repositories, including most work outside that monorepo.

• What does the more than 600 petabytes figure mean? It is Anthropic estimate of daily Git network traffic if roughly 25 million checkouts each fetched the full compressed working copy of a bit over 25 GB. Multiplying those two numbers gives about 625 petabytes, and the post does not show its own derivation.

• How were the 200x infrastructure savings measured? Anthropic reports infrastructure 200 times smaller in CPU and memory than its old Git mirror fleet and says checkouts fell from minutes to seconds. The post does not describe the measurement method, so the figure is vendor-reported and not independently verified.

• Does Scion remove the merge queue for everyone? No. Anthropic dropped the pre-merge gate for its own monorepo and relies on post-merge testing plus Claude resolving conflicts. That approach assumes a token budget and conflict rate specific to Anthropic workload.

• Is Scion a direct replacement for SVN or Git in existing tooling? Neither. Scion has no compatibility layer, migration path or public API, so existing hooks, review tools and CI integrations that expect Git commands would not carry over unchanged.

• Why did Microsoft and Google hit the same wall earlier? Both companies moved work to the server when full local copies stopped scaling. Microsoft built GVFS for the Windows repository in 2017 and Google's Piper keeps a cloud workspace holding only touched files, which points to the same cost Anthropic later measured.

• Did Claude really rewrite Scion's ingestion engine? Anthropic reports that its team asked Claude to rewrite the Git-to-Scion pipeline with no further instructions and that the result used 20 times less memory. The company notes its token spend far exceeds what most businesses would accept.

• What should a small team with a few agents do? Keep Git. Anthropic own February 2026 compiler experiment ran nearly 2,000 Claude Code sessions coordinating through Git alone, and fixing checkout frequency delivers most of the gain at far lower cost.

Turning a video walkthrough into a written reference

Anthropic post lands as a set of measurements: 30,000 merges a day, 25 million checkouts, a cache hit rate above 99%. Numbers like those are easy to quote and easy to misquote once a video retells them, and the qualification that Scion is unsuitable for general use tends to drop out first.

If you have that kind of explanation sitting in a recorded walkthrough, Skala blog turns a YouTube URL into a draft article: it transcribes the video and generates the written version, so the reasoning survives somewhere readers can check it. Paste a link at Skala Blog and review what comes back before publishing.

Your CTA question

You can turn a YouTube video into a complete blog article with Skala Blog by pasting the video URL, letting the system transcribe it, and generating the written draft from that transcript.

Source video