Beyond Git: How Anthropic Is Redesigning Source Control for AI Agents

AI is changing software engineering faster than traditional development infrastructure can keep up. In its recent article, Redesigning Source Control at Anthropic, Anthropic introduces Scion, a new version control system designed for a future where AI agents generate and modify code at unprecedented scale.

The interesting innovation is not simply replacing Git. It is rethinking source control architecture around AI agents rather than human developers.

1. Why Git Becomes a Bottleneck#

Git was designed for distributed development, allowing developers to clone repositories, maintain local histories, and commit changes offline.

However, AI coding agents operate differently. They are typically online, generate changes continuously, and execute thousands of development tasks concurrently.

At Anthropic, merged code changes increased from approximately 2,500 per day in May 2026 to over 30,000 per day by September. Its monorepo reached nearly 100 GB of main-branch history, with roughly 25 million CI checkouts daily.

Traditional Git infrastructure struggled to support this workload.

2. Scion: Server-Centric Source Control#

Scion introduces several architectural changes.

First, server-side operations. Unlike Git, where clients maintain repositories and perform commits locally, Scion moves commits, merges, rebases, and history queries to centralized services. Clients maintain lightweight caches and retrieve only necessary data.

Second, incremental changesets. Instead of storing a complete tree reference for each commit, Scion represents a changeset as a list of modified files and content-addressed pointers to their contents. Changesets are written to a server-side log, enabling high-throughput, lock-free operations.

Third, derived metadata. File histories, blame information, and commit relationships are maintained through specialized data structures. These can be computed eagerly or lazily, avoiding unnecessary processing.

Fourth, sparse and virtualized checkouts. Agents retrieve only the files they need, rather than cloning an entire repository. Some workflows operate directly through APIs without checking out files at all.

3. How the Architecture Works#

Scion uses a hierarchical caching architecture:

Because objects are content-addressed and immutable, multiple caching layers can serve requests efficiently without extensive synchronization.

The reported results are impressive: 200× smaller CPU and memory infrastructure footprint, checkouts completing in seconds rather than minutes, and a 25% reduction in CI CPU capacity requirements.

4. AI Is Also Changing the Engineer's Role#

Perhaps the most interesting aspect is that AI helped build the infrastructure needed to support AI itself.

Anthropic reports that seven engineers built Scion and its code review system, Antique, and migrated the monorepo within five months, with substantial assistance from Claude.

Engineers increasingly focused on architecture, system constraints, correctness, and reviewing the intent of changes rather than manually writing every line.

5. The Bigger Picture: Agent-Native Software Engineering#

Scion illustrates a broader shift.

Traditional software engineering infrastructure assumes that humans write code, while tools automate supporting tasks. Agent-native engineering reverses this relationship: AI agents perform much of the implementation, while humans define architecture, constraints, and verification requirements.

Scion is not intended to replace Git universally. Its design targets extremely large repositories and highly automated development environments.

Nevertheless, its architectural principles suggest that the next generation of software engineering tools may need to be redesigned from the ground up for AI agents—not merely augmented with AI features.

Source: Anthropic Engineering, October 13, 2026.