Anthropic Scion: Why AI Agents Outgrew Git and What Replaced It

For two decades, Git has been the default answer to "how do we store and share code?" It powers almost every open-source project and most companies. So when Anthropic published Redesigning source control at Anthropic on October 13, 2026, explaining that it had moved its core monorepo off Git and onto a custom system called Scion, it landed as more than an infrastructure footnote.

The reason was not that Git is badly designed. It is that Git was designed for humans. Anthropic's engineers increasingly aren't the ones writing most of the code — autonomous agents built on Claude are. And agents use source control very differently.

The bottleneck, now, is all of the developer infrastructure built for human scale.

That line from Anthropic's post is the real story. Scion is what happens when an engineering organization takes that idea seriously.

Scion at a Glance

Why AI Agents Broke Git

Between May and September 2026, as internal adoption of coding agents like Claude Code accelerated, daily merges to Anthropic's monorepo grew more than tenfold — from roughly 2,500 to over 30,000 per day. Every one of those changes needs a checkout, a build, tests, and review.

The numbers Git had to absorb

• Repository size: the main branch's history was almost 100 GB, and a single compressed working copy exceeded 25 GB.
• Checkout volume: about 25 million CI checkouts per day — before counting developer environments, agent sandboxes, and research jobs.
• Network traffic: a naive fetch model at that volume would mean more than 600 petabytes of Git traffic per day.
• Mirror sprawl: at peak, Anthropic ran several hundred internal Git mirrors just to keep up, and they got harder to operate as the merge rate climbed.

Git's human-era assumptions

Git is a distributed system built on a simple premise: as Anthropic puts it, Git "assumes that clients work offline and need a complete copy of the repository." That made perfect sense for humans on laptops who pull occasionally, commit locally, and push a few times a day.

Agents break every part of that premise. They run in ephemeral sandboxes and CI jobs that start fresh, are always online, often need only a small slice of a huge monorepo, and produce changes around the clock. Cloning 100 GB of history so an agent can edit a handful of files is pure waste — multiplied millions of times a day. CI and agents were spending minutes simply getting a working directory.

Git wasn't broken. It was optimized for a workload that no longer dominated.

What Is Scion? An Agent-Native Version Control System

Scion flips Git's model. Instead of every client holding the full repository, the server holds the truth and clients fetch exactly what they need, when they need it.

1. Thin, always-online client (scn)

The client is called scn. Its protocol negotiates only the trees and blobs a client actually wants, which makes sparse and virtualized checkouts natural rather than an afterthought. An agent that needs three directories gets three directories.

2. Changesets instead of commits-plus-packfiles

Scion's unit of work is a changeset — an entry in a write-ahead log. Changesets are created server-side and record only the files that changed relative to the first parent, with content-addressed pointers to compressed blobs. There is no equivalent of Git's packfiles, so there is no repository maintenance to run.

3. Server-side merges — nothing to push

Every commit, rebase, and merge happens on the server, so in Anthropic's words "there's nothing to push." Anthropic also notes it has not replicated the industry-standard global repository lock on the merge queue; instead it leans on post-merge and pre-deploy testing. Concurrent changes can conflict, but Claude can typically fix those conflicts faster than humans can identify them.

4. Derived data computed on the server

Because changesets store only diffs, everything else — the commit graph, blame, path history, copy detection, path-based file search — is derived data, computed recursively from each changeset's parents and written back to storage. Anthropic mentions skip lists for the commit graph and dedicated structures for blame and path history, and each kind of derived data can be computed eagerly or deferred. Expensive history operations become fast server-side queries instead of local work repeated on every clone.

5. Spanner, blob storage, and enforced tiers

scn client (agent / CI / engineer)
        ↓
scion-daemon        one per node · shared object store
        ↓
scion-cache         regional · streams from memory · >99% hit rate
        ↓
scion-server        authoritative · merge, rebase, derived data
        ↓
Google Cloud Spanner (changesets, refs, derived data)
+ cloud blob storage (file contents)

File contents live in blob storage. Metadata lives in Google Cloud Spanner, where a ref update is simply a compare-and-swap on a single row. Refs are used sparingly, and tiering is strictly enforced so that a failure in one layer stays isolated. Each caching tier maintains a hit rate above 99%.

Scion vs Git: Side-by-Side

The Results: 200x Less Infrastructure

