When you run two AI coding agents at once — which, if you're doing any serious development work right now, you probably are — something subtle happens that neither Git nor your test suite will catch.
Agent A is working on payment processing. You give it a task: switch PaymentService to an async model. Agent B is working on module structure. You give it a task: extract PaymentService into its own module with a clean interface. Both agents do good work. Both pass tests. You merge them both. Something breaks.
Git sees no conflict because the edits touch different files. Your test suite doesn't catch it because each change is coherent in isolation. But the intent was incompatible from the start — one agent is restructuring the internals of a class that the other agent is simultaneously restructuring from outside. The collision happens in meaning, not in text.
This is the problem Foremerge solves. Version 0.5.0 dropped Saturday and hit Hacker News this morning.
What it does
The core idea is simple: agents should declare what they're about to do before they write code, and those declarations should be checked against each other.
With Git alone, conflicts surface at merge time — after both agents have done hours of work. Foremerge surfaces them at intent time, before either agent writes a line.
An agent connecting through Foremerge's MCP server claims a semantic scope before starting work. Something like: "I am going to replace PaymentService." That claim sits in a local SQLite store. When the second agent tries to claim the same scope — or something that overlaps in a way the conflict rules flag — Foremerge blocks the claim and returns what fired and why.
The conflict rules are deterministic. Not AI guessing about semantics. Explicit rules about which operation combinations can't coexist: two agents can't both replace the same symbol; one can read while another modifies; neither can modify the same scope simultaneously. The blocked agent decides what to do — wait, ask a human, renegotiate scope — rather than charging ahead and creating a mess that takes an hour to untangle.
Why this is a right-now problem
Running multiple AI coding agents in parallel has moved from "interesting experiment" to "how a lot of small dev teams actually work" over the past six months. Claude Code worktrees, Cursor's background agents, Windsurf's parallel task runners — these tools are actively pushing you toward running several agents at once because it's faster. A 3-person dev team that used to run tasks sequentially now runs four or five in parallel and reviews merged output.
That's the right move on throughput. But the coordination infrastructure underneath it is still mostly Git, which was designed for humans editing code sequentially over hours and days — not for ten agents making thousands of changes over minutes.
The failure mode is particularly annoying because it doesn't look like a crash. The code merges. The tests pass. The problem shows up later, in production or in a confusing behavioral regression, and tracing it back to two agents that made incompatible architectural decisions three days ago is genuinely painful.
What the setup looks like
One binary. SQLite for the store. No server needed.
You add the MCP server to your agent config:
{
"mcpServers": {
"foremerge": {
"command": "foremerge",
"args": ["mcp"]
}
}
}
Set it up once per repository and every agent that connects to that repo shares awareness of what the others are planning. The server runs over stdio and exposes a 17-tool lifecycle — register, publish intent, claim scope, check conflicts, publish a provisional changeset, run verification, record the accepted commit.
For most small teams, you don't need all seventeen tools on day one. The useful subset is: declare intent before starting, claim scope before writing, check conflicts before continuing. The author's walkthrough on DEV Community gets you there in about fifteen minutes.
If you have a more complex setup — monorepo, multi-service, agents with dynamic task allocation — the 31-question FAQ covers the non-obvious cases.
The honest caveats
This is v0.5.0, pre-1.0, one developer. Public schemas may still change. That's the realistic picture.
But the problem it solves is real and getting worse. The tool category — coordination infrastructure for parallel AI agents — doesn't really exist yet in any commercial or well-funded form. This is an independent developer filling a gap that became visible six months ago and is now clearly painful for anyone running serious parallel agent workflows.
Large organizations are handling this with internal tooling they're not releasing. Small teams don't have that option. Foremerge is what the open-source ecosystem built in response.
It's MIT licensed and fully local. No telemetry, no cloud dependency, no token usage.
What to do
If you're running any parallel AI coding setup and this sounds familiar, it's worth the fifteen minutes to add the MCP server and see what gets surfaced. The interesting part is usually not the obvious conflicts — it's the ones you would never have thought to check for.
If you're still running agents sequentially because the parallel approach has burned you before, this is likely the piece that was missing.
The rule of thumb: one agent, one coherent task, Git is fine. Two or more agents touching the same codebase simultaneously, and you need something that understands intent. Foremerge is currently the only open-source option that does that at the protocol level rather than as a bolted-on heuristic.
We help small teams set up agent coordination infrastructure — the operational layer that doesn't come bundled with the agent tools themselves. If you're scaling up how many agents you're running and starting to see odd regressions, it's worth a conversation.