Why Anthropic replaced git with Scion (and what to take from it)

On October 13, 2026, Anthropic explained why it had dropped git, the tool almost every developer in the world uses to manage versions of their code. Its main repository took around 2,500 code merges a day in May. By September it was taking more than 30,000. Git could no longer keep up, so the company replaced it with Scion, an in-house system built by seven people in five months (Anthropic).

Git works fine. Its users changed. At Anthropic, "nearly all of our clients were agents and jobs that are online by definition." Git was designed in 2005 for human developers, each working on their own machine, sometimes offline. Scion is designed for agents.

Should everyone leave git, then? No, and Anthropic is the first to say so. But for very large codebases with thousands of agents working on them, the git model is hitting its limits. What will replace it is already being built at GitHub, at GitLab and at a handful of startups.

Git, a version control system built for humans

A version control system records every change to the code: who made it, when and why. It lets you go back, work on the same project with others and bring everyone's work together. Git, written by Linus Torvalds in 2005 for the Linux kernel, became the standard.

What sets it apart is that it is distributed. Every developer holds a full copy of the project and its history. They can work offline, create a branch to try an idea, then merge it with everyone else's work. Every operation (comparing two versions, finding who wrote a line, merging) runs on their own machine.

Git is not GitHub. Git is free software. GitHub, owned by Microsoft, is a forge: a service that hosts git repositories and adds code review, issues and continuous integration (CI), the tests that run automatically on every change. There are other forges, several of them open source and hostable in Europe. We come back to them below.

Why git stopped being enough at Anthropic

Anthropic works in a monorepo: a single repository holds all of the company's code, as at Google or Meta. This one is huge. Its history weighs almost 100 GB, a single compressed working copy is over 25 GB, and CI checks it out about 25 million times a day.

AI made the volume explode. By July 2026, Claude was already writing about 80% of the code merged at Anthropic, and engineers were shipping on average eight times more code per quarter than in 2021-2025 (Anthropic). The result: 2,500 merges a day in May, over 30,000 in September, and Anthropic does not expect it to slow down.

To cope, the company had piled up workarounds: several hundred internal git mirrors, shallow clones, sparse checkouts. By its own estimate, naive git usage at this scale would generate more than 600 petabytes of traffic a day (AIM). Source control had become the main bottleneck in development.

The mismatch comes down to a few assumptions:

Anthropic was using git as a centralized system, when git was designed not to be one.

How Scion works

Scion starts from the opposite assumption: clients are always online. That changes five things.

The server does the work. Commits, merges, rebases and history queries all run server-side. A laptop or CI machine keeps only a small cache and its working copy, and fetches only the files it needs.

Everything goes through an API. Many jobs no longer need a copy of the code at all. A bot looking for the change that broke a test, or reverting a faulty change, queries the server directly.

No full copy exists anywhere. Data is spread across machines and stored in Spanner, Google Cloud's distributed database. Three cache tiers (per machine, per region, then the authoritative server) answer more than 99% of requests. The unit of work, the "changeset," is an entry in a log, as in a database, rather than a node in a commit graph as in git.

Testing happens after the merge. A classic merge queue locks the main branch while each change is tested. At agent scale, that lock becomes untenable. Anthropic merges first and tests afterwards, before deployment. Concurrent changes can conflict, but according to the team, "Claude can typically fix these conflicts faster than humans can even identify them."

Review changes nature. Reviewers check the intent of each change rather than every line. The review tool, Antique, applies rules by type of change: editing a comment needs fewer checks than editing code. Permissions are set directory by directory. And Claude instances nicknamed "superfans" each watch one component through its logs, to catch what conventional alerts miss.

Claude also helped build it. An early version of Claude Mythos rewrote the program that imports git history into Scion, which now uses 20 times less memory and runs 4 times faster. The team draws a more down-to-earth lesson: "Very often, we found that the role of the engineers was to tell Claude 'no.'" Agents sometimes broke system constraints, and much of the engineers' job was saying no.

