Anthropic Replaces Git with Scion: Architectural Lessons from 30,000 AI Agent Commits Per Day

Title

Anthropic Replaces Git with Scion: Architectural Lessons from 30,000 AI Agent Commits Per Day

Meta Description

Anthropic replaced Git with its own centralized version control system Scion, responding to agent commits surging from 2,500 to 30,000 per day. This article breaks down Scion's derived data architecture, server-side materialized checkout flow, the Antique code review system, and the failure modes and migration strategy of centralized source control.

Article Content

Anthropic swapped its version control system from Git to a self-built centralized system called Scion. What triggered this migration wasn't developer experience, but commits surging from 2,500 to 30,000 per day—a jump that directly corresponds to the internal deployment of Fable and Mythos-level models. Claude is now the heaviest user of this source infrastructure, and Scion was designed from the start on the assumption that "agents are always online."

This isn't a story about whether a tool is good or bad, but about how the speed of agent-generated code has punched through the underlying assumptions of distributed version control.

Why Git Couldn't Keep Up

Git's distributed model rests on several premises: developers work offline, clone full repositories, and merge infrequently. Anthropic's workload inverted every single one of these premises.

According to data disclosed by its engineering team, the system handles 25 million checkouts per day, distributed across CI pipelines, agent sandboxes, and research tasks. The main branch history alone is 100 GB, and each checkout's compressed working copy is about 25 GB. If you followed a naive Git traffic model, daily traffic would reach 600 PB.

The bottleneck isn't storage—it's the cost of materializing full working copies for ephemeral compute. Every CI job, every agent sandbox, every research experiment needs a clean checkout, and Git's object model requires you to fetch and decompress the entire history graph just to get a working tree.

Claude runs in a data center—it doesn't need to write code on an airplane. Anthropic's engineers realized they had been paying the full complexity cost of distributed version control for a feature that its primary user would never touch.

Derived data is the core concept of this design. It refers to computation results that the server precomputes and caches for each commit—such as complete tree snapshots, expanded blob sets, and directory indexes. In Git, this data would normally be computed on demand by the client (decompressing objects, rebuilding trees, checking out files), whereas in Scion it's precomputed and stored centrally.

The trade-offs and benefits of this approach are both clear: the server needs extra storage and precomputation compute power, but the client gets to skip expensive steps like commit graph traversal, object decompression, and tree rebuilding. For workloads with frequent commits, massive checkout volume, and distributed, heterogeneous client compute, consolidating complexity into a controllable centralized server is an asymmetric optimization.

Scion Architecture: Derived Data and Server-Side Materialization

Scion is a centralized system, designed with reference to Google Piper and Meta's Sapling/Mononoke. The core idea is derived data: the server precomputes and caches expensive operations, and clients only fetch the portion they need.

Key Design Trade-offs

Component	Git Model	Scion Model
Repository structure	Distributed, full clone	Centralized, partial checkout
Working copy materialization	Client decompression	Server-side derived data
Offline support	First-class citizen	Not supported
Checkout cost	O(history size)	O(number of changed files)
Primary users	Human developers	AI agents + humans

The server maintains precomputed snapshots for each commit. When a client requests a checkout, it only fetches the files needed for that revision—decompression, incremental application, and tree construction are all handled server-side.

This is essentially trading server compute for client bandwidth and storage. For Anthropic's workload, this exchange is extremely asymmetric: they have centralized infrastructure, and what they need is to drive down the cost of each checkout.

Checkout Flow

# Conceptual illustration of Scion checkout (not the actual implementation)
def checkout(commit_sha, sparse_paths=None):
    # Server side: query the precomputed tree snapshot
    snapshot = derived_data_cache.get(commit_sha)

    if sparse_paths:
        # Fetch only the requested subtrees
        files = snapshot.filter(sparse_paths)
    else:
        files = snapshot.all_files()

    # Stream file contents to the client
    for path, blob_id in files:
        yield (path, blob_store.fetch(blob_id))

The client doesn't decompress, doesn't walk the commit graph—it just requests a snapshot and streams file contents. All complexity is absorbed by the server.

Agent Commit Patterns and Code Review

Anthropic's commit velocity curve aligns closely with model release milestones. The jump from 2,500 to 30,000 per day happened after Fable and Mythos became available internally.

Agent-generated commits differ fundamentally from human commits:

• Higher frequency: Agents iterate fast and commit intermediate states more often
• Larger diffs: Agents refactor entire modules rather than making surgical small changes
• Less context: Commit messages are generated and don't carry institutional knowledge

To handle this volume, Anthropic built its own code review system, Antique. The system uses adversarial review—having Claude critique its own changes while other models flag potential issues.

