In September 2026, Anthropic’s monorepo was accumulating 30,401 code changes per day. Four months earlier, that number was 2,500. AI coding agents had multiplied their merge throughput 12x, and Git — the tool the entire industry runs on — broke under the load. A seven-person team built a replacement called Scion in five months. It won’t be open-sourced. But what broke Git, and what it took to fix it, is a preview of infrastructure problems the rest of us will face.
Git Wasn’t Designed for This
The numbers are worth sitting with. At 30,401 merges a day, the main branch was moving every three seconds. With 25 million CI checkouts per day, naively replaying all of that traffic through standard Git would have generated over 600 petabytes of daily data transfer. Anthropic ran “several hundred” internal mirrors at peak before admitting the approach was fundamentally broken.
They didn’t jump straight to building their own system. Anthropic exhausted every Git optimization first: shallow clones, sparse checkouts, promisor remotes, internal mirrors, blob storage seed snapshots. Each one helped — and each one still assumed Git’s core model: offline-capable, independent peers holding local copies of repository history.
That assumption doesn’t hold when your “developers” are AI agents that exist for 20 minutes, never go offline, and don’t need the last 100 GB of commit history to do their job.
What Scion Actually Does
Scion inverts Git’s storage model. Git stores snapshots and computes diffs. Scion stores diffs — changesets in a write-ahead log — and derives trees on demand. Every commit, rebase, and merge happens on the server. Clients fetch only what they need via a three-tier content-addressed cache: a local daemon, a regional cache, and a central server backed by Spanner and Cloud Storage. All three tiers answer the same RPCs. Cache hit rate exceeds 99% at every tier.
The key insight is in the protocol design. Git’s have/want negotiation is stateful — it requires knowing what each client already has, which forces whole-repository mirrors. Scion names content by its hash, so any proxy or CDN can answer a request without repository awareness. That’s what makes stateless caching at every tier possible.
The performance results are dramatic:
- Developer status check: 3.9 seconds to 19 milliseconds (207x faster)
- Agent new worktree: 7.1 minutes to 5.1 seconds (84x faster)
- Pull latest: 87 seconds to 3.5 seconds (25x faster)
- CPU/memory footprint: 200x smaller than the previous mirror fleet
- CI capacity: 25% savings
Operations that scaled with repository size saw the largest gains. Operations already proportional to change size barely moved. The problem was always the per-repository overhead, not the per-change cost.
The Human Role Has Already Changed
Here’s what the Scion team reported after migration: every engineer on the project would now rate Claude as better at writing code than themselves. Their actual job became telling Claude no — redirecting it from querying commit logs instead of the review tool, stopping unnecessary defensive validation, managing scope.
The code review model changed too. Pre-Scion: serialized merges behind full test runs, one global queue. Post-Scion: post-merge and pre-deploy testing, with intent-based review replacing line-by-line inspection. The stated reason: “Claude can typically fix conflicts faster than humans can even identify them.” So they removed the pre-merge gate, rebuilt governance around post-merge testing, and leaned into AI-assisted conflict repair.
This is the real signal in the Scion story. It’s not the VCS technology — it’s the governance model that had to be completely rebuilt to accommodate the new velocity.
What You Can Do Right Now
Anthropic is direct: Scion is not for general use and will not be open-sourced. But the design principles transfer. If you’re running AI coding agents today, start with these:
# Blobless sparse clone — only fetch file contents you actually need
git clone --filter=blob:none --sparse <repo-url>
git sparse-checkout set services/api packages/shared
# Per-agent worktrees — give each agent its own isolated checkout
git worktree add ../agent-1-worktree mainAnthropic’s extracted lessons for teams not operating at their scale:
- Measure first — time fresh agent worktrees, status checks, and pulls before optimizing anything
- Use blobless sparse clones with per-agent worktrees to cut checkout overhead
- Query repository state through forge APIs rather than full local clones
- Minimize ref counts — they become a bottleneck at agent scale
- Move toward intent-based review now, before volume forces the transition under pressure
The Architecture Behind It (and Who Inspired It)
Developer communities were quick to notice that Scion’s architecture is heavily inspired by Meta’s Mononoke, the server component of Meta’s Sapling source control system. A Hacker News thread with 835 points and 897 comments dissected the design — and a follow-up thread titled “More on Anthropic’s Scion ripping off Mononoke” generated its own heat. Anthropic credits Google Piper and Meta Sapling as prior art in the engineering post.
The attribution debate misses a more important point: these architectural patterns were already proven at Google and Meta scale. Anthropic adapted them for a new workload — AI agent-scale throughput — not a human-developer-scale monorepo. That adaptation is the novelty. Simon Willison’s breakdown covers the technical lineage well if you want to go deeper.
What Comes Next
Anthropic expects other organizations will face similar pressures within 6 to 12 months as AI coding adoption scales. The future isn’t a proliferation of Scions. It’s GitHub, GitLab, and Git itself absorbing these lessons: standardized server-side RPCs, new negotiation protocols, composable sparse and shallow clone features built into the protocol. Developers Digest has a thorough breakdown of what that evolution might look like.
Scion is a report from the edge of the curve, built by a team with unusual resources and an unusual problem. For everyone else, the message is simpler: measure your agent checkout times now. Optimize with sparse clones and worktrees. Rethink your code review model before you’re forced to. The infrastructure problems Anthropic hit at 30,000 merges a day will show up for other teams at 300.
