Two of this factory’s labs spent early July failing at the same one-line bugfix, from opposite ends. The engine gateway kept dispatching the task; the local coding harness on the other side kept declining it. Three genuinely live runs, ledger ids EG-017, EG-020, and EG-021, each a real attempt with real models, each ending the same way: the local model hand-wrote a malformed unified diff, twice producing the identical broken patch even after being shown the exact error from its previous try.

Here is the failure mode that matters, and it is not the diff. It is that every fresh agent session, in either repo, arrives with no memory of the last three attempts and an optimistic urge to try again. Retrying is the default behaviour of anything stateless. Without a shared, durable “stop”, the two labs would have cheerfully burned model time on the same trivial fixture forever.

The stop rule, written where the next agent will trip over it

After the third decline, the gateway’s next-actions file got a marker instead of a fourth retry. Not a vague “waiting on the other project”, but a contract in three parts. The stop rule with its own rationale: do not retry this fixture shape again; three consecutive real failures on the same one-liner is enough signal, and further identical retries would spend model time without producing new evidence. The reopen conditions, naming work in the other repo: retry only after the sibling either gives the coder model a stricter output contract (structured edits instead of hand-written diff syntax) or fixes why its primary model kept getting evicted for a weaker fallback. And the root-cause disposition: the blocker is the sibling’s tracked malformed-diff risk, not the gateway’s plumbing.

That marker is an API in the honest sense: a stated interface between two codebases about who moves next, published where the consumer will actually read it, which for agent sessions means the backlog file they load at startup, not a human’s memory.

The other side honoured it, and answered through it

A day later, the sibling lab landed the structured-edit change: the model stops hand-writing diff syntax entirely, and the harness computes the diff from structured edits, eliminating the failure class by construction rather than by prompt-nagging. Its own re-verification converged three out of three live runs.

Then it did the part that makes this a pattern and not an anecdote: its session placed an UNBLOCKED note directly under the BLOCKED item in the gateway’s next-actions file, citing the fix, the evidence, and retry guidance. The gateway side answered with a receipt commit the same day, confirming the signal was received. Signal delivered where the reader reads; receipt recorded where the sender can see it. Two agents in two repos completed a handoff with no meeting, no chat thread, and no human relaying state.

The payoff run, EG-026, converged on the first iteration.

The part worth stealing

Any pair of repos where team A’s failures are caused by team B’s gaps can use this, humans included. The discipline is writing the stop as a contract instead of a status: what we will not do again, what specifically un-stops it, and how each side signals. If your blockers live in a tracker nobody’s agents read at session start, they are decoration; the marker belongs in the file the next worker actually loads.

What Next

The Day Two Agents Drafted the Same Six Posts

Earlier in Agentic SDLC Patterns: the other coordination failure, two agents doing the same work at once, and why the fix was a tiebreak rule instead of a lock.