Quick answer: Anthropic Scion is the in-house version control system Anthropic built after coding agents pushed its monorepo from about 2,500 merges a day in May 2026 to more than 30,000 a day by September. Scion runs commits, merges and rebases on the server. It’s internal, and Anthropic says it isn’t a general replacement for Git.
What Anthropic did with Scion, and why
On October 13, 2026, Anthropic’s engineering team published Redesigning source control at Anthropic. The opening claim is blunt: “coding is no longer the bottleneck to building systems or doing research.” The bottleneck, they write, is “all of the developer infrastructure built for human scale: source control, builds, and CI.”
The numbers explain why. In May 2026 the company merged around 2,500 code changes per day. By September it merged over 30,000. That’s a twelvefold jump in four months, and Anthropic attributes it to agents doing the coding.
Git held up at human scale. At agent scale it buckled. Anthropic reports about 25 million CI checkouts per day, a main-branch history near 100 GB, and several hundred internal Git mirrors at peak. A naive fetch strategy would have meant over 600 PB of Git traffic a day.
So a team of seven built Scion, a code review tool called Antique, code search, and a per-directory access system. They migrated the monorepo off Git in five months. Anthropic even had Claude Mythos Preview rewrite the Git-to-Scion ingestion pipeline, and the rewrite used 20x less memory and ran 4x faster.
If you run Claude Code, Codex or another coding agent across a team, this post is a preview of your own next bottleneck. Sharkly is built around that problem: it keeps agent work, results and review on shared Tasks instead of in scattered terminals.
How Scion differs from Git
Git assumes every clone is a full, self-sufficient copy of history that works offline. Scion assumes the opposite: clients are always online and compute little on their own.
| Git | Anthropic Scion | |
|---|---|---|
| Where commits, merges and rebases run | Locally, on your laptop | On the server |
| Local data | Full history | A bounded object cache, sparse or virtualized checkout |
| Unit of work | Commit pointing to a tree | Changeset in a write-ahead log, listing changed files |
| Branches and refs | Cheap and encouraged | Discouraged except main and release branches |
| Fetch | Packfiles | Per object (trees, then blobs), no repository maintenance |
| Offline work | Yes | No |
| Main clients | People | Agents, CI and research jobs |
The architecture has three tiers: scion-daemon on each node, scion-cache per region, and an authoritative scion-server. The client CLI is scn. Cache hit rates sit above 99% at each tier.
The payoff is large. The CPU and memory footprint is 200x smaller than the old Git mirroring setup. CI and research checkouts take seconds instead of minutes, and CI gained 25% CPU capacity.
What you give up with server-side commits
Server-side commits give up the property that made Git win: a full local history you can work against on a plane. Anthropic says so directly. Scion is “by no means a suitable replacement for git for general use,” and offering it in a form other organizations could use would be difficult. It isn’t released, and the post doesn’t describe it as open source.
The concurrency story also differs from what you’d expect. Anthropic doesn’t serialize every merge behind a global lock. Concurrent changes can conflict, and the team catches that with post-merge and pre-deploy testing.
Git for AI agents: the lesson for teams without Scion
You won’t get Scion, and you don’t need it. Your repo isn’t 100 GB, and you aren’t running 25 million checkouts a day. The useful part of the post is the shape of the problem, which shows up at any scale.
When agents write the code, the bottleneck moves downstream. It moves first to merging, then to review. DevOps.com’s coverage and TechSpot’s write-up both frame Scion as infrastructure catching up with agent output. A five-person team running ten agents hits a smaller version of the same wall.
You’ll recognize the symptoms:
- Two agents edit the same file in the same afternoon and you resolve the conflict by hand.
- Pull requests pile up faster than anyone reads them.
- CI queues get longer every week while the agents stay fast.
- Nobody can say which agent changed what, or why.
- A branch from Tuesday rebases into a mess on Friday.
Anthropic attacked items 1 and 3 with new infrastructure. You can attack all five with process and Git tools you already have.
Coding agents merge conflicts: why they multiply
Merge conflicts scale with overlap, not with headcount. Ten agents working on one broad goal touch the same files constantly. Ten agents working on ten narrow tasks rarely collide. The size of each task matters more than the number of agents.
Long-lived branches make it worse. Every hour a branch stays open, main moves under it. Agents make this sharper because they open branches faster than people close them. Our earlier piece on how many agent workdays one human workday can review puts numbers on that gap.
What you can do today without Scion
These five habits cover most of what a normal team needs. None of them requires new version control.
Give every task its own worktree
A Git worktree is a second working directory attached to the same repository. One worktree per task means two agents never write to one directory at the same time.
git worktree add ../tasks/COIN-212 -b agent/COIN-212 origin/main
cd ../tasks/COIN-212
# run the agent here, commit, push, open a PR
git worktree remove ../tasks/COIN-212
We cover the setup in Git worktrees for AI coding agents and the cleanup side in managing worktrees without the cleanup pain.
Keep tasks small and scoped
Write each task so it names the files or module it may touch and the check that proves it’s done. A task that fits in one reviewable diff merges cleanly. A task that says “refactor auth” doesn’t.
Put a merge queue in front of main
A merge queue tests each pull request against the latest main plus everything ahead of it, then merges in order. GitHub’s merge queue does this for protected branches. It’s the small-team version of what Anthropic handles with post-merge testing: you stop finding out about broken combinations after they land.
Tie review to the task, with evidence
A diff alone doesn’t tell a reviewer what the agent was asked to do or what it checked. Review goes faster when the request, the run, the test output and the diff sit in one place. See how to review AI-generated code with task-level evidence and why human review becomes the bottleneck.
Make agents wait for approval
Let agents research, write, test and report. Let people set direction, approve risky steps and accept the result. An agent that stops and waits for a human before merging costs you minutes. One that merges unreviewed work into main costs you a day. Our guide to approval gates for coding agents shows where to put the stops.
Where Sharkly fits
Sharkly doesn’t replace Git, and it doesn’t resolve merge conflicts. Your agents still commit to your repository through your existing Git host. What Sharkly organizes is the work around those commits.
Each piece of agent work is a Task with an Assignee, a status and an execution record. Agents run on your own Computers, using the Claude Code, Codex or other runtime you already pay for. In Temporary mode, each Task gets an isolated directory, and repository-backed runs can prepare a separate worktree, so concurrent Tasks don’t write to one shared folder.
When an agent finishes, it can leave the Task waiting for human review. That signal lands in Inbox, where the responsible person opens the Task, reads the result in context, and decides to accept, retry or reassign. Task execution and its follow-up discussion return to the Task timeline, so the board becomes your review queue.
The combination is the Git-side habits above plus one shared place for request, run, evidence and decision. If you’re comparing options, our roundup of tools for managing parallel coding agents covers the field.
Who should act on this now
Teams with three or more agents running daily. You’re close to the merge wall. Add worktrees and a merge queue this week.
Solo developers running agents in parallel. Your bottleneck is review, not merging. Shrink tasks until each diff takes under ten minutes to read.
Platform and infra leads. Watch your CI queue time and PR age. Anthropic’s post says source control and CI broke before anything else did; expect yours to break in the same order. The parallel agents with isolated worktrees setup buys you time.
Conclusion
Anthropic Scion is a signal, not a product you can adopt. Anthropic’s merge volume grew twelvefold in four months, Git’s offline-first design stopped fitting, and a seven-person team rebuilt source control for clients that are mostly agents. Most teams will never need that.
Every team running coding agents will meet the same shift, though. Writing code gets cheap, and merging and reviewing it gets expensive. Isolate each task, keep tasks small, queue your merges, and review against evidence.
To put the review half in one place, connect one Computer to Sharkly, create one Agent, and assign it a small, low-risk Task. Watch where the result lands, and decide from there.
FAQ
What is Anthropic Scion?
Scion is Anthropic’s in-house version control system. It replaced Git for the company’s monorepo in 2026. The server performs commits, merges and rebases, and clients keep only a bounded local cache.
Why did Anthropic replace Git?
Coding agents raised daily merges from about 2,500 in May 2026 to over 30,000 by September. Git mirroring, checkouts and CI couldn’t keep pace at that volume, so source control became the main bottleneck.
Is Scion open source or available to use?
No public release exists. Anthropic says Scion is not a suitable general replacement for Git and would be hard to offer to other organizations. It shared the design so others can apply the ideas to Git.
How do I reduce merge conflicts between coding agents?
Give each task its own worktree, keep tasks narrow enough to fit one reviewable diff, merge often, and put a merge queue in front of main. Conflicts track file overlap, so scoping matters more than agent count.
Do small teams need a new version control system?
Almost never. Anthropic’s problem came from a 100 GB history and 25 million checkouts a day. At normal scale, worktrees, merge queues and task-level review handle the load.