• ~200x smaller footprint — CPU and memory needs compared with the previous Git mirroring setup.
• Two orders of magnitude faster checkouts for CI and research — seconds instead of minutes.
• 25% CI CPU capacity reclaimed, simply by no longer burning compute on checkouts.
• >99% cache hit rate at each caching tier.
• Rich access control, with permissions down to individual directories.

Cheap, programmatic access to source control also unlocked companion automation that depends on it, such as automated bisect and revert pipelines.

How Claude Helped Build Scion

The most striking detail is the team size. A core team of seven engineers built Scion, the Antique code review tool, and about half a dozen related systems, then completed the full monorepo migration in five months — while merge volume grew roughly 10x underneath them. They worked with internal frontier models, including Claude Mythos Preview and Claude Tag.

Implementation and optimization

Claude Mythos Preview rewrote the Git-to-Scion ingestion prototype, producing a version that used 20x less memory and ran 4x faster while preserving the existing ordering and data-structure invariants. Claude also found performance fixes humans had missed, such as an ancestry query that wasn't using one of the available indexes.

"Superfan" agents for operations

Anthropic assigns dedicated Claude instances — Superfans — to individual components such as scion-daemon, scion-cache, and the Antique merge queue. Each one watches its component's telemetry and logs and surfaces subtle issues that conventional alerts might never fire on. It is a practical example of the always-on monitoring we describe in self-healing AI agents.

Why humans still mattered

Anthropic is candid that Claude was not autonomous here. Engineers supplied design judgment and frequently had to tell Claude "no" when it violated system constraints or over-engineered for hypothetical risks. Claude's adversarial reviews were useful but sometimes myopic, so humans steered them. Every change request is still reviewed by a person — but the review focuses on intent rather than reading every line.

The engineer's job shifted from writing every line to judging design intent and knowing when to say no.

That pattern — agents doing the heavy lifting inside a system of constraints, checks, and human approval — is exactly what we mean by an AI agent harness.

Standing on Sapling and Piper

Scion did not appear from nowhere. Anthropic credits Meta's Sapling — specifically its server, Mononoke, and its Bonsai data model — with pioneering many of the techniques Scion uses, and points to Google's Piper as prior art for huge, server-centric monorepos. What is new is the driver: those systems were built for tens of thousands of human engineers; Scion was built for agents.

Is Scion Open Source? Can You Replace Git With It?

No. Anthropic says plainly that Scion is not a general-purpose Git replacement and is hard to offer in a broadly useful form, because it is tightly coupled to Anthropic's own infrastructure. Instead, Anthropic is sharing its design thinking so others can apply parts of it within Git-based systems, and plans to work with GitHub, GitLab, and the open-source community.

Community engineers have already started experimenting — for example, the CarterT27/scion clean-room Rust implementation explores the architecture. Treat projects like this as learning tools, not drop-in production replacements.

Lessons for Engineering Teams (Even If You Stay on Git)

Few companies merge 30,000 changes a day. But many are about to see agent-driven code volume multiply. Scion's design offers lessons that apply inside a Git workflow today:

1. Measure the human-scale bottlenecks. Track checkout time, merge throughput, CI queue wait, and review latency — they move first when agents arrive.
2. Stop cloning everything. Use partial clones, shallow fetches, sparse checkouts, and shared object caches for CI and agent sandboxes.
3. Move expensive history queries server-side. Blame, ancestry, and code search are better served by indexed services than by every client.
4. Rethink merge queues. Global locks don't scale to agent volume; strong post-merge testing and fast automated fixes may.
5. Make source control programmable. Cheap API access powers automated bisect, revert, and agent workflows.
6. Redesign code review around intent. Humans can't read every line of agent output — they can judge whether the change does the right thing, within the right constraints.
7. Give agents operational roles. Component-level "Superfan" agents watching telemetry are a pattern any team can borrow, as long as they report to humans and are backed by solid AI observability.

Final Takeaway

Scion is not really a story about Git being obsolete. It is a story about where the bottleneck goes once AI agents make writing code cheap. At Anthropic, it went straight to source control — then to CI, then to code review.

Agents write code faster
        ↓
Human-scale infrastructure becomes the bottleneck
        ↓
Infrastructure gets redesigned for agents

Most teams will not build their own version control system. But almost every team adopting coding agents will eventually ask the same question Anthropic did: which parts of our developer infrastructure were quietly designed around the speed of a human typing?