Why AI coding agents create merge conflicts (and how to prevent them)

In a study of 107,026 real-world pull requests, 27.67% of AI agent PRs hit merge conflicts. The cause is rarely the diff itself. It is that two agents quietly built against two different ideas of the same interface, and nobody found out until merge day.

Merge conflicts are as old as version control. What is new is the rate. AI coding agents write more code, faster, and in parallel across a team. That speed is the point, but it also means more changes are in flight at the same time, each one made by an agent that cannot see what the others are doing. The 27.67% figure comes from AgenticFlict, presented at ACM AIware 2026: measured, not hypothetical.

Why agents collide

An AI agent works from its own context window. It sees the files it has read, the prompt you gave it, and whatever its tools return. It does not see your teammate's open editor on another laptop, and it does not see a change that has not been committed yet. So when two developers point their agents at the same area of a codebase in the same afternoon, each agent makes locally correct decisions that are globally incompatible.

Two failure shapes dominate. The first is a textual conflict: both agents edit overlapping lines, and Git cannot reconcile them. Annoying, but Git flags it loudly. The second is worse: a semantic conflict that merges cleanly and then breaks. One agent renames a function, changes a return type, or adds a required field. Another agent, working in parallel, writes a dozen call sites against the old shape. Both diffs touch different files, so the merge succeeds. The build, or production, fails later.

Contract drift is the root cause

The deeper problem behind both shapes is contract drift: the gap that opens when two agents hold different versions of the same interface. An interface contract is the shape both sides agreed on, an endpoint signature, a shared type, an event payload. The moment one agent changes that shape without the other knowing, the contract has drifted, and every line written against the old shape is already wrong. It just has not failed yet.

Why existing tools miss it

Continuous integration catches the conflict, but only after the PR exists, which is the most expensive moment to find it. The agent has already finished, the developer has moved on, and unwinding the work means rebuilding context that both agents have since lost. Code review has the same timing problem. Type checkers help within a single repository checkout, but they cannot see a change a teammate has not pushed. None of these tools close the window where the collision is cheap to fix: while both agents are still in the session that created it.

How cross-machine sharing prevents it

The fix is to make the contract change visible to every agent the moment it happens, not the moment it merges. That requires sharing a small amount of state across machines: which contracts exist, what shape they are now, and who just changed one. Crucially, this is not source code. It is the interface metadata an agent explicitly publishes.

Aethereum does this through three MCP tools that any agent can call. When an agent changes an interface, it declares the new shape. Every other agent that depends on that contract sees an alert the next time it pulls team context, while it is still working, before it writes anything against the stale shape.

copy
// backend agent, machine A
declare_contract('POST /users', '{ email, displayName }')
// frontend agent, machine B, minutes later
get_team_context()
// → alert: contract 'POST /users' changed; you depend on it

The collision that would have surfaced as a failed build on Friday surfaces as a one-line alert on Wednesday, while both agents still remember exactly what they were doing. The merge becomes a non-event because the drift never happened. To set this up, run npx aethereum init and read the documentation. It is free to start.

Takeaway

AI agents do not collide because they write bad code. They collide because they cannot see each other. The 27.67% conflict rate is a visibility problem: contracts drift in the gap between change and discovery. Close that gap by sharing interface contracts across machines in real time, and most of those conflicts never get the chance to form.