Two AI agents, one repo — main kept breaking, so I built a PR traffic controller as a GitHub App

#github #ai #programming #productivity

What I built

Veripsa Core is a GitHub App that warns you — before merge — when open PRs are about to collide on main.

Install it on a repository and covered pull requests get an advisory check.

Install: https://veripsa.com/go/install?source=devto:veripsa-parallel-pr-collision
Site: https://veripsa.com

Why this problem shows up

When you run several AI coding agents in parallel — Claude Code, Codex, GitHub Copilot — the number of open PRs goes up.

Say one agent works on auth, another on the API, another on tests. Each PR looks correct on its own. CI is green on all of them.

And main can still break depending on the order they land:

PR-A and PR-B rewrote the same area, separately
one landed first, the other carried a stale assumption in
no line-level conflict ever appeared, but merging both broke the meaning

Humans working in parallel hit this too. Parallel AI agents just make it much more visible, because the PR count and rebase count go up.

Why existing tools don't quite see it

Collisions aren't a new problem. What makes them hard to see is that per-PR inspection and PR-to-PR relationships are different things.

git tells you about conflicts at merge time. If the lines don't overlap, two changes can collide in meaning without ever being a git conflict.
CI runs each PR in isolation. A green and B green says nothing about "what if A and B both land?"
Review happens one PR at a time. Nobody re-checks every other open PR heading toward the same surface.
Merge queues stabilize the final merge of ready PRs. That's a different time window from the draft / pre-review stage where parallel-agent traffic piles up.

The blind spot is not inside a PR. It's between PRs.

What it does

Veripsa Core does not auto-resolve conflicts.

Before merge, it posts decision material as a GitHub check and a PR comment:

This PR is heading for the same landing area as another open PR.
There's a PR that should land first.
Here's what to check before you rebase.

Three properties:

Advisory: Veripsa never blocks a merge by itself. Whether it gates anything is decided by your branch protection / required status checks.
Content-free: it may read file bodies transiently to compute the signal, but it does not store or display source file bodies or diff contents. What it keeps is minimal operational metadata — details at veripsa.com/trust.
Not a safety proof: it never says "this merge is safe." It reports the PR-to-PR relationships it can see.

Turning the pause into an actual gate

For heavy collisions, Veripsa surfaces a pause with an acknowledgement path.

It only actually blocks the merge button if you mark the Veripsa check as a required status check in branch protection or rulesets. Without that, the comment and check stay advisory.

Whether required checks are available on private repositories depends on your GitHub plan. On public repositories they're free.

What it actually looks like

Here's the comment two PRs touching the same file produced (public PR #1):

✓ Clear to land — nothing is blocking you

This PR reserves: orders/pricing.py, tests/test_pricing.py

⏳ 1 in-flight PR is waiting behind this one — PR-2.

That comment is traffic information at the moment both PRs were open: PR #1 in front, PR #2 queued behind. After PR #1 merged, PR #2's final state changed to Cleared — the earlier overlap has resolved.

Pricing

Free to install while in early access.
If paid plans come later, they'll live in GitHub Marketplace-native billing.
Required-check management, retention, team dashboards, audit trails, priority support are future candidates — nothing paid is being promised as of this article.

https://veripsa.com/pricing

How to use it

Install the GitHub App and covered PRs get the check. Nothing to add to CI.

If your agents open PRs, rebase, and drive them to the edge of merge, add one rule to your CLAUDE.md / AGENTS.md: read the Veripsa check and comment before merging. That's how the advice enters the loop.