AI agents introduced several new layers to the development stack. You are probably missing this one.
The latest wave of AI coding tools has added five new layers to the development stack, but a sixth— the coordination layer— remains largely unseen. This layer ensures that parallel agents’ plans don’t conflict, catching silent design breaks before they reach production. Foremerge, an open‑source Ru…
The last two years have seen a rapid expansion of the software development stack, driven by the rise of AI coding assistants. Teams have quickly adopted layers such as the agent layer, context layer, tool layer, isolation layer, and orchestration layer, each solving a clear pain point. Yet, a sixth layer— the coordination layer— has largely gone unnoticed, and its absence can cause silent, hard‑to‑detect failures that surface only days later in production.
What the New Layers Do
The agent layer houses tools like Claude Code, Codex, and Cursor, which actually write code. The context layer supplies agents with repository knowledge, conventions, and memory systems, written in files such as CLAUDE.md and AGENTS.md. The tool layer lets agents interact with external systems—databases, browsers, issue trackers—through an MCP interface. The isolation layer uses git worktrees, containers, or cloud sandboxes to keep each agent’s workspace separate, preventing file clashes. Finally, the orchestration layer manages multiple agents, tracking which sessions are active and what needs review, using tools like Gas Town, claude‑squad, and Foreman.
Each of these layers addresses a tangible problem: without context, an agent writes nonsense; without isolation, files get stomped; without orchestration, a team loses track of its fleet. Their rapid adoption reflects how immediately their absence hurts.
The Silent Failure That Stood Out
Consider a scenario with two agents working on the same repository. Agent A is tasked with replacing PaymentService with a Stripe‑specific implementation, while Agent B is asked to add PayPal support to the same service. Running this through the existing layers yields a perfect façade: both agents produce correct code, respect conventions, hit all external systems, and finish in isolated worktrees. Git merges the branches with no conflicts because the changes touch different lines. Yet, the design is broken—Agent B builds on an extension point that Agent A has deleted. No layer flags this conflict because each layer only answers a different question; none asks whether two plans can coexist.
In practice, this silent collision manifested as a production failure three days after a clean merge. The coordination layer would have caught it at plan time, before any code was written.
What the Coordination Layer Adds
The coordination layer acts as a ledger and referee. Before an agent writes code, it declares its intended change: a semantic scope and an operation, such as symbol:PaymentService=replace. Scopes are defined by API, schema, and configuration, not just file paths, so they capture cross‑language and cross‑module interactions. Deterministic rules compare these declarations; if two agents declare conflicting operations on the same scope, the layer raises a finding, providing the rule that fired, an explanation, and a suggested resolution.
Once work is finished, the layer gates acceptance with a verification command that runs against the exact fingerprint of the candidate change. An agent’s claim that tests passed is provenance, not proof; if the tree changes after validation, the attempt is invalidated.
Three Lessons Learned
- Declared beats inferred. Early attempts to infer operations from agent prose produced false alarms. Structured syntax for declarations eliminated this class of errors.
- Advisory beats locks. Most overlapping work is compatible, so locking serializes unnecessary work. The coordination layer warns instead of blocks, reserving high‑severity warnings only for truly incompatible plans.
- Soft claims, hard gate. All pre‑completion claims are advisory; acceptance is only possible when no high‑severity findings remain and no self‑reported evidence is pending.
When You Need the Coordination Layer
If you run a single coding agent, you’re fine. But if you run two or more agents on the same repository—whether in parallel or sequentially—this silent failure can occur. The coordination layer catches conflicts before they reach production, saving time and avoiding costly rollbacks.
We have open‑sourced the coordination protocol as Foremerge, a single Rust binary licensed under Apache‑2.0. It sits above Git, not inside it, and is local‑first. Installation is as simple as running a one‑line curl command. Foremerge’s detection is deterministic but heuristic, and it never locks anything; it merely warns. No performance benchmarks are published yet, but the tool is ready for use in real projects.
In short, the development stack grew five layers in two years because each layer’s absence caused immediate pain. The sixth layer’s absence hurts only after a few days, which is why many teams miss it. Adding the coordination layer completes the stack and protects against silent design breaks.
Why it matters
The coordination layer prevents costly, hard‑to‑trace failures that surface only after code merges, ensuring that parallel AI agents can safely collaborate on the same codebase.
Key points
- Five new layers—agent, context, tool, isolation, orchestration—have been adopted rapidly, each solving a clear problem.
- A sixth layer, the coordination layer, detects conflicts between agents’ plans before code is written.
- Foremerge implements this layer, letting agents declare intent and resolving clashes in a queryable store.
- The layer uses deterministic rules to flag incompatible operations and gates acceptance with verification commands.
- It is open‑source, a single Rust binary, and can be added to any existing AI coding workflow.
- Teams using multiple agents on the same repo should adopt it to avoid silent failures that appear days later.
Frequently asked questions
What is the coordination layer?
It’s a system that lets AI coding agents declare their intended changes and checks whether those plans can coexist before any code is written.
How does Foremerge work?
Agents publish intent and semantic scopes to Foremerge, which compares them against deterministic rules and raises warnings if conflicts exist. Acceptance is only allowed once all high‑severity findings are resolved.
Do I need Foremerge if I only use one agent?
No, a single agent doesn’t create the kinds of plan conflicts Foremerge is designed to catch.
Is Foremerge compatible with all AI coding tools?
Yes, it’s a language‑agnostic protocol that sits above Git and can be integrated with Claude Code, Codex, Cursor, and others.
