Anthropic went from 2,500 merges a day to more than 30,000 in four months. Git broke, and seven engineers replaced it in five months. Their write-up is worth reading.
The most interesting line is about what happens when two agents change the same thing. Their system lets both changes land, then relies on tests, and on Claude, to clean up.
That works when you are Anthropic. It is also the question every team running coding agents is about to face, and most teams do not have a pipeline like theirs to fall back on.
There is another way: stop the collision before it happens, and keep a signed record of every decision along the way. That is what Nool does, and there is a side-by-side comparison with Scion if you want the detail.
Two different problems
Anthropic's problem was size: about 100 GB of history and 25 million CI checkouts a day. They moved commits and merges to a server, dropped git's packfiles and put caches in front of everything, with cache hit rates above 99% and checkouts in seconds. It is excellent engineering, and it is internal to Anthropic.
Most companies have a different problem. They have many repositories, several agents working at once, and a security team that wants to know who changed what and why. That is the problem Nool is built for, and you can install it today.
Coordinate first, clean up never
Nool sits between the git repository you already have and the agents working in it. Think of it as a signed ledger of who intended what. It does not replace git, and your agents do not have to change.
Before an agent edits anything it does three things.
First, it says what it plans to change and claims those files.
Second, it checks what other agents are doing. If the claim overlaps, it finds out now.
Third, it submits the change with its reason attached, and Nool checks it before it lands.
nool announce intent --agent-id api-agent --intent "Add rate limiting" --target-nodes src/api/limits.ts
nool discover conflicts --as-agent api-agent src/api/limits.ts
nool propose --as-agent api-agent --path src/api/limits.ts --intent "Add rate limiting" --solidifyThe collision becomes a message at the door instead of a failing build an hour later. What the agents learn along the way is recorded, so the next session starts with it.
The results
We ran a pre-registered benchmark with 35 agents working 60 tickets:
- Plain git fleet: 33 to 62% of tickets accepted.
- Nool: 98 to 100% accepted, with zero merge conflicts.
Nool's fleet planner splits the work into waves that cannot collide, and its checks keep protecting you when agents misjudge which files they will touch. Landing a change adds a few hundred milliseconds, which disappears inside the time of the model call before it. The method and full data are published, and the same approach scales from one machine to fleets across cloud sandboxes.
What it looks like on a real project
We build Nool with coding agents, so we can read the results from our own ledger. Over seven weeks on one project:
- Throughput roughly tripled. Accepted changes went from 72 a week to 233.
- Spend stayed flat. Weekly agent cost held between about $170 and $300, so cost per accepted change fell from about $3.60 to about $1.
- Tasks close fast. The median task goes from created to complete in 4.7 hours.
- Changes land clean. 98.6% of test runs, 97.3% of policy checks and 96.1% of health checks passed on the first attempt.
- Almost nothing is rolled back. One revert in 878 accepted changes.
Across every project on one machine, that is about 7,000 recorded changes and 70,000 agent interactions, with 15 of 16 projects keeping a single linear history.
Why enterprises can adopt it now
Most companies are not choosing between Scion and Nool. They are choosing what to put in front of their agents this quarter.
- Your repositories stay where they are. GitHub, GitLab and your CI keep working.
- Any agent, any model. Claude Code, Codex and Copilot share one history, and the MCP server works with other agents.
- Approvals you can show an auditor. Signed human approvals and test evidence sit on every change. See AI code governance and security.
- Spend is a control. Token budgets and per-agent caps are part of the tool.
- It nests. One repository, or a workspace of many projects with health and cost rolled up.
A faster store makes agents quicker. These controls decide whether a company lets them run unattended at all.
Measure what matters
Merges per day tells you how busy the pipeline is. It does not tell you whether the work was worth doing. If you are running agents, track four numbers, each divided by accepted changes: cost, time, defects and the health of what landed. A system that lands fewer, cleaner changes should beat one that lands more and reworks half of them.
Nool records the evidence for cost, time and health on every change, and it can link each bug to the change that introduced it, so escaped defects per accepted change become a number you can chart.
See it on your repo
How do you handle two agents editing the same file today: a lock, a merge queue, or fixing it in CI?
If the answer is "we hope they do not", try the other approach. Start with five Claude Code agents on one repo, or set Nool up on your own repository in a few minutes. Teams can compare plans and pricing, and the Nool vs Scion comparison has the full feature table.
*Update, November 3, 2026: OpenAI has now published its own answer, a git backend called Pando. We compared it with Nool in OpenAI Rebuilt Git for Codex.*
Update, November 2026
Pando and Origin have joined Scion in the same conversation. What is agentic version control? puts all five systems side by side.