Anthropic says its daily merged code changes rose from roughly 2,500 in May 2026 to more than 30,000 by September. Source control became its biggest development bottleneck, prompting the company to replace Git for its monorepo.
In an engineering disclosure published on October 13, Anthropic describes Scion, an internal version-control system designed for clients that are almost all agents or automated jobs already online. They don’t need an independent copy of the repository capable of answering every question offline.
A seven-person team built Scion, a related code-review tool called Antique, and supporting infrastructure, then completed the migration in five months, according to Anthropic. The lesson for other companies is how much infrastructure can change when automated clients become the dominant consumers of source control, not that they should abandon Git.
The Bottleneck Was Repeated Access, Not Just Repository Size
Anthropic’s monorepo had become expensive to distribute. Its main-branch history approached 100 GB, while a compressed working copy exceeded 25 GB.
CI performed approximately 25 million checkouts daily, before counting developer environments, agent sandboxes, or research jobs. Repeatedly making a large repository available to short-lived clients was the central scaling problem.
The company estimates that naively fetching those working copies would generate more than 600 petabytes of Git traffic per day. That is a hypothetical calculation, not a measurement of actual traffic. Anthropic already used shallow clones, sparse checkouts, promisor remotes, internal mirrors, and repository snapshots stored in blob storage to avoid such waste.
Those measures bought time. At peak, however, Anthropic operated several hundred Git mirrors. As merge volume increased, repository snapshots fell further behind the latest main-branch revision between refreshes. Keeping history-dependent operations such as diff and blame working correctly with partial clones also required increasing care.
Scion followed extensive use of Git’s existing mechanisms and infrastructure workarounds under an unusually large automated workload. It wasn’t Anthropic’s first response to a slow clone.
The company’s account describes a mismatch between distributed repository mechanics and centralized, high-volume consumption. It doesn’t establish that Git is unsuitable for ordinary development.
Scion Moves Repository Intelligence to the Server
Git’s distributed design lets a conventional clone operate as a self-contained repository. Developers can inspect history, create commits, and perform many operations without contacting a central service.
Scion deliberately gives up much of that independence. Its server answers history and blame queries, creates commits, and performs merges and rebases. The client maintains a bounded local object cache, arranges working-copy files on disk, monitors filesystem changes, and provides the user interface. Anthropic says the client can compute very little independently.
This reduces the data each client must retain. A job asking who last changed a line can request the answer directly, without a local repository capable of reconstructing it.
Anthropic also exposes the source-control queries used by its client through APIs. The company says this makes automated bisect and revert pipelines practical at its scale, without requiring every tool to maintain its own repository copy.
The cost is a stronger dependency on the service. Editing an already materialized file and completing a server-side commit are different operations; the latter requires connectivity to Scion. Teams considering a similar architecture need to evaluate service availability, network latency, and failure handling alongside checkout performance.
Anthropic’s always-online assumption is credible for its CI jobs and agent infrastructure. It would be a poor default for a repository whose contributors depend on disconnected work or independently operated clones.
Sparse and Virtualized Checkouts Reduce the Work Per Job
In Scion, an operation doesn’t necessarily start with a working copy.
A CI job that needs the difference between a changeset and its merge base can ask the server for that diff. Anthropic says some write workloads can also operate entirely through APIs. Avoiding a checkout removes both data transfer and filesystem setup from those tasks.
When files are necessary, Scion uses two complementary mechanisms:
- Sparse checkouts contain only the directories the client requests.
- Virtualized checkouts materialize files on demand, so clients pay for the files they actually read.
Sparse selection limits the scope of the working copy; virtualization delays the cost of filling it.
For example, a job that needs one package shouldn’t automatically receive unrelated directories. Even within that package, it may read only a subset of files. This is an illustrative workload, not a reported Anthropic benchmark, but it explains why combining the two mechanisms can reduce unnecessary work.
Virtualization moves some work to file-access time rather than eliminating it. A job that reads everything still needs the relevant contents, and its performance will depend on cache behavior and retrieval latency.
Teams can often reduce checkout demand before contemplating a replacement version-control system. The question is whether each automated task needs repository metadata, file contents, or both.
Content Addresses Make Data Reusable Across Clients
Scion’s basic unit of work is a changeset stored in a write-ahead log. Unlike a Git commit, which points to a tree, a Scion changeset records files changed relative to its first parent, together with content-addressed pointers to compressed file contents in blob storage.
Content addressing identifies an object by its contents. It gives clients and storage systems a stable identity for the data they retrieve, instead of treating each working copy as a separate payload.
The disclosed architecture includes a bounded client-side object cache and blob-backed content storage. For teams designing tiered caches, the transferable principle is that different cache layers can reuse the same content identity. Frequently requested objects can remain close to consumers without requiring every consumer to retain the entire repository.
Caching a complete checkout snapshot works differently. When snapshots age rapidly, clients must reconcile an increasingly stale starting point with current history. Object-level caching allows unchanged content to remain reusable as new changesets arrive.
Changesets alone don’t efficiently answer every historical question, so Scion builds additional structures for file blame, path history, and the commit graph. Anthropic calls these structures “derived data” and computes them recursively from parent changesets, either eagerly or when needed.
Separating the acceptance of changes from the construction of query indexes also lets Anthropic change server-side structures without exposing their internals to clients.
Anthropic says Scion distributes repository data across independently scalable components, with no fully materialized repository copy even on the server. It also avoids Git packfiles, the compressed object bundles whose creation and maintenance form part of Git’s storage model.
Server-Side Commits Require Different Coordination Choices
Moving commits to a server could simply move the bottleneck unless the write path is designed for concurrency.
Anthropic’s stated requirement was that commit creation and associated updates scale with the size of the change, not the size of the entire repository. Scion accepts changesets without receiving packfiles or moving branch references as part of that operation.
The system also discourages refs, the pointers used for branches and tags, apart from cases such as main and release branches. Anthropic identifies globally coordinated state as a potential scaling constraint.
Scion does support refs. Updating one is a separate compare-and-swap operation on a single Spanner row; it isn’t a prerequisite for creating or fetching changesets.