What Scion is worth on its own merits

Big gains, measured only by Anthropic

Anthropic reports infrastructure that is 200 times leaner in CPU and memory than its old git mirrors, code checkouts in seconds instead of minutes, and 25% of CI compute capacity freed up. These are the company's own numbers. Nobody has measured them independently.

Few truly new ideas

Anthropic names its own models: Piper at Google and Sapling at Meta. Google moved away from standard tools more than a decade ago. In 2016, its single repository held 86 TB, served about 25,000 developers, and took 16,000 changes a day from humans and 24,000 from automated systems. Piper already ran on Spanner (Communications of the ACM). Google also runs most of its tests after code is submitted, with automatic rollback of faulty changes, a practice described as early as 2020 (Software Engineering at Google). Microsoft, for its part, kept git for Windows by adding a virtualization layer.

Criticism arrived within the day. Simon Willison called it "a reinvention of centralized source control along the lines of Subversion" (simonwillison.net). On Hacker News, where the post passed 840 points and 900 comments, former Googlers pointed out that Perforce already did all this. Others called a 100 GB history absurd, noted that centralization creates a single point of failure, or asked who really reviews 30,000 merges a day (Hacker News).

What is new: who reached this scale, and how fast

The pace is what struck us most. Google and Meta built their systems for tens of thousands of engineers, over a decade. Anthropic reached comparable scale with agents, and built Scion, its review tool, its code search and its access controls with seven people in five months, while merge volume grew more than tenfold. And where Google, Meta and Microsoft kept some compatibility with existing tools, Anthropic did a full migration.

What Scion is not

Scion is not a git alternative you can install. Anthropic writes that Scion "is by no means a suitable replacement for git for general use," and that it is "difficult to offer Scion in a form that would be broadly useful to other organizations." Adopting it would mean replacing the whole development lifecycle: review, search, CI. The company says it wants to share its ideas with GitHub, GitLab and git's maintainers.

Several articles claim Anthropic "confirmed" Scion would never be open-sourced. We found no such statement: the claim traces back to a line in The Register that the reporter does not attribute to Anthropic.

The problem goes beyond Anthropic

GitHub is living through the same thing at global scale. In September 2026, developers and agents made 7.38 billion commits there, more than five times the volume of September 2025. Pull request merges nearly quadrupled, and GitHub Actions ran 3.26 billion times in a month. GitHub puts it bluntly: "Agentic software development is driving the next architectural shift" (GitHub). In April, its CTO said the platform had to be designed for 30 times its scale at the time (GitHub). In August, an outage of almost eight hours was caused by a lack of capacity. According to Satya Nadella, one pull request in three on GitHub now involves an agent.

GitLab says the same in an architecture document from June 2026: "we see a significant rise in RPC calls that are caused by agentic workloads, and we expect this to accelerate" (GitLab). A single clone of its own repository takes 4 to 6 GB of memory on the server.

Mitchell Hashimoto, co-founder of HashiCorp, who pulled his Ghostty project off GitHub in April, puts it his own way: "The issue isn't Git, it's the infrastructure we rely on around it: issues, PRs, Actions" (The Register). What breaks first is everything built around git.

Git is not GitHub: open source forges hosted in Europe

When people say "git is overloaded," they mostly mean GitHub's servers. A company can run git elsewhere, with open source software, on its own servers or with a European host.

