18 conflicts, 5 branches, 0.97 seconds.

We simulated 5 AI agents working on the same repo. Git merged everything cleanly. Tests passed on every branch. Here's what was actually broken.

The setup.

We built a demo repo with a Python backend, a TypeScript frontend, Go services, a Ruby mailer, and cross-language API contracts. Then we created 5 branches, each simulating a different AI coding agent making independent changes.

Alice (Cursor)

Python backend. Changed the order API, added required fields, updated route handlers.

Bob (Copilot)

Go services. Refactored the payment service, changed function signatures.

Charlie (Codex)

TypeScript frontend. Built checkout page against the old API contract.

Dave (Claude Code)

Cross-language work. Updated auth module, changed validation signatures.

Eve (Windsurf)

Ruby mailer. Changed email templates and notification triggers.

Every branch passes its own tests. Every branch merges cleanly with main. Git sees no conflicts because the agents touched different files. A human reviewer looking at any individual PR would approve it.

But across branches, there are 18 structural incompatibilities that could cause runtime errors when they merge.

What the engine found.

We ran rosentic scan-all against the repo. It checked all 10 branch pairs in 0.97 seconds on a warm scan. Here are some of the conflicts it caught:

Sample conflicts detected

Alice ↔ Charlie API contract

Backend requires shipping_id. Frontend doesn't send it.

Alice ↔ Charlie URL mismatch

Backend route is POST /orders. Frontend calls POST /order.

Bob ↔ Dave Signature

validate_token() now requires 2 params. Caller still sends 1.

The API contract conflicts are the most dangerous. Alice changed the Python backend to require a shipping_id field on the order endpoint. Charlie built the TypeScript frontend against the old API that didn't require it. Both branches pass their own tests. Both merge cleanly. The frontend breaks on the first order submission.

The URL mismatch is the kind of thing that's almost impossible to catch in code review. One agent used /orders (plural), the other used /order (singular). Both are valid paths. Neither is wrong in isolation. They just don't match.

The numbers.

Conflicts found

Branch pairs checked

0.97s

Warm scan time

Cold scan (first run, no cache): 1.6 seconds. Warm scan (cached index, no branches changed): 0.97 seconds. The persistent index caches each branch's HEAD commit hash and skips re-indexing branches that haven't moved.

We also ran it against a production codebase - 46,690 lines of code, 235 files, 5 active branches. 10 conflicts detected. 11.3 seconds warm, 29.6 seconds cold.

What this means.

This is a demo repo designed to show the problem. Real codebases are bigger and the conflicts are subtler. But the pattern is the same. Agents work independently, push independently, and create incompatibilities that no existing tool checks for.

The question isn't whether your agents are creating cross-branch conflicts. They are. The question is whether you're catching them before they hit main.

You can run this yourself. The demo is interactive and runs in your browser. No install, no signup.

Run the demo.

Watch the engine scan all 10 branch pairs and find every conflict.

Try it now