Anthropic Scion: What It Is and Why Anthropic Left Git

Anthropic Scion is a proprietary, server-centric version control system built to replace Git across its monorepo. Anthropic built Scion as merges to its monorepo rose from about 2,500 a day in May 2026 to over 30,000 a day by September 2026.

Git was architected around decentralized, offline repositories where every clone retains a full copy of the commit history. At enterprise scale with millions of automated checkouts and swarms of agents, Anthropic ran several hundred internal Git mirrors that got harder to operate as the merge rate rose.

A small team of seven engineers completed the migration from Git in five months while simultaneously delivering Antique, a companion code review system. While Anthropic explicitly notes that Scion is not intended as a general-purpose replacement for Git, Anthropic suggests applying several of its concepts to Git as agent workloads grow.

What Anthropic Scion Is and Why Anthropic Moved Off Git

Anthropic Scion is Anthropic's in-house, server-centric version control system (VCS). Anthropic built it because merges to its monorepo rose from about 2,500 a day in May 2026 to over 30,000 a day by September, and Git's decentralized, offline-capable design strained under mostly-online agents and jobs; it migrated the monorepo from Git in five months. Anthropic says Scion is not a general replacement for Git and is not offered to other organizations. The engineering team documented this transition in an engineering publication on redesigning source control.

Anthropic says the volume of code merged per day increased 10x during the five-month migration.

Anthropic stated that the latent demand for merging code is practically infinite, meaning repository activity will continue to expand. A dedicated team of seven engineers designed and deployed Scion, alongside a companion code review system called Antique, code search, source control identity and access management (IAM), and tools to land reviewed changes.

• Daily merge growth: Merges increased from 2,500 per day in May 2026 to over 30,000 per day in September 2026.
• Monorepo history size: The Git history of the main branch alone approached 100 gigabytes (GB).
• Working copy footprint: A compressed working copy of the monorepo exceeded 25 gigabytes (GB).
• Continuous integration checkouts: Automated jobs ran approximately 25 million code checkouts per day.
• Potential transfer volume: Naive Git checkouts at this rate would generate over 600 petabytes (PB) of traffic daily.
• Engineering timeline: A team of seven engineers built Scion, Antique, and supporting infrastructure in five months.

Why Git Strained Under Agent-Scale Development

Git is built around a decentralized model where every clone acts as a complete, self-contained repository designed to operate offline. While this architecture suits typical open-source projects and human engineering teams, Anthropic found that its monorepo no longer matched Git's core design assumptions. In Anthropic's environment, virtually all operations originated from continuous integration (CI) workers, research jobs, and autonomous agents that remain permanently connected to the network.

Anthropic initially attempted to mitigate these performance bottlenecks using standard enterprise Git optimizations. Anthropic used shallow clones, sparse checkouts, promisor remotes, snapshot seed archives stored in cloud blob storage, and several hundred internal Git mirrors at peak scale. These intermediary techniques bought time, but operational overhead escalated as daily merge counts multiplied.

High commit velocity caused snapshot seeds to fall behind the tip of the main branch between scheduled updates. Operations that depend on history, such as diff and blame, took more care on partial clones. Anthropic realized it was running Git as a centralized authority with one canonical repository, despite the software's decentralized foundations. Anthropic names Google's Piper and Meta's Sapling as prior art.

Architectural Principles of the Anthropic Scion System

Anthropic structured Scion around six design principles tailored for automated, cloud-native workflows. The first principle assumes that clients are always online, meaning client tools and communication protocols rely on network access to retrieve repository data on demand. The second principle enforces client-server asymmetry, assigning heavy computational tasks to central servers while local clients maintain a bounded cache, lay out working files, and monitor the local filesystem.

The third principle dictates that every repository query available to the local client is also accessible through an application programming interface (API). Programmatic access allows automated bisect and revert pipelines to inspect code states without materializing local files on disk. The fourth principle requires horizontal scalability across distributed storage, eliminating packfiles and avoiding fully materialized copies of the monorepo on both client machines and backend servers.

The final two principles focus on server-side commit creation and optional working copies. Scion treats commits as cheap, incremental, lock-free operations executed entirely on the server, avoiding push operations and discouraging references other than main and release branches. Working copies remain optional and sparse by default, enabling virtualized checkouts that load files on demand and allowing automated jobs to fetch diffs against merge bases without populating local directories.

How Scion Operates Under the Hood

Scion organizes code updates around changesets recorded in a write-ahead log. Each changeset contains a list of modified files relative to its primary parent, paired with content-addressed pointers directing to compressed file contents in cloud blob storage. Because changesets are generated directly on the server, newly recorded changes become accessible across the entire infrastructure instantly without network push steps.