The engineering team also pointed out a specific failure mode: adversarial review tends toward short-sightedness. Claude over-engineers in response to hypothetical concerns. Human engineers have to pull the agent back from "adding complexity for edge cases that will never happen." This is fundamentally a calibration problem: the agent doesn't know which concerns are real and which are paranoia—it needs human feedback to learn the difference.

Adversarial review refers to having a model (or a different instance of the same model) examine another model's output from the perspective of a fault-finder, thereby exposing issues that are easily overlooked in a single generation pass. In Anthropic's practice, Claude is asked to critique its own changes while other models flag potential risks in parallel, forming a multi-perspective cross-check.

This approach effectively catches missed boundary conditions and logic flaws, but its failure mode differs from human code review: the model lacks judgment about actual business priorities and real failure rates, making it easy to treat hypothetical concerns as must-fix issues. The result is that review feedback tends toward defensive over-engineering, and human engineers must continuously subtract, pulling the agent back from adding complexity for extremely low-probability edge cases.

Migration and Deployment

A team of seven built Scion from scratch and migrated Anthropic's entire codebase off Git within five months. The migration strategy had four phases:

1. Dual-write phase: All commits written to both Git and Scion simultaneously
2. Shadow mode: Scion handles read traffic, Git remains the source of truth
3. Cutover: Scion becomes the source of truth, Git is archived
4. Cleanup: Remove Git-specific tooling and workflows

The team avoided a big-bang migration, instead running both systems in parallel until Scion proved stable under production load.

Dropping offline support was a conscious trade-off. When asked about it, a Scion engineer said on Hacker News: "Since Claude is the heaviest user of Scion and it's necessarily online, this feature just isn't important to us." This is the clearest signal that Scion was designed agent-first, human-second.

Failure Modes and Operational Considerations

Centralized and distributed systems have completely different failure modes:

• Single point of failure: If Scion goes down, nobody can commit
• Blast radius: A bad server-side change instantly affects all clients
• Derived data staleness: A cache invalidation bug could return incorrect snapshots
• Scaling bottleneck: Server-side materialization cost grows with checkout volume

Anthropic's mitigations include redundant servers (multiple Scion instances behind a load balancer), canary deployments (server-side changes rolled out to a small percentage of traffic first), derived data validation (checksums and consistency checks on every snapshot), and horizontal scaling (add machines as checkout volume grows).

For its workload, this system is operationally simpler than Git, but it requires more infrastructure investment. You can't run Scion on a laptop.

Canary deployment refers to releasing server-side changes to a small fraction of traffic or instances first, then gradually expanding scope after observing that metrics are normal. For a centralized system like Scion, this mechanism is especially important because a bad server-side change affects all clients simultaneously—there's no buffer in a distributed system where local failures are isolated.

Combined with derived data validation (checksums and consistency checks on every snapshot), this can catch dirty data returned by cache invalidation or snapshot computation errors early. Together, these two mechanisms address the most dangerous failure mode of centralized systems: errors propagate globally and instantly, and are difficult to mitigate through local rollback.

Technical Conclusions

When to borrow Scion's architecture:

• Agent-generated commits dominate your workflow
• You have centralized infrastructure capable of running server-side materialization
• Checkout volume is high and working copies are large
• Offline workflows aren't a hard requirement

When not to:

• Human developers need offline access
• Your team is too small to maintain self-built infrastructure
• Commit volume is low enough that Git's overhead is acceptable
• You need compatibility with existing Git tooling

Anthropic's migration is a preview of what happens when agents become the primary users of development infrastructure. The tools we built for humans can't keep up with agent scale. For workloads where clients are always online and need fast, cheap checkouts, a centralized system with server-side computation is the more appropriate form.

The really interesting question isn't whether Scion is better than Git, but: as agent-generated code surpasses human-generated code, what other development tools need to be redesigned?

One-line Summary

Anthropic replaced Git with centralized system Scion after agent commits surged 12x.

Paragraph Summary

Anthropic replaced its version control system with a self-built centralized system, Scion, driven by commits jumping from 2,500 to 30,000 per day after internal deployment of Fable and Mythos models, combined with 25 million daily checkouts—punching through Git's distributed model assumptions. Scion draws on Google Piper and Meta Sapling/Mononoke, using derived data and server-side materialization to cut checkout cost from O(history size) to O(changed files), sacrificing offline support. Facing agent commit patterns of high frequency, large diffs, and low context, Anthropic built its adversarial review system Antique, but humans must calibrate its over-engineering tendency. A seven-person team completed the migration in five months via four phases: dual-write, shadow mode, cutover, and cleanup.