---
title: "When Coding Agents Outgrow Git: Inside Anthropic's Scion Architecture"
description: "When daily monorepo merges jumped from 2,500 to over 30,000 between May and September 2026, Git became Anthropic's main bottleneck. Here is how a seven-person team replaced it with Scion in five months—and what platform teams can apply on standard Git today."
canonical: "https://zainahmed.net/blog/when-coding-agents-outgrow-git-anthropic-scion"
published: "2026-10-14"
---

# When Coding Agents Outgrow Git: Inside Anthropic's Scion Architecture

> Author: Zain Ahmed
> Published: 2026-10-14
> Read Time: 8 min read
> Category: AI & Tech
> Tags: Anthropic, Git, Coding Agents, Platform Engineering, Distributed Systems, CI/CD, Claude Code
> Canonical URL: https://zainahmed.net/blog/when-coding-agents-outgrow-git-anthropic-scion

## Excerpt
When daily monorepo merges jumped from 2,500 to over 30,000 between May and September 2026, Git became Anthropic's main bottleneck. Here is how a seven-person team replaced it with Scion in five months—and what platform teams can apply on standard Git today.

---

<div className="my-8 not-prose">
  <card className="border-primary/30 bg-primary/5 ring-1 ring-primary/10">
    <cardheader>
      <cardtitle className="text-primary font-bold">If You Only Read One Sentence</cardtitle>
    </cardheader>
    <cardcontent>
      Git assumes offline humans need a full copy of the repository; when always-online coding agents push 30,000 merges and 25 million CI checkouts a day, source control has to become a stateless, server-side API with tiered object caching.
    </cardcontent>
  </card>
</div>

