Most of AgentSCM gets written by Claude Code and Codex sessions running in parallel on the same repos. Before shipping anything we went back through our own PR history to count how often two sessions had edited the same files with neither of them aware of the other.
175 of our 875 merged PRs (20.0%) were still open when another PR merged changes to a file they also touched, on the same target branch. For the AgentSCM repo on its own it was 30 of 86, or 34.9%.
All of the numbers in this post come from our own repos and a couple of small experiments. No customer data yet.
What we counted
Audit cutoff was 26 October 2026. The question per merged PR: while it was open, did any other PR merge a change to one of the same files on the same branch?
| Scope | PRs exposed to same-file overlap |
|---|---|
| Company repositories in the core cohort | 175 / 875 (20.0%) |
| AgentSCM repository only | 30 / 86 (34.9%) |
| All 22 accessible repositories | 277 / 2,038 (13.6%) |
On its own, sharing a file proves very little (lots of PRs touch the same file and merge fine, and our file lists include docs and config), so we replayed the merges in Git. Between 5 June and 25 October we could rebuild 226 integration parent pairs. 131 of those conflicted, spread over 97 PRs, and 95 replayed cleanly.
Those are conflicts that actually happened in our history. How many of them AgentSCM would have caught is a separate question, and we haven’t measured it.
Where the tokens went
Git at least stops you on a conflict. What costs more is an agent that carries on building against code another merge has already changed, and nobody notices until review.
In one AgentSCM PR, 8.44M of 28.77M review tokens (29%) were spent in three late rounds of test-and-fix review. 98% of that was cached input: each small fix sent the reviewer back through a large context that had barely changed. Cached tokens are priced well below fresh ones, so read the 29% as a measure of repeated work rather than of the bill.
PR #122 is the CI version of the same story. Its captured history shows 47 workflow runs, 82 jobs, four merges from main and 366.83 runner-minutes, and every one of those runs was a first attempt, not a retry. Separately, across 27 PRs we found 43 repeat runs of the same format and lint checks on the same revision, worth 53.35 runner-minutes. At private-runner prices that’s about $0.46, and on public runners it cost us nothing, so CI waste is not where the money is for us.
What AgentSCM does
It sits beside Git and the GitHub or GitLab flow you already have. You keep merging the way you merge now. There’s a Hub (you host it) that agents and people report to, plus hooks for the agents you already run.
Shared intents and overlap notices. Each agent declares the files it’s working on. When a second agent tries to edit a file somebody else has claimed, the hook turns that first edit down, once per session and file, and tells both agents who holds the file and why. The agent can then coordinate or hand the work over. If it tries again, the edit goes through, and if the hook itself breaks, edits go through too. We kept it that weak deliberately; a lock that fails would stop every agent behind it.
Collision checks on plain Git. Before installing any of that, you can check whether your branches and worktrees already overlap. No Hub needed, nothing to migrate:
agentscm collisions --worktrees
Checked 2 branches/worktrees against main · 1 pair touches the same files · 1 would conflict in git
Would conflict (git merge-tree):
feat-invoices ↔ feat-rounding billing.rs
Under the hood it runs git merge-tree read-only, and it lists real conflicts separately from pairs that only share a file.
A record you can hand over. Work claims and handoffs live on the Hub. Picking up a task, you can see who owns it and which checks ran on which source, because change capture links each observed command to the commit or working tree it ran against. Missing or stale evidence shows up as missing or stale.
Checks before expensive review. The experimental native workflow binds required evidence to one exact revision. During local alpha qualification it refused approval when evidence was missing, had failed, or no longer matched the source, and it let current passing evidence through.
A small test of checking first
Does running cheap checks before an agent review save anything, or only move the cost somewhere else? To find out we took small Python candidates and ran each one two ways: review, fix, re-review; or check, fix, then a single review.
Two defect cases came out with equal final quality on both paths. For those two, checking first used 57,233 tokens against 86,277 (33.7% fewer). Final code was identical, checks passed, the last review was clean, and model calls went from 6 to 4. The saving is one skipped review call per case and nothing else.
Before anyone quotes that number:
- Six synthetic pairs, 24 model calls, all on Haiku. Only two defect pairs and one clean control qualified, and the full six-pair study failed its own quality gate.
- On the clean control, checking first cost 34 extra tokens. With nothing to catch, the check is pure overhead.
- We told the review-first reviewers not to run checks. If your agents already test before review, reordering won’t buy you much.
- Initial generation and AgentSCM’s own runtime cost weren’t counted.
What it shows is the mechanism working on toy problems, at a scale far too small to predict savings on real work.
When we added process and it got worse
Earlier on we tried 24 sessions in which AgentSCM only told agents the repository rules and enforced nothing. Those sessions used 15.3% more tokens and followed the rules no better. In a separate handoff comparison both sides got the right answer, and ours took 67.4 seconds to the other side’s 56.3, scheduling included.
Agents pay to read instructions whether or not they follow them. Since that pilot the work has gone into hooks and gates that act at the edit or the approval, and we record overhead in the same table as savings.
Others working on this
A few other teams are on the same problem, and if AgentSCM isn’t a fit one of these might be.
| Project | Approach |
|---|---|
| Overlap | Reads agent session logs, warns on same-file or same-line edits and blocks the conflicting edit until coordinated. MIT, self-hosted on Cloudflare. |
| Foremerge | Agents declare semantic scopes (a symbol, an endpoint) before editing; clashing plans get advisory warnings. Apache-2.0, local-first. |
| Entire | A Git forge that stores prompts, decisions and agent sessions alongside commits, with eval-driven review in place of PRs. |
| garden | Describes itself as source control built for agents. Little public detail so far. |
Where Overlap blocks, AgentSCM warns once at file level and then gets out of the way. Like Entire it keeps intent and evidence next to the work, though you stay on your current forge. The part we’re betting on is binding checks and evidence to exact source, so an old green run can’t approve code it never saw.
The limits
AgentSCM is alpha software. CLI, APIs and storage may change with no migration path, and production security and scale haven’t been qualified. Git and your forge still decide what merges; native gates don’t see raw pushes or forge merges. Capture is fullest for Claude Code, and Codex exposes a lot less. It’s licensed FSL-1.1-ALv2, source-available, converting to Apache 2.0 after two years.
What we’d really like to report is total cost per accepted change at equal quality, with AgentSCM’s own overhead included, and we can’t yet. That needs teams running several agents on shared repos through weeks of normal work, measured with and without coordination, and our own history can’t stand in for that.
Try it
The scripted demo spins up a throwaway local Hub, pushes three simulated agents through the real hook endpoint and opens the status page. No account, no Docker, no forge, and it doesn’t touch your repository.
npx agentscm demo
To connect your own agents:
npx agentscm
Code is on GitHub; setup and limits are in the docs. If you’ve had two agents in one repo this month, run agentscm collisions on it and send us what comes back. False alarms are the most useful.
