Skip to content

Blog

Agent-paced merging turns the merge queue into a database problem

The merge queue used to be a scheduling problem between people. With agents opening changes around the clock, it becomes concurrency and conflict resolution against shared state.

Written by

Software Factory

Published: 10 September 2026 Updated: 2 min read

The merge queue used to be a calendar. Whose pull request goes first, who is waiting on whom, can we land this before the release. It was a coordination problem between people, solved with a bit of process and a bit of patience.

I think that is about to stop being true, and the reason is worth thinking through before it lands on your repo.

The old queue assumed human pacing

The old merge queue assumed human pacing. A handful of pull requests a day, opened by people, on their schedule. Conflicts were rare because the inputs were slow and a person could see them coming. Merging was scheduling: order the queue, mind the calendar.

Agents bring many concurrent writers

Agents remove that assumption. When they work the line, the inputs are not slow: many changes are in flight at once, opened around the clock, each one touching a live codebase that several other changes are also touching. The thing you are now managing is many concurrent writers contending for shared state, with conflicts that have to be detected and resolved correctly and fast.

That is a database problem

That is a database problem, not a project-management problem. We have a whole mature field for exactly this shape, concurrent transactions against shared state:

  • Isolation, so two changes do not corrupt each other.
  • Conflict detection, so a clash is caught, not merged blind.
  • Serialization, so the end result is consistent no matter the interleaving.
  • Retry, so a losing transaction reruns cleanly against the new state.

The same machinery, spelled in code changes

A merge queue under agent load needs the same machinery, just spelled in the language of code changes. Detect that two pull requests touch overlapping behavior. Decide an order that stays correct. When one cannot land cleanly, rebase or regenerate it against the new reality and check it again, automatically, without a human in the loop for the routine case.

The teams that struggle here will be the ones treating a concurrency problem as a staffing problem, adding a release manager to a queue that needs a transaction model.

When several agents change your codebase at once, what actually resolves the conflicts, and is it a process or a system?

Further reading

  1. Run retrospectives for your agents, not just your team Teams run retros to improve how humans work, but agent mistakes die with the session. Saving sessions, letting a retro agent mine them and turning failures into config rules makes the learning compound. 2 min readShort post
  2. Six developer experience investments that outlast the next model Most agentic tooling bought this year will not survive the next model generation. Six fundamentals will, because what is good for human developers turns out to be good for agents. 2 min readShort post
  3. Put your coding agents in the outer loop The inner loop is your IDE, the outer loop is CI, review automation and scheduled upkeep. Most teams put agents in the inner loop, but the work that compounds lives one loop out. 2 min readShort post

All 23 posts on Software Factory

ClientsClient work

Test the constraint in your system

The Factory Readiness Assessment connects this research to your value stream, your data, and the next decision.

Training on this topic: Agentic Software Factory: Advanced Team Training
See the assessment

Want to check one team first? The self-check: twelve yes or no questions, three minutes, instant result, no account. Take the self-check