Updating repository references requires a compare-and-swap operation on a single Spanner row, decoupling branch updates from changeset creation. Derived repository data, including file blame, path history, commit graph skip lists, copy detection, and path search, is generated through a unified recursive mechanism. These derived computations execute either eagerly or asynchronously, keeping internal algorithmic complexity invisible to connected client applications.

The dedicated scn client does not tell the server what it already has. Instead, the client queries requested trees and blobs recursively from a designated root tree, producing cacheable, resumable responses without multi-gigabyte packfile payloads. Anthropic organizes Scion into three distinct infrastructure tiers: scion-daemon running on local compute nodes, scion-cache providing regional tree and blob caching, and scion-server acting as the authoritative layer querying Spanner and cloud object storage.

Reported Performance Gains and Resource Savings

Anthropic's engineering report detailed substantial performance improvements and hardware footprint reductions after migrating from Git to Scion. According to Anthropic's own reported figures, each infrastructure caching tier achieves cache hit rates exceeding 99 percent. The overall infrastructure footprint supporting version control decreased by a factor of 200 in central processing unit (CPU) and memory utilization compared to the previous Git mirroring architecture.

CI and research jobs check out code two orders of magnitude faster (seconds rather than minutes). CI alone realized a 25% CPU capacity win.

Operational maintenance routines also disappeared under the new architecture. Anthropic reported that there is no equivalent of packfiles, so neither clients nor backend caches require repository maintenance.

How Anthropic Used Claude to Engineer Scion

The engineering team developed Scion concurrently with early internal releases of Claude Mythos Preview and Claude Tag. An ingestion pipeline responsible for migrating history from Git into Scion was initially handwritten by human engineers. An early snapshot of Claude Mythos Preview rewrote this ingestion pipeline, producing a replacement version that consumed 20 times less memory and ran four times faster while preserving subtle implicit data invariants.

Anthropic noted that while all seven engineers on the project considered Claude superior at writing code, engineers supplied system-level understanding and design trade-offs. Engineers frequently intervened to reject Claude's initial design suggestions, such as preventing systems from brute-forcing commit logs instead of querying the code review service, and eliminating excessive validation logic generated during adversarial review cycles. The team reviews every change request for the intent of the change rather than every line.

The team deployed Claude to generate hermetic simulation environments, conduct automated fuzzing, configure rate limiters, and resolve performance bottlenecks, including an ancestry-query algorithm that missed an index. Specialized instances described as superfan Claudes monitor individual subsystems via Claude Tag within Slack channels alongside traditional system telemetry.

Rethinking Merge Queues and Repository Security

Operating at this merge volume forced Anthropic to reconsider standard merge queue practices. At extreme commit volumes, Anthropic found that a proper merge queue did not make much sense and was unable to replicate a global repository lock on the merge queue. Rather than enforcing strict sequential locks before merging, Anthropic invested in post-merge and pre-deploy automated testing.

Concurrent modifications inevitably produce merge conflicts when multiple agents update overlapping code paths simultaneously. Anthropic says Claude can typically fix conflicts faster than humans can identify them.

Scion provides fine-grained permissions at both the repository and individual directory levels. Working alongside Scion, Anthropic's review tooling can express semantic approval constraints, such as separating comment-only changes from sensitive logic changes.

Why Anthropic Scion Is Not a General Git Replacement

Anthropic explicitly stated that Scion is by no means a suitable replacement for Git for general use across the software industry. Scion was designed specifically for massive monorepos supporting tens of thousands of human developers or extensive swarms of autonomous agents.

Anthropic says its ability to spend tokens internally far exceeds what other businesses would realistically want to spend. Deploying Scion externally would require adopting Anthropic's bespoke code review platform, search engines, and CI integrations.

As of October 2026, Anthropic has not released Scion as an open-source project, has not announced commercial availability, and does not publish pricing for external access. Organizations interested in governance and security models for autonomous coding can review the guide on AI coding assistant security governance. Broader comparisons of agent capabilities are detailed in the evaluation of the best AI coding agents in 2026.

What Engineering Teams Can Take From Scion

Although Scion remains an internal tool, Anthropic suggested that the broader software industry can adapt several of its core concepts within existing Git environments over the next six to 12 months. Anthropic argued that Git server infrastructure does not need to mirror client-side execution models. Git platforms could introduce server-side remote procedure calls (RPCs) like Scion's.

Anthropic also suggests Git platforms rethink negotiation protocols and improve sparse and shallow features. Teams evaluating agent tooling can explore the guide on what Claude Code is and operational considerations for Claude Code for business.

Teams running AI coding agents can examine repository performance metrics before commit velocity causes operational friction. Questions to ask include measuring total daily merge volume, tracking the proportion of CI compute consumed by repository checkouts, and verifying whether existing merge queues introduce serial locking bottlenecks. For evaluations of model performance across software tasks, consult the review of AI coding benchmarks.