Forgejo is the rising open source forge. A fork of Gitea, GPL-licensed since 2024, its trademark is held by Codeberg, a Berlin-based non-profit. In April 2026, the Dutch government launched code.overheid.nl, a Forgejo instance it hosts itself, open to the ministries of Finance, Foreign Affairs, Agriculture and the Interior, and to the cities of The Hague, Utrecht, Leiden and Arnhem. GitHub was ruled out as proprietary, GitLab because of its "open core" model, where some features are reserved for the paid edition (It's FOSS). Fedora is moving to Forgejo too, and the Zig and Gentoo projects left GitHub for Codeberg, partly over GitHub's push for Copilot.

GitLab Community Edition remains the most common self-hosted choice, including in the public sector: the Adullact forge for French local authorities, the French education ministry's forge for digital commons, openCode in Germany, code.europa.eu for the EU institutions. GitLab is, however, an American company. Clever Cloud offers a managed GitLab hosted in Europe.

Other options include Gitea, SourceHut (based in the Netherlands) and Heptapod, a French GitLab variant for Mercurial maintained by Octobus.

The sovereignty argument is getting stronger. Since April 24, 2026, GitHub trains Copilot on interaction data from individual accounts unless users opt out (Business and Enterprise plans are excluded) (heise). We cover this kind of dependency in our article on Europe's digital dependence on the United States.

These forges do not solve the throughput problem. Codeberg runs on three servers, and in July 2026 its members voted to ban "vibe-coded" projects, including those "created by LLM 'agents' in autonomous ways," in part because a drive that cost €700 a few years ago now costs €3,700 (Codeberg). Since September, SourceHut has banned LLM-written content in new projects. A European forge answers the sovereignty question. Sizing for agent throughput is up to the company running it.

What will emerge for very large codebases

For most teams, git has no reason to go away. For a very large codebase with thousands of agents working on it, however, we think the git model no longer holds: a server that has to serve full copies, computation done on machines that live for a few minutes, a main branch locked for testing. What will replace it can already be read in the choices of GitHub, GitLab, Google and a few startups, which converge on six points.

Git stays on the developer's machine, the server changes completely

GitHub now separates storage from compute, keeps authoritative data in object storage and coordinates only branch updates, for up to 35 times more write throughput in internal tests. GitLab proposes the same architecture. The startup East River Source Control is building a server that speaks the git protocol without storing git repositories. Martin von Zweigbergk, creator of Jujutsu, joined it as CTO in September 2026, after fifteen years at Google. His diagnosis: "the remote server is still Git, which has a ceiling that comes fast for products at scale" (ERSC). Scion takes this logic all the way, dropping git on the client side as well.

Repositories become services you query

An agent does not need to clone 100 GB to read three files. GitLab is studying "repositories as a service," with a per-repository API, and cites agent workspaces as a use case. Anthropic calls on forges to standardize these server-side calls. Nobody has done it yet.

Working copies become virtual

The developer, human or agent, sees the whole repository, but only the files it opens are downloaded. Google has done this for years. Jujutsu, a git-compatible client, is now generally available inside Google, with a virtual file system in the works.

Merging happens later, and differently

Testing after merging, with automatic rollback, is becoming the norm at large scale. Merging itself is getting smarter: Mergiraf, an open source tool hosted on Codeberg, merges by understanding the structure of the code. Out of 7,415 conflicting merges in the Linux kernel, it fully resolves 428 (LWN). LLMs find the correct resolution in 55% to 62% of cases, according to a Virginia Tech study from July 2026 (arXiv). That beats classic tools, but it is far from reliable.

Intent is kept alongside the code

When an agent writes the code, knowing what changed is not enough: you need to be able to find the request that produced the change. Cursor proposes an open format, Agent Trace, that links each piece of code to the conversation that produced it. Entire, the startup of former GitHub CEO Thomas Dohmke, raised $60 million to store prompts and decisions with each commit. The Linux kernel already requires an Assisted-by: tag for code written with AI.

Every agent gets an identity and limited rights

Scion assigns permissions directory by directory and approval rules by type of change. Identity providers are following: in August 2026, Okta made single sign-on for agents generally available.

The emerging model

Mitchell Hashimoto talks about a "Gmail moment for version control": never delete, archive everything (The Pragmatic Engineer). For a very large codebase, the picture looks like this: git, or a compatible client such as Jujutsu, on the developer's machine; a distributed repository service queried through an API on the server; tests after merging; a record of intent attached to every change.

What IT leaders can take from this today

1. Keep git. Every tool knows it, and so do agents, since they learned to code on git repositories. Git keeps improving: version 2.56, released in September, computes some operations on a large monorepo in 0.01 seconds instead of 0.68.
2. Measure the share of agents. How many pull requests do agents open, and how long do they wait for review and CI? That is where the bottleneck will show up first, long before version control itself.
3. Pick your forge for sovereignty, then size it for agents. A Forgejo or GitLab Community Edition instance hosted in Europe works, provided you plan CI capacity, pull request caps per agent and controlled MCP access. We explain what MCP changes for agents in this article.
4. Review by risk. Anthropic tiers its code by risk, reserves human review for critical code, and has humans review a sample of the rest. Vercel merges 58% of pull requests in its largest repository without human review, based on a risk grid (Vercel). Reviewing intent rather than every line means writing down, for each type of change, what you expect from it.
5. Give each agent an identity and the fewest rights possible. An agent that can merge anything anywhere is a risk, just like an unrestricted service account. Our principles for enterprise AI agents apply here.
6. Look beyond code. At the hosting provider Neon, agents were already creating 80% of databases in October 2025. At Vercel, agents have triggered more than half of all deployments since June 2026. Ticketing, ERP, CRM, identity management and per-seat software contracts were designed for humans too. Netlify has a name for this: Agent Experience, the experience of an agent when it is the user of a product. The tools your agents will mostly use will come under the same pressure as git did at Anthropic.

Frequently asked questions about Scion and git

What is Anthropic's Scion?

Scion is the version control system Anthropic built to replace git on its main repository, announced on October 13, 2026. Unlike git, it runs commits, merges and history queries on the server, is queried through an API, and never keeps a full copy of the repository on client machines. Seven engineers built it in five months, along with a code review tool (Antique), code search and access management.

Why did Anthropic abandon git?

Because its main repository went from about 2,500 to more than 30,000 code merges a day between May and September 2026, and almost all of its users are AI agents and automated jobs that are always online. Git is designed for human developers who each hold a full copy of the code and can work offline. At that scale, serving those copies and running a merge queue had become Anthropic's main development bottleneck.

Is Scion open source?

No, and it is not available outside Anthropic. Anthropic says it would be difficult to make it useful to other organizations, since adopting it would mean replacing the entire development toolchain, and it plans to share its ideas with GitHub, GitLab and git's maintainers. Anthropic has not, however, announced that Scion will never be released: that claim, repeated by several sites, comes from a line in The Register that does not quote the company.

Should companies stop using git?

No, almost none of them should. Anthropic itself writes that Scion is not a replacement for git for general use. The problem arises for repositories of tens of gigabytes that take thousands of merges a day. Forges such as GitHub and GitLab are rebuilding their servers to absorb agent load, while keeping git on the developer side.

What is the difference between Anthropic's Scion and Google's Scion?

They are two unrelated projects. Anthropic's Scion is an internal version control system that replaced git. Google's Scion, released as open source on GitHub in 2026, is a testbed for running several coding agents in parallel, each in its own container with its own git working copy. There is also SCION, a network architecture developed at ETH Zurich, unrelated to either.

Which open source GitHub alternatives can be hosted in Europe?

The two main ones are Forgejo and GitLab Community Edition. Forgejo, GPL-licensed and governed by the Berlin non-profit Codeberg, was chosen in 2026 by the Dutch government for its public forge. GitLab Community Edition is widely used in European public administrations, but its vendor is American. Gitea, SourceHut and Heptapod are other options. All of them can be self-hosted or run by a European hosting provider.

---

Git is doing fine, and most companies will keep it for a long time. Scion shows something else: a tool designed for humans eventually gives way when its main users become agents. Anthropic had the means to rebuild everything in five months. Everyone else will wait for GitHub, GitLab or a startup like ERSC to do it for them.

For IT leaders, the useful exercise is to identify which tools in their stack will soon be used mostly by agents, and to measure where they will jam. Version control will rarely be the first.