Anthropic Scion: Rebuilding Version Control for the Agent Era

Client Model Shift Drives Redesign

Git's design assumes long-lived, potentially offline developer workstations that hold a complete repository clone. Anthropic's workload is the opposite: the primary clients are ephemeral AI agent sandboxes and CI jobs that run online for minutes, need only a few directories, and require fast answers to historical questions (blame, merge-base, ancestry) without maintaining a full local repo.

Anthropic tried shallow clone, sparse checkout, promisor remotes, object-storage snapshots, and hundreds of Git mirrors. These reduced some transfer and disk use, but snapshots fell behind fast-moving trunk, mirrors required constant catch-up, and tools depending on full history remained hard to maintain.

Scion Architecture: Three Separated Paths

Scion splits data write, historical query, and file distribution into three independent server-side paths:

Fact path : Authoritative source-of-truth writes (changesets) land in Spanner via single-row compare-and-swap.

Query path : Historical questions (blame, path history, commit-graph jumps, root tree) are answered from precomputed or on-demand derived data built recursively from parent changesets.

Distribution path : Workspace population fetches only missing tree and blob objects on demand through a layered cache hierarchy.

Agent Task Flow

scn

client creates a workspace and requests only the tree and blob objects for directories the task touches; unaccessed files never hit disk.

Historical queries (blame, merge-base, ancestry) call server APIs directly — no local repo needed.

On completion, the server creates a changeset recording parent changeset(s), changed-file list relative to first parent, and content-addressed pointers to compressed blobs.

Moving the trunk ref is a separate Spanner CAS operation; persistence ≠ merge.

Changesets vs. Git Commits

Changesets resemble Git commits but differ in write path and authority location. Git shares trees and blobs too; the difference is that Scion changesets are created server-side, cost scales with the change size, and no global ref moves atomically with the write. Trunk and release branches still exist but ref updates are explicit CAS operations.

Derived Data for History Queries

Changesets only record "what changed this time." Scion builds derived indexes for blame, path history, commit-graph traversal, and root trees. Each derived dataset is computed recursively from parent results, can be pre-generated or computed on query, and is decoupled from the write path — new indexes don't require client protocol changes, and re-indexing never rewrites raw changesets.

Complexity moves to the server: lazy-computation first-hit latency, hotspot backfill, index versioning, and failure recovery become centralized operational concerns instead of being replicated across every short-lived client.

On-Demand Checkout via Layered Cache

When files must materialize, scn walks the root tree, detects missing objects, and requests only needed sub-trees and blobs. Each request targets an immutable content-addressed object, enabling caching, retry, and resume without waiting for a massive packfile.

Distribution chain: scn → scion-daemon (per-node object reuse) → scion-cache (regional in-memory cache) → scion-server → Spanner / object storage. All layers speak the same RPC but traffic cannot skip levels; a regional cache failure must not cause a thundering herd on the authority service.

Internal metrics: every cache layer >99% hit rate; source-control infrastructure CPU/memory ≈ 1/200 of the old Git mirror fleet; CI and research checkout dropped from minutes to seconds; CI alone freed ~25% CPU capacity. Anthropic emphasizes these gains reflect their specific repo shape, hotspot distribution, and task profile — replacing Git does not automatically yield the same results.

Three Divergent Approaches

Cursor's Origin/Continuity tackles the same pressure (more agents, PRs, CI) but at a different layer:

Scion : Replaces data model, client, and protocol. Gains larger design space; cost is full toolchain migration (review, search, permissions, CI).

Origin / Continuity : Keeps standard Git protocol and clients. Rewrites server persistence (S3 WAL), replication, recovery, and repo scheduling. Better compatibility but retains Git object/packfile semantics.

Git incremental : Partial clone, sparse checkout, sparse index, background maintenance. No repo or process change; optimization space bounded by existing protocol and tool behavior.

Cursor publishes read-scaling with replica count and push throughput across S3 classes; Anthropic publishes daily merge volume, checkout latency, and infra footprint. Units, paths, and goals differ — no direct leaderboard possible. Scion engineer Nick G. confirmed on Hacker News: "These are two different classes of systems; Scion solves more than write speed. Origin is closer to server replication/persistence; Scion also changes history query, workspace prep, and the path to trunk."

Four Change States Emerge

With merge queues failing at agent scale, Anthropic shifted more automated testing to post-merge/pre-deploy. A change now progresses through four distinct states:

Persisted : Change fact saved, referenceable and recoverable

Merged : Change entered shared trunk

Verified : A check suite produced a result against an explicit snapshot

Deployable : Current release policy permits entry to target environment

The Scion public write-up does not claim these four states are a built-in generic model; the author extracted them from the review, test, and verification pipelines. As change density rises, "code is committed" conveys less and less.

Human Role: Guard Intent, Not Lines

Scion engineers acknowledge Claude writes code better than they do, but humans still set system boundaries, scale assumptions, and migration trade-offs — including telling Claude "no." One implementation linearly scanned entire commit history to answer when a change entered trunk; the code ran but the query belonged in the code-review service, not the version-control layer. Adversarial reviews that pile defensive checks around hypothetical risks add complexity without addressing root causes (Simon Willison observed the same). Scion team reviews focus on change intent: why the change exists, which authoritative fact it depends on, what constraints it breaks, and how to stop and recover on failure.

Agents raise implementation throughput; humans hold system boundaries and change intent.

Not a General-Purpose Git Replacement

Scion is explicitly not for ordinary teams. Anthropic states it fits only massive monorepos, tens of thousands of engineers, or environments with continuous agent-authored code. It also depends on custom review, search, CI, and permission systems and is not a downloadable product.

Yet the client-shift pattern is broader: when the primary client is human, full local copy, offline operation, and strong client make sense; when the primary client is online, ephemeral, parallel agents, server-side query, on-demand workspace, and shared caching become critical. As code generation accelerates further, systems must distinguish change fact, trunk position, verification result, and deployment eligibility. Scion rewrites the first two layers; Anthropic had to re-architect the third. Mainstream teams won't adopt Scion directly, but version control's design premises are changing.