Scion: Why Anthropic Replaced Git for a Monorepo Written by Agents

In May 2026, Anthropic merged about 2,500 code changes per day. By September: over 30,000 per day. Their engineering post makes a blunt claim: coding is no longer the bottleneck. Developer infrastructure built for human scale — source control, builds, CI — is.

Their answer was Scion, an in-house version control system. A team of seven built it and migrated the monorepo off git in five months.

Why Git Broke

Git is decentralized: every clone is a full repository that works offline. That is the right design for most repos. Anthropic’s monorepo is not most repos:

Main-branch history is almost 100 GB; a compressed working copy exceeds 25 GB.
About 25 million checkouts per day for CI alone, before developer environments, agent sandboxes and research jobs. Naively fetched, that’s 600+ PB of git traffic daily.
Workarounds (shallow clones, sparse checkouts, promisor remotes, several hundred internal mirrors, blob-storage seeds) bought time but got harder to operate as the merge rate grew.

The key insight: nearly all clients are agents and jobs that are online by definition. Git’s offline-first strengths were working against them.

Six Design Principles

Clients are always online. Fetch data on demand.
Client-server asymmetry. The server does history, blame, commits, merges, rebases. The client keeps a bounded object cache and lays out files.
Everything is an API. Bisect and revert pipelines become practical because CI needn’t hold a local repo to ask “who last changed this line?”
Horizontal scalability. No fully materialized copy anywhere, no packfiles, no repo maintenance.
Cheap, lock-free, server-side commits. Cost scales with change size, not repo size. Refs are discouraged except main and release branches.
Optional, sparse working copy. Many reads and writes skip checkout entirely; the rest use sparse or virtualized checkouts.

How It Works

Changesets. The unit of work is a changeset, an entry in a write-ahead log. It stores the files changed relative to its first parent, with content-addressed pointers to compressed blobs. No packfiles, no locks, no ref movement; moving a ref is a compare-and-swap on a single Spanner row.

Derived data. Blame, path history and commit-graph skip lists are computed from changesets through one generic, recursive mechanism. Each type can be eager or lazy, and can be optimized without touching the client.

Tiered caches. Because all data is content-addressed and immutable, any cache can answer any request. The scn client talks to scion-daemon on each node, which talks to regional scion-cache servers, which fall back to authoritative scion-servers backed by Spanner and cloud storage. Negotiation asks only for the trees and blobs the client wants — no multi-gigabyte packfile response, and sparse or virtual checkouts come for free.

The Numbers

Cache hit rate above 99% at every tier.
Infrastructure footprint 200x smaller than the old git mirror fleet (CPU and memory).
Checkouts two orders of magnitude faster — seconds instead of minutes.
25% CPU capacity win for CI alone.

Lessons for Agent-Scale Engineering

Small teams can move fast. Seven people shipped Scion, the Antique code review tool and half a dozen related systems while merge volume grew 10x.
A striking rewrite. A handwritten git-to-Scion ingestion prototype was rewritten by an early Claude Mythos Preview snapshot with no extra guidance: 20x less memory, 4x faster, with implicit ordering invariants preserved.
Engineers’ role shifts to saying “no.” The engineers rate Claude as a better coder than themselves, yet agents violated core constraints — for example, brute-force reading the commit log instead of asking the code review tool — and adversarial review sometimes drove over-engineering. Design judgment is the human contribution.

Takeaway

Most teams won’t hit these limits tomorrow. But if agents multiply your commit rate even 5x, the assumptions behind your CI checkouts, mirrors and review flow will start to strain. The transferable idea isn’t “drop git” — it’s to ask which of your tools assume a human at the keyboard, and design the server-side, API-first, cache-friendly version for clients that never go offline.

Source: Anthropic Engineering — Redesigning source control