Suppose one of us asks an agent to change how session expiry works. A teammate starts another agent on a sign-in bug. Each patch passes in its own worktree. The combined tests fail because the patches assume different rules about when a session expires. By then we have two diffs to read and a decision we could have made before either agent wrote code.
We’re building AgentSCM for teams that already start agents this way. The question we care about is what the teammate’s agent can learn about the change while there’s still time to do something with that information. Sometimes that’s as simple as finding out who’s working on session expiry and asking which rule they settled on.
How often agent pull requests overlap
GitHub’s 2026 Octoverse reported that more than 40% of pull requests on GitHub in September started with an agent’s first draft, up from 17% in March. GitHub counted agent involvement at the start of a PR, including drafts that developers could revise afterward. To see how often that work overlaps in a repository, we have to look at the lifetimes of the PRs themselves. GitHub Octoverse 2026
George Xu and colleagues looked at an earlier public GitHub dataset. In 40.2% of the repositories they studied, at least two agent PRs were open at the same time. Only 0.5% of those co-active pairs came from different agent products. The researchers also replayed merges on a sample of overlapping pairs. Git reported textual conflicts in 41.7% of evaluable mixed-product pairs, versus 19.8% of same-product pairs. The higher rate comes from a replay sample with 115 mixed-product pairs and measures how often Git needed help combining the diffs. It says little about how much work it took to resolve a conflict. The rarity of mixed-product overlap is a reason to take coordination inside a single tool seriously. We have much less visibility into how private teams work. Our own audit is one data point: 175 of our 875 merged PRs were still open when another PR merged changes to a file they also touched, which we wrote up in One in five of our PRs was open when another change landed on the same files. Xu et al.
A clean merge can also break behavior. In Passes Alone, Fails Together, the authors had agents redo tasks from pairs of real, merged Django PRs and found one instance of semantic interference in 834 runs. Review and integration may already have made those tasks easier to combine. In a separate experiment, the researchers deliberately changed interfaces that another patch depended on. Interference occurred in 97% of runs when the agent worked without an update. When the researchers sent a message describing the completed concurrent change, 82% of runs recovered. We’d try sending an agent a specific update when we know its work depends on a changed interface. We’d want more evidence from ordinary development before interrupting agents every time nearby code moves. Xia et al.
At one software company, a longitudinal study found that merged PR throughput rose as developers adopted AI coding tools and the review load per reviewer doubled. For engineering leads, the time it takes to get a draft diff is only part of the cost. If the same reviewer has to untangle two changes to session handling in the same afternoon, the speed of either agent says little about when the work will land. He et al.
When one agent should do the writing
On ParallACT, a single Claude Code agent that saw both specifications solved 62% of contradictory task pairs in one configuration, versus 16% for parallel agents. A channel for the peers to talk recovered only a small part of that gap. Anthropic’s Worse Together found that one coordinator outperformed teams of separately delegated agents across four simulated environments where the agents had to share a resource. Cognition’s account of what has worked in practice describes letting several agents investigate while keeping writes single-threaded. ParallACT, Anthropic’s study, Cognition’s follow-up
If a migration and a feature both need to decide what constitutes a valid session, we’d give one writer both briefs. Other agents can trace callers or read the tests and bring their findings back. That works when one person sees both requests and can put them together. On a team where people pull their own tickets and start agents independently, someone has to spot the shared decision first. We’d count it as a good outcome if they spotted it early and gave the work to one writer.
What worktrees and forges already cover
Worktrees, PRs and a merge queue are a strong default. Give each agent a worktree and it can edit its own checkout. Reviewers use the PR to see the diff and apply branch policy. The queue checks each candidate against the target branch and any PRs ahead of it. With clear ticket ownership and good integration tests, a team can handle a lot of parallel work this way. In the session expiry example, the queue can catch the test failure even if the patches arrive hours apart and Git can combine them cleanly. Git worktrees, GitHub merge queues
Coding tools already cover some of the work before the PR. Claude Code’s Agent Teams lets sessions claim tasks from a shared list and message each other. The Codex app gives people threads and worktrees for parallel jobs. GitHub’s Agent HQ lets people assign Claude, Codex and Copilot to tasks, including assigning the same task to several agents when a person wants to compare their work. Agent Merge can fix failing Actions workflows or resolve merge conflicts from the PR. That’s a distribution advantage for GitHub. Reviewers already go there to see the diff and manage the checks, and GitHub can put the next coordination feature in the same place. Claude Code Agent Teams, Codex app, Agent HQ, Agent Merge
MCP Agent Mail already provides agent messaging and advisory file reservations. An issue tracker can tell you who owns a task when you come back tomorrow. With AgentSCM, we want the coding agent you start tomorrow to be able to look up where the work stopped and match that record to the source and checks from the earlier session. It does that through the team’s Hub for that repository, even when someone else started the work in a different connected tool. MCP Agent Mail, AgentSCM Work and catch-up guide
What the AgentSCM Hub keeps
The Community Edition has a self-hosted Hub that connects to existing coding agents. It keeps durable Work records that outlive the sessions that created them. A record can hold the scope and owner, along with decisions and blockers a teammate would need for a handover. A fresh session can look up unfinished work, and a returning session can catch up from the point it previously acknowledged. If a merged PR changes a file the agent is working on, AgentSCM can prompt the agent to update its branch. AgentSCM Work and catch-up guide, Hub guide
For ordinary same-file coordination, a supported pre-edit hook refuses the first attempt to edit a file another agent holds. It names the holder and gives the incoming agent a chance to ask for a handover or switch tasks. A retry goes through while the same hold is in place. If the hook fails, the edit goes through. Once a session declares Work, the check is stricter: an edit not linked to that Work, or made after the Work’s lease lapsed, is refused until the session starts or checks in on it. We made the file warning advisory because file overlap is a rough signal. Two people can edit separate functions in a file without interfering, and incompatible decisions about an interface can end up in different files. Claude Code is the reference integration. Cursor can receive a note after editing, and an agent connected only through MCP has to ask for advice. AgentSCM agent support
AgentSCM can keep evidence alongside Git, such as the command a session recorded and the source state it applied to. That gives a reviewer a place to look up which revision a reported test result refers to. Recorded checks and reviews are not independent proof of execution. The experimental native workflow in Claude Code can require checks and explicit human approval for a particular revision before it lands through that workflow. Git and the forge retain merge authority over the ordinary routes. Change capture, native workflow
Our advice for the alpha is “try it, don’t depend on it.” We haven’t qualified production security or scale. The Community Edition is source-available under FSL-1.1-ALv2 and installs with npx agentscm. A hosted version that we run, so teams don’t have to run a Hub themselves, is planned, with no launch date yet. AgentSCM on GitHub, AgentSCM documentation
What would make the Hub worth running
We’d start with a repository that already uses worktrees, PR review and a merge queue, and where people regularly pick up changes someone else started. Before adding the Hub, we’d track how long it takes a new session to resume an unfinished task and how much reviewer time goes to reconciling overlapping changes. During the pilot, we’d record which warnings actually changed what someone did next, including cases where an agent retried immediately and that was the right call.
If the team spends just as long sorting out overlaps in review, we’d want to know whether handovers alone justify running the service. We’d time how long it takes a teammate to find the relevant revision, recover the reason for an unfinished change and make the next correct edit. Any time spent keeping the Work record current belongs in that comparison.
