Why Git Broke at 30,000 Merges a Day: Inside Anthropic's Scion Architecture

The Day Version Control Hit the Agentic Wall

For twenty-one years, Git has been the undisputed bedrock of software engineering. Designed by Linus Torvalds in 2005 for the Linux kernel, Git was built on two foundational premises:

1. Decentralization: Every developer machine holds a full, self-contained clone of the entire repository history, capable of computing diffs, blames, and checkouts completely offline.
2. Human Cadence: Commits and merges happen at human speed. Even at high-velocity tech companies, developers rarely merge more than a handful of pull requests per engineer per week.

In 2026, those two premises did not just bend—they violently shattered.

At Anthropic, software development underwent an irreversible phase shift. Autonomous AI coding agents powered by Claude began executing research iterations, writing unit test suites, micro-optimizing algorithms, and shipping services around the clock. In May 2026, Anthropic's monorepo averaged roughly 2,500 merged changes per day. By September, that number skyrocketed past 30,000 merges per day.

The resulting strain on traditional developer infrastructure was catastrophic. Anthropic's main branch history alone reached 100 GB, with compressed working copies exceeding 25 GB. Between automated CI test runners, agent sandboxes, and research pipelines, the fleet performed 25 million code checkouts every single day.

If handled naively via standard Git protocols, that load would have generated over 600 petabytes of Git network traffic per day. Even after operating hundreds of internal Git mirror servers, shallow clone daemons, and pre-seeded blob storage snapshots, the infrastructure was buckling. Git had become the primary bottleneck to company progress.

Anthropic's response was radical: a seven-person engineering team spent five months building Scion&source=gmail&ust=1793150734285000&sa=E, a completely in-house version control system, and migrated their entire monorepo off Git permanently.

The Core Flaw: Offline Assumptions in an Always-Online World

When the Anthropic team diagnosed why Git failed, they identified an architectural mismatch hiding in plain sight: Git treats every client as a peer server that might lose internet connectivity on an airplane.

Yet in an agentic organization, 99.9% of all clients checking out code—CI runners, automated bisect workers, deployment bots, and autonomous coding agents—are online by definition. They never disconnect.

Forcing millions of always-online cloud sandboxes to negotiate complex object packfiles, resolve delta-compressed packs locally, and maintain long-lived commit graphs is massive architectural waste.

Scion inverted this philosophy through six radical architectural shifts:

1. Client-Server Asymmetry

In Git, the client computes diffs, computes merge bases, and walks commit graphs. In Scion, the client is intentionally dumb: it maintains a bounded local object cache, lays out files on disk, and provides a CLI (scn). The server cluster handles all heavy lifting: calculating diffs, running rebases, evaluating merges, and generating file blame.

2. Changesets Over Commits

In Git, a commit is a pointer to a complete root tree of the repository. In Scion, the core unit of work is a changeset—an entry in an append-only, write-ahead log. A changeset records only the list of files modified relative to its first parent, accompanied by content-addressed pointers to compressed blobs in object storage:

// Conceptual representation of a Scion changeset
message Changeset {
  bytes id = 1;                    // Content-addressed SHA-256
  bytes first_parent_id = 2;       // Trunk merge base
  repeated FileDelta modified = 3;  // List of modified file paths and blob hashes
  int64 timestamp = 4;
  string author = 5;
  string commit_message = 6;
}

Because a changeset does not store global state, creating a commit or landing a change requires zero packfile generation, zero cross-server locking, and zero branch ref movements. Moving the main pointer is simply a single Compare-And-Swap (CAS) transaction on a Google Cloud Spanner row.

3. Server-Side Derived Data Pipelines

Because changesets only store deltas, they cannot natively answer questions like "Which commit introduced this bug on line 45?" To solve this without client-side graph traversal, Scion builds derived data structures—such as path-based file history, file blame matrices, and commit-graph skip lists—asynchronous background pipelines. Each derived data type is computed recursively from parent changesets, cached server-side, and exposed via high-speed gRPC APIs.

The 200x Tiered Checkout Engine

The most demanding operational challenge was materializing 25 million checkouts per day without melting storage networks. Scion replaced Git's packfile negotiation with a tiered, content-addressed streaming architecture:

1. scion-daemon: A node-level daemon residing on every Kubernetes host. When multiple CI runners or agent sandboxes on the same physical host request code, they pull from scion-daemon's local shared cache over a Unix domain socket.
2. scion-cache: A regional cluster of in-memory caching servers. They stream immutable file trees and blobs directly from RAM in the exact disk format the client requires, eliminating the need to compute delta-compression on the fly.
3. scion-server: The authoritative tier backed by Google Cloud Spanner and cloud object storage, queried only when a regional cache misses.

Because every object is content-addressed and immutable, every tier maintains a cache hit rate exceeding 99%. Furthermore, Scion supports virtualized and sparse checkouts natively: an agent testing a backend authentication handler only downloads the services/auth directory, materializing files lazily on demand.

The operational results are staggering:

• 200x reduction in CPU and memory infrastructure footprint compared to the previous Git mirroring fleet.
• Two orders of magnitude faster checkouts (dropping from minutes to sub-second spans).
• 25% CPU capacity reclamation across Anthropic's entire CI compute farm.

The Meta Lesson: Building Software When Agents Out-Code Humans

The most profound takeaway from the Scion migration is how it was built. A tiny team of seven engineers designed and deployed an enterprise-grade version control system, code review platform (Antique), and IAM engine in just five months—a timeline that would historically require fifty senior engineers working for three years.

Anthropic achieved this because Claude was heavily utilized to design, test, and write the code. When an early handwritten prototype of the Git ingestion pipeline proved sluggish, the team gave the codebase to an early internal snapshot of Claude Mythos Preview; with no specific architecture instructions, the model rewritten the pipeline to be 4x faster while consuming 20x less memory.

Yet, Anthropic's engineers emphasized that their role was more critical than ever. In an agentic environment, an engineer's primary responsibility shifts from typing code to:

• Enforcing System Constraints: Telling the agent "no" when it attempts to solve problems with brute-force workarounds (such as parsing commit logs linearly instead of using structured review APIs).
• Rejecting Myopic Over-Engineering: Pruning excessive validation layers that agents generate during overly defensive adversarial reviews.
• Defining Invariants: Setting clean data contracts, immutability boundaries, and failure isolation tiers.

What This Means for Every Software Team

Anthropic is candid that Scion is an internal system built for a unique, extreme workload. Most teams merging fifty PRs a week do not need to replace Git today.

However, as tools like Cursor, Claude Code, and autonomous coding agents become standard across startups and enterprises, every engineering team's merge velocity will surge by 5x to 20x over the next twelve to eighteen months. The developer tools built for human typing speed—branch-locking merge queues, monolithic CI checkouts, and local Git history—are the next major bottlenecks waiting to blow up.

Git was the tool of the human software developer. The next generation of version control will be built for fleets of autonomous agents that never sleep, never work offline, and never stop shipping.