Between May and September 2026, daily code changes merged into [Anthropic's central monorepo](https://www.anthropic.com/engineering/redesigning-source-control) rose more than twelvefold—from roughly **2,500 merges per day** to **over 30,000 merges per day**. Internal deployments of Claude Mythos Preview and Claude Tag shifted engineering work from writing individual patches to running continuous research, optimization, and service-building loops.

Coding speed stopped being the constraint. Source control, builds, and CI took its place.

To remove that bottleneck, a seven-person team at Anthropic—Nick G. alongside S.G., R.K., Dan C., Garrett H., Ben L., Colin M., and Joe P.—built an in-house version control system called **Scion** and a companion code review platform named **Antique**, migrating the entire monorepo off Git in five months. Their [engineering write-up](https://www.anthropic.com/engineering/redesigning-source-control) shows where human-scale infrastructure breaks under agent workloads and which pieces of that architecture you can replicate on standard Git today.

<datachart id="merges-growth"></datachart>

## Why Git Hit a Physical Wall at 25 Million Checkouts a Day

Git was designed in 2005 around distributed, offline-first work. Every clone is a self-contained repository capable of computing diffs, blame, and history without a network connection. For human workflows and open-source collaboration, that symmetry is a strength.

Inside Anthropic's monorepo, every assumption flipped:

- **Repository size:** The history of `main` alone approached **100 GB**, and a single compressed working copy exceeded **25 GB**.
- **Checkout volume:** CI pipelines executed roughly **25 million checkouts per day** before counting developer environments, agent sandboxes, or research jobs.
- **Network load:** Fetched naively, those checkouts would generate **more than 600 PB of daily Git traffic**.

Before writing Scion, the team exhausted the standard monorepo toolkit: shallow clones, sparse checkouts, promisor remotes, blob-storage snapshot seeds, and a fleet of several hundred internal Git mirrors. At 30,000 merges a day, the workarounds stopped holding. The repository outgrew mirror disk and memory limits, background packfile maintenance saturated CPUs, and `main` advanced so quickly that snapshot seeds fell far behind the branch tip between refreshes.

Because Anthropic's primary clients were always-online agents and ephemeral CI runners inside data centers, the team redesigned version control around a reachable server and on-demand fetching, drawing on lessons from Google's Piper and Meta's [Sapling](https://simonwillison.net/2026/Oct/13/redesigning-source-control-at-anthropic/).

## The FinOps & Build-vs-Buy Calculus

Engineering leaders budgeting for AI coding agents usually track token spend and seat licenses. Anthropic's migration exposes the second-order infrastructure bill: when agent swarms spin up thousands of isolated sandboxes per hour, traditional cloning burns cloud network egress and leaves CI runners idle waiting on disk I/O.

Moving off full checkouts and Git mirror farms produced immediate infrastructure gains reported by [Anthropic's source control team](https://www.anthropic.com/engineering/redesigning-source-control):

- **200x reduction** in source control CPU and memory footprint compared with the legacy Git mirror fleet.
- **100x faster checkouts**, dropping job startup wait times from minutes to seconds.
- **25% of total CI CPU capacity freed** across the fleet.
- **Up to 4x faster** native repository operations with zero background `git gc` or packfile maintenance.

Building a custom VCS, code review surface (Antique), code search, and directory-level IAM system historically took companies like Google and Meta years and dozens of engineers. Seven engineers shipped Scion and completed the monorepo migration in five months while daily merge volume grew 10x. Lower coding cost shrinks the build-versus-buy threshold for bottlenecked internal tooling, though Anthropic notes that custom lifecycle infrastructure still carries heavy integration and maintenance obligations—and that mainstream enterprises will likely hit similar Git and CI pressure points within **6 to 12 months**.

## Inside Scion's Architecture

In discussions on [Hacker News](https://news.ycombinator.com/item?id=50073633) and [Reddit](https://www.reddit.com/r/ClaudeAI/comments/1x5b5ek/redesigning_source_control_at_anthropic/), several readers compared Scion to centralized systems like Subversion (SVN) or Perforce. While Scion is server-authoritative, its storage and caching model is built specifically for immutable content addressing at tens of millions of daily reads.

### 1. Write-Ahead Log Changesets Over Packfiles

In Git, each commit points to a root tree snapshot, and objects are periodically delta-compressed into packfiles. In Scion, the unit of work is a **changeset** written directly to a server-side write-ahead log (WAL).

Instead of referencing a full directory tree, a changeset records only the file paths modified relative to its first parent alongside content-addressed pointers to compressed file blobs in cloud storage. Creating a commit, merge, or rebase happens directly on the server with no `git push` step, and its cost scales with the size of the change ($\mathcal{O}(\Delta)$) rather than the size of the monorepo.

As Scion engineer Nick G. noted in the [Hacker News thread](https://news.ycombinator.com/item?id=50073633) (highlighted by [Simon Willison](https://simonwillison.net/2026/Oct/13/redesigning-source-control-at-anthropic/)), immediate server-side creation means every commit hash is globally addressable right away across sandboxes and CI jobs. To avoid global coordination locks across servers, Scion discourages mutable refs except for `main` and release branches; advancing `main` is a separate atomic compare-and-swap (CAS) on a single Google Cloud Spanner row.

### 2. Recursive Derived Data in Spanner

Because a delta changeset only lists modified files, it cannot answer blame or history queries on its own. Scion computes **derived data** recursively in Spanner: each changeset's derived structures are calculated from its parent changesets' values.

These server-side structures include:

- **Commit graph skip lists** for logarithmic ancestry traversal.
- **Dedicated blame and path-history indices** for fast line-level and file-level lookups.
- **Copy-detection and path-search indices** added incrementally as the repo grew.

The server can materialize derived data eagerly on commit or lazily on query. Because clients only query derived data through RPCs and never inspect the internal storage layout, engineers can add new indices or swap graph algorithms without updating the client CLI.

<checkpoint id="changeset-scaling"></checkpoint>

### 3. Four-Tier Stateless Fetch Hierarchy

When a workload needs files on disk, Scion defaults to **sparse checkouts** (requesting only needed directory cones) and **virtualized checkouts** (materializing files on demand when read). Many read and write workloads—including bisect pipelines and automated revert tools—skip the working copy altogether and operate purely over server RPCs.

For jobs that do materialize files, Scion replaces Git's stateful `have`/`want` packfile negotiation with a uniform, stateless RPC protocol across four tiers:

<div className="my-8 not-prose">
<div className="border-border/60 bg-card/60 p-6 border-2 font-mono text-xs">
<div className="text-primary font-bold tracking-wider uppercase mb-4 flex items-center justify-between">
<span>Scion 4-Tier Stateless Checkout Architecture</span>
<span className="text-[10px] text-muted-foreground">&gt;99% Hit Rate Per Tier</span>
</div>

<div className="grid grid-cols-1 md:grid-cols-4 gap-4">
<div className="border border-border/60 bg-background/50 p-4">
<div className="flex items-center gap-2 text-primary font-bold mb-2">
<span className="w-5 h-5 rounded-none bg-primary/20 text-primary flex items-center justify-center text-[10px]">1</span>
<span>scn CLI Client</span>
</div>
<p className="text-muted-foreground text-[11px] leading-relaxed mb-3">
Runs inside the sandbox or CI container. Maintains a bounded local cache and recursively requests missing trees and blobs over a Unix socket.
</p>
<div className="bg-muted/50 p-2 text-[10px] text-foreground border border-border/40">
<code>Workspace Tier</code>
</div>
</div>

<div className="border border-border/60 bg-background/50 p-4">
<div className="flex items-center gap-2 text-primary font-bold mb-2">
<span className="w-5 h-5 rounded-none bg-primary/20 text-primary flex items-center justify-center text-[10px]">2</span>
<span>scion-daemon</span>
</div>
<p className="text-muted-foreground text-[11px] leading-relaxed mb-3">
One instance per physical compute host. Boots from a periodic snapshot and shares cached objects across all jobs on the node.
</p>
<div className="bg-muted/50 p-2 text-[10px] text-foreground border border-border/40">
<code>Node Tier</code>
</div>
</div>

<div className="border border-border/60 bg-background/50 p-4">
<div className="flex items-center gap-2 text-primary font-bold mb-2">
<span className="w-5 h-5 rounded-none bg-primary/20 text-primary flex items-center justify-center text-[10px]">3</span>
<span>scion-cache</span>
</div>
<p className="text-muted-foreground text-[11px] leading-relaxed mb-3">
Regional memory cache storing objects in the exact binary disk format consumed by the daemon—zero delta compression or CPU serialization.
</p>
<div className="bg-muted/50 p-2 text-[10px] text-foreground border border-border/40">
<code>Regional Tier</code>
</div>
</div>

<div className="border border-border/60 bg-background/50 p-4">
<div className="flex items-center gap-2 text-primary font-bold mb-2">
<span className="w-5 h-5 rounded-none bg-primary/20 text-primary flex items-center justify-center text-[10px]">4</span>
<span>scion-server</span>
</div>
<p className="text-muted-foreground text-[11px] leading-relaxed mb-3">
Stateless authoritative server fleet. Answers cache misses from Google Cloud Spanner metadata and cloud blob storage.
</p>
<div className="bg-muted/50 p-2 text-[10px] text-foreground border border-border/40">
<code>Origin Tier</code>
</div>
</div>
</div>
</div>
</div>

Because every request addresses an immutable content hash, responses are cacheable, parallelizable, and resumable. All four tiers implement the exact same RPC interface, with strict tiering enforced to isolate failure domains so a regional cache incident cannot overwhelm `scion-server`.

<datatable
  data='[{"Dimension":"Primary Client Assumption","Legacy Git (Mirror Farms)":"Offline humans needing full repository copies","Anthropic Scion (scn)":"Always-online AI agents & ephemeral CI runners","Operational Impact":"Eliminates redundant multi-gigabyte transfers"},{"Dimension":"Core Commit Data Model","Legacy Git (Mirror Farms)":"Full-tree snapshots bundled into packfiles","Anthropic Scion (scn)":"Write-ahead log (WAL) delta changesets + blob pointers","Operational Impact":"Commit cost scales with change size O(Δ); zero git gc"},{"Dimension":"Branch & Ref Management","Legacy Git (Mirror Farms)":"Prolific local/remote refs requiring global sync","Anthropic Scion (scn)":"Minimal refs (main/releases) via single-row Spanner CAS","Operational Impact":"Lock-free server commits with instant global hash visibility"},{"Dimension":"History & Blame Queries","Legacy Git (Mirror Farms)":"Computed locally by traversing client commit graph","Anthropic Scion (scn)":"Computed server-side via recursive derived data & skip lists","Operational Impact":"Fast API responses without cloning a working copy"},{"Dimension":"Wire Fetch Protocol","Legacy Git (Mirror Farms)":"Stateful have/want negotiation & dynamic delta packing","Anthropic Scion (scn)":"Stateless recursive fetches of immutable objects across 4 tiers","Operational Impact":">99% cache hit rate per tier; 200x smaller infra footprint"},{"Dimension":"Working Copy Materialization","Legacy Git (Mirror Farms)":"Full checkout by default; fragile sparse composition","Anthropic Scion (scn)":"Optional by default; native sparse & virtualized on-demand files","Operational Impact":"Checkouts drop from minutes to seconds (100x faster)"}]'
  columns='[{"key":"Dimension","label":"Architectural Dimension"},{"key":"Legacy Git (Mirror Farms)","label":"Legacy Git (Mirror Farms)"},{"key":"Anthropic Scion (scn)","label":"Anthropic Scion (scn)"},{"key":"Operational Impact","label":"Operational Impact"}]'
  pagination="false"
></datatable>

## How Seven Engineers and Claude Built Scion—and Where Humans Said "No"

Claude's autonomous coding created the scaling crisis and also wrote most of the replacement. Every engineer on the seven-person team rated Claude as better at writing raw code than they were, allowing the team to build hermetic simulations, fuzzing harnesses, and rate-limiting layers inside a five-month window.

In one early test, the team handed their handwritten Git-to-Scion ingestion prototype to an internal snapshot of **Claude Mythos Preview** with instructions to rewrite it. The model produced an implementation that used **20x less memory** and ran **4x faster** while preserving ordering and data-structure invariants. Later, Claude spotted an ancestry query optimization that was missing an index—tuning work that would normally take days of manual profiling.

<datachart id="ingestion-rewrite"></datachart>

To operate the platform with seven people, the team used **Claude Tag** to run component-specific monitoring agents in Slack—called **"superfans"**—for `scion-daemon`, `scion-cache`, and the Antique merge queue. Wired into logs and telemetry, these agents spotted subtle anomalies before threshold alerts fired.

At the same time, serial pre-merge locks broke down once hundreds of changes began landing during a single test run. Anthropic replaced global queue locks with **Antique's** semantic approval rules (separating comment edits from sensitive logic changes) and shifted to post-merge and pre-deploy automated testing, relying on Claude to resolve conflicting merges on `main`.

<div className="my-8 not-prose">
  <card className="border-amber-500/40 bg-amber-500/5 ring-1 ring-amber-500/10">
    <cardheader>
      <cardtitle className="text-amber-600 dark:text-amber-400 font-bold">Why Human Engineers Still Had to Say "No"</cardtitle>
    </cardheader>
    <cardcontent>
      Left to optimize a local task, coding agents repeatedly violated system-wide invariants. During the migration, multiple services tried to find when a change merged to <code>main</code> by brute-force scanning the linear commit log instead of querying the Antique API. Adversarial review agents also showed extreme myopia—in one instance distrusting an internal Anthropic service and prompting Claude to add layers of unnecessary defensive validation. Human engineers shifted from reading every line of syntax to enforcing architecture boundaries and reviewing change intent.
    </cardcontent>
  </card>
</div>

<checkpoint id="adversarial-review-myopia"></checkpoint>

## Stealing Scion's Wins on Standard Git

Anthropic explicitly states that [Scion is not a general-purpose Git replacement](https://www.anthropic.com/engineering/redesigning-source-control) and will not be open-sourced; it depends on internal Spanner tables, bespoke IAM, and uncapped internal token budgets. And as skeptics on [Hacker News](https://news.ycombinator.com/item?id=50073633) and [Reddit](https://www.reddit.com/r/theprimeagen/comments/1x55z6f/redesigning_source_control_at_anthropic/) pointed out, high merge volume alone does not guarantee cohesive product design if teams trade away interface boundaries for raw patch velocity.

You do not need a custom VCS to eliminate redundant repo transfers in agent workflows. Platform teams can capture most of Scion's operational savings on standard Git right now with four upgrades:

1. **Combine blobless clones with cone sparse checkouts in CI:** Replace full clones with `git clone --filter=blob:none --sparse` and `git sparse-checkout set <dirs>` scoped to the target service and its transitive dependencies. Pair this with a warm, node-level object cache (or reference repository) on CI hosts so cold runners do not trigger blob-on-demand storms against your Git forge.
2. **Isolate parallel local agents with `git worktree`:** Instead of cloning a multi-gigabyte repository per agent, spin up lightweight worktrees (`git worktree add -b feat/task .worktrees/agent-1 main`) sharing a single local object store, as detailed in [Essential AI Coding Feedback Loops for TypeScript Projects](/blog/essential-ai-coding-feedback-loops-for-typescript). Restrict agent tool definitions so agents cannot run unshallow full-history greps unless investigating a regression.
3. **Route metadata queries to Forge APIs:** When a CI job, revert bot, or triage agent only needs a diff, blame, file list, or merge base, query GitHub or GitLab REST/GraphQL endpoints rather than checking out a working copy.
4. **Shift from serial merge locks to path-filtered pre-merge + post-merge checks:** Scope pre-merge CI strictly to affected build graph targets, and pair fast merges with automated post-merge test suites that trigger deterministic rollbacks or targeted fix PRs.

<datatable
  data='[{"Role":"Builders & Agent Engineers","Bottleneck":"Agents cloning full repos and colliding in shared working trees","Immediate Git Upgrade":"Run parallel agents in isolated git worktree directories backed by one local object store; block full-history greps by default"},{"Role":"Platform & CI/CD Engineers","Bottleneck":"Multi-gigabyte CI checkouts burning network egress and runner CPU","Immediate Git Upgrade":"Switch CI to --filter=blob:none + cone git sparse-checkout with a warm node-level object cache; move diff/blame lookups to Forge APIs"},{"Role":"Engineering & FinOps Leaders","Bottleneck":"Serial merge queues stalling velocity and unreviewed agent complexity","Immediate Git Upgrade":"Audit CI checkout egress costs, require intent-focused architecture review on agent PRs, and invest in automated post-merge rollback gates"}]'
  columns='[{"key":"Role","label":"Role"},{"key":"Bottleneck","label":"Agent-Scale Bottleneck"},{"key":"Immediate Git Upgrade","label":"Immediate Git Upgrade"}]'
  pagination="false"
></datatable>

<debrief></debrief>

## Primary Sources & Further Reading

- **Anthropic Engineering:** [Redesigning source control at Anthropic](https://www.anthropic.com/engineering/redesigning-source-control) (Nick G., S.G., R.K., Dan C., Garrett H., Ben L., Colin M., and Joe P., October 13, 2026)
- **Simon Willison's Weblog:** [Redesigning source control at Anthropic](https://simonwillison.net/2026/Oct/13/redesigning-source-control-at-anthropic/)
- **Hacker News Discussion:** [Redesigning source control at Anthropic (860+ points, 960+ comments)](https://news.ycombinator.com/item?id=50073633)
- **Reddit Threads:** [r/ClaudeAI discussion](https://www.reddit.com/r/ClaudeAI/comments/1x5b5ek/redesigning_source_control_at_anthropic/) and [r/theprimeagen discussion](https://www.reddit.com/r/theprimeagen/comments/1x55z6f/redesigning_source_control_at_anthropic/)

## Interactive article data

```json
{
  "charts": {
    "merges-growth": {
      "type": "bar",
      "title": "Anthropic Monorepo Daily Merges (May vs. September 2026)",
      "description": "Daily changes merged into Anthropic's central monorepo surged 12x over four months following internal deployments of Claude Mythos Preview and Claude Tag.",
      "yAxisLabel": "Merges / Day",
      "data": [
        {
          "name": "May 2026",
          "merges": 2500
        },
        {
          "name": "September 2026",
          "merges": 30000
        }
      ],
      "config": {
        "merges": {
          "label": "Changes Merged per Day",
          "color": "#F97316"
        }
      }
    },
    "ingestion-rewrite": {
      "type": "bar",
      "title": "Git-to-Scion Ingestion Prototype vs. Claude Mythos Preview Rewrite",
      "description": "Relative memory usage and ingestion speed (normalized to handwritten baseline = 100) after Claude Mythos Preview rewrote the pipeline.",
      "yAxisLabel": "Relative Index",
      "data": [
        {
          "name": "Memory Footprint (Lower is Better)",
          "handwritten": 100,
          "mythos": 5
        },
        {
          "name": "Ingestion Throughput (Higher is Better)",
          "handwritten": 100,
          "mythos": 400
        }
      ],
      "config": {
        "handwritten": {
          "label": "Handwritten Prototype (1x)",
          "color": "#64748B"
        },
        "mythos": {
          "label": "Claude Mythos Preview (20x Less RAM, 4x Faster)",
          "color": "#14B8A6"
        }
      }
    }
  },
  "checkpoints": {
    "changeset-scaling": {
      "section": "Scion Data Model",
      "prompt": "A monorepo receives 30,000 merges per day. Why does Scion record commits as write-ahead log (WAL) delta changesets rather than Git-style full-tree snapshots and packfiles?",
      "options": [
        {
          "text": "So every client can download a complete offline copy of the commit graph in a single compressed bundle.",
          "correct": false,
          "why": "Scion is built for always-online agents and CI runners; it eliminates packfiles and full repository clones entirely."
        },
        {
          "text": "So commit, merge, and rebase costs on the server scale with the size of the change O(Δ) instead of total repository size.",
          "correct": true,
          "why": "Storing only modified paths relative to the first parent plus content-addressed blob pointers removes packfile repacking and global ref locking."
        },
        {
          "text": "Because Google Cloud Spanner cannot store directory tree hashes or commit ancestry.",
          "correct": false,
          "why": "Scion stores recursive derived data—including commit graph skip lists, blame, and path history—directly in Spanner."
        }
      ],
      "reveal": "By recording only changed paths relative to the first parent in a server-side WAL, commit creation scales with O(Δ) and avoids packfile garbage collection across tens of millions of daily CI runs."
    },
    "adversarial-review-myopia": {
      "section": "Human Oversight in Agent Loops",
      "prompt": "During the five-month migration to Scion, where did Anthropic's seven human engineers have to override Claude and say 'no'?",
      "options": [
        {
          "text": "When writing low-level memory optimization code for the Git-to-Scion ingestion pipeline.",
          "correct": false,
          "why": "Claude Mythos Preview rewrote the handwritten ingestion prototype to use 20x less memory and run 4x faster while preserving ingestion invariants."
        },
        {
          "text": "When agents brute-forced linear commit log scans instead of querying the Antique API, or added excessive validation after myopic adversarial reviews.",
          "correct": true,
          "why": "Agents optimizing for a local task frequently violated cross-system boundaries or over-engineered defenses against trusted internal services."
        },
        {
          "text": "When monitoring telemetry dashboards for scion-daemon and scion-cache anomalies.",
          "correct": false,
          "why": "Dedicated Claude Tag 'superfan' agents in Slack continuously monitored component telemetry and caught subtle regressions before threshold alerts fired."
        }
      ],
      "reveal": "Even when models outperform humans on raw code generation and local optimization, human engineers still own system boundaries, inter-service trust models, and intent review."
    }
  }
}
```

---

## Related Endpoints & Navigation
- **All Articles**: [https://zainahmed.net/blog](https://zainahmed.net/blog)
- **Author Profile**: [https://zainahmed.net/about](https://zainahmed.net/about)
- **Machine-Readable LLM Manifest**: [https://zainahmed.net/llms.txt](https://zainahmed.net/llms.txt)
- **RSS Feed**: [https://zainahmed.net/feed.xml](https://zainahmed.net/feed.xml)