Blog// version control

Why Anthropic Built Its Own Version Control System for Autonomous AI Agents

Anthropic replaced Git with its own Scion system due to a surge in AI‑agent‑driven merges; the experience offers lessons for optimizing CI pipelines in small businesses.

18-10-2026 · 6 min read
Why Anthropic Built Its Own Version Control System for Autonomous AI Agents

As Habr reports, in October 2026 Anthropic announced the move of its monorepo from Git to its own Scion system. The cause was a sharp rise in the number of merges performed by automated agents: from May to September 2026 their count grew from about 2,500 to over 30,000 per day. The history of the main branch weighs nearly 100 GB, the compressed working copy exceeds 25 GB, and the continuous integration system performs about 25 million checkouts daily. If all these operations were done with ordinary git fetch, daily traffic would exceed 600 PB, and the company maintained several hundred internal git mirrors.

It reveals two important trends already affecting development processes even in medium-sized teams: the growth of code-writing automation and increasing load on verification, merging, and test execution stages. Understanding how large players solve such problems helps choose the right tools and avoid typical bottlenecks.

Why Git Couldn't Handle the Agent Load

Git is designed as a distributed system where each client stores a full copy of the repository and can work offline. At Anthropic, almost all clients are agents and tasks that are constantly online and start each work session from a clean slate. Although shallow clone, sparse checkout, and the use of mirrors partially alleviated the problem, as the number of merges grew their maintenance became increasingly difficult and required significant administrative effort.

As Habr notes, the Git model assumes that most operations are performed rarely and that the cost of storing full history is justified by the flexibility of distributed work. When the main load shifts to frequent writes and fast checkouts, the redundancy of full copies becomes a hindrance: network traffic, CPU and memory consumption grow disproportionately, and operations that should take seconds start taking minutes.

How Scion Works and Its Advantages

Scion is a centralized version-control system. Its basic unit is a changeset, which is a record in a write-ahead log listing the files changed relative to the first parent and references to binary objects (blobs) by their hash. There are no packfiles, so no separate repository maintenance is needed. Reference updates happen via a compare-and-swap operation on a single Spanner row, and the scn client talks to a local daemon that reaches regional caches, which in turn talk to the authoritative servers. At each cache level the hit rate exceeds 99 %.

According to Habr, moving to Scion cut infrastructure CPU and memory consumption by roughly 200 times compared to a git-mirror-based setup. Checkout for CI and research tasks now takes seconds instead of minutes, and the CI system itself gained about 25 % free CPU capacity. The Scion system and the Antique code-review tool were built by seven engineers in five months; during that period merge volume grew tenfold. The data migration from Git to Scion was carried out by a pipeline written in Claude; the new version uses 20 times less memory and runs four times faster.

What This Shows About the Future of Development with AI Agents

Anthropic emphasizes that writing code has become cheap, while acceptance, review, merging, and CI execution have become expensive. Classic merge queues with a global lock do not scale when thousands of agents propose changes simultaneously. The company shifted to post-merge and pre-deployment testing, with separate Claude-based agents monitoring each component’s state alongside ordinary alerting.

The observation about people is also interesting: engineers often spend time telling Claude ‘no’ because agents can violate basic system constraints, and adversarial AI review sometimes turns out overly cautious. This points to the need for human oversight even in highly automated processes.

Lessons for Small Companies in Russia and the CIS

For most local businesses the code volume and merge frequency remain at levels where Git works without noticeable problems. Nevertheless, Anthropic’s experience suggests several practical ideas that can be applied today:

  1. Assess CI load. If checkout or build time is measured in minutes, consider using shallow clones and sparse checkout in your build system. This reduces the amount of data transferred without losing needed history for current tasks.
  1. Cache artifacts and dependencies. Central caches with high hit rates, like in Scion, cut repeated downloads of identical files. In GitLab or Jenkins you can configure caching of Docker layers, Maven/npm packages, and build artifacts.
  1. Split verification stages. Instead of a single long merge queue, it is useful to add a fast pre-merge check (lint, unit tests) and a more thorough post-merge verification stage (integration tests, static analysis). This lowers the chance of blocking due to one long job.
  1. Use AI-assisted code review as a supplement, not a replacement. Tools such as Claude or internal models can quickly flag obvious issues, but the final decision should remain with an experienced engineer, especially when dealing with business logic and security.
  1. Invest in observability. Metrics for checkout time, build duration, merge frequency, and CPU usage help spot load growth early and take preventive measures.

What to Do This Week

  • Audit current checkout and build execution times in your CI system. Record the averages and flag tasks that exceed the one-minute threshold.
  • Enable shallow clone depth=1 for all builds that do not need full history, and measure the time change.
  • Set up dependency caching in your CI system (e.g., cache the node_modules folder or ~/.m2) and check the hit rate after a few runs.
  • Define two code-check levels: a fast pre-merge (syntax, basic unit tests) and a more thorough post-merge (integration tests, vulnerability scanning). Set up separate pipelines for each level.
  • Allocate one hour for a team discussion on how AI tools can assist in review, and agree on a process where their recommendations are the first step and the final decision is made by a person.

Brief Conclusion

Anthropic’s move to its own centralized version-control system shows that under extreme code-writing automation traditional tools can become a

Frequently Asked Questions

Why did Anthropic abandon Git?

Anthropic encountered scaling challenges with Git because of the massive volume of automated changes generated by AI agents. Existing version control systems could not handle such a flow, leading to delays.

What is Scion and how does it work?

Scion is an internal version control system developed by Anthropic to efficiently process multiple automatic merges. It is optimized for high-speed changes generated by AI, minimizing conflicts and speeding up integration.

How can Anthropic’s experience benefit small businesses?

Anthropic’s experience underscores the importance of adapting CI/CD infrastructure to increasing automation and AI agent usage. Small businesses should proactively plan for system scalability to prevent future bottlenecks.

Based on: Habr

Analysis & review by
Alexander K.

Web development, digital advertising and marketing expert since 2012. Founder of AIFORSALE.

How we can help
Online storesMarketingAI agentsContact us
← All articles