Bounded Negotiation with Fallback
When two agents argue over one artifact until they agree,
"until they agree" is not a termination condition — so the loop needs a
round cap and a defined action for what happens when the cap is
hit. The pattern has three parts and all three are
load-bearing: a cap (5 rounds of plan negotiation, 2
rounds of review-and-repair), a success exit (consensus
reached, artifact frozen), and a fallback — the
deterministic thing that happens when the rounds run out. In
grill-me-codex the fallback is unusually clean: after two
failed repair rounds the reviewing model stops asking the builder to fix
it and fixes it itself — "I want to drive. It'll take the wheel
and start writing the code." Not an error, not an escalation to a human,
not an infinite retry: a pre-declared change of strategy.
The cap exists because independent models are not guaranteed to converge — that is the point of making them independent (Cross-Model Independence). Two genuinely uncorrelated critics can disagree forever, each round costs tokens and wall-clock, and the operator is usually not watching. Without a bound, the strongest property of the pattern (real disagreement) becomes its worst failure mode (a non-terminating, billed argument). Note the caps are asymmetric and that asymmetry is informative: five rounds for planning, where disagreement is cheap and valuable, and only two for repair, where a builder that has twice failed to follow a review is evidence the delegation itself has failed, not that it needs a third try.
The companion discipline is that a bounded argument must be
auditable after the fact: the negotiation writes its
transcript to a file (PLAN-REVIEW-LOG.md) and records
resolutions with reasons ("12 findings… 11 accepted, 1 scoped down with
logged reason"). An operator who did not watch eight minutes of two
models arguing needs the disagreement and its resolution to
survive as an artifact — otherwise the cap silently truncates work and
the run reads as clean consensus when it was actually a timeout. This is
Decision Log applied to machine-machine
argument, and it is how the pattern honours "no silent caps."
Claims
- "Argue until you agree" is not a termination condition — any agent-vs-agent negotiation needs an explicit round cap plus a defined fallback for cap exhaustion. principle — durable: convergence is precisely what independent critics do not guarantee, so an unbounded consensus loop has no upper bound on cost or latency. The bound is not a cost optimization bolted on afterward; it is what makes the loop a terminating program.
- The fallback must be a pre-declared change of strategy, not a retry or an error. principle — durable: "the reviewer takes the wheel and does it itself" resolves the task, where a third repair round would just re-run the thing that already failed twice and an error would dump an unfinished artifact on the operator. A cap without a fallback converts a slow success into a fast failure.
- Size the cap to what a round buys: generous where disagreement is the product, tight where a failed round is evidence the delegation isn't working. best practice — context: cross-model pipelines with distinct stages. The source's 5-for-planning / 2-for-repair split embodies it — planning disagreement is the value being purchased, while a builder that misses a review twice has demonstrated a capability gap a third round won't close. The specific numbers are one skill's tuning, not a law.
- Write the negotiation transcript to a durable artifact and record each resolution with its reason — including what was rejected and why. best practice — context: automated multi-round argument the operator does not watch in real time; "11 accepted, 1 scoped down with logged reason" is the shape. Without it a capped run is indistinguishable from a converged one, which is exactly the silent truncation the cap was supposed to make visible. See Decision Log.
- A run that hit the cap and a run that converged must be
distinguishable in the output.
principle — durable, and the "no
silent caps" discipline stated for negotiation: the source's own summary
leads with
Converged: APPROVED, 2 rounds— the round count and the outcome, together. Reporting only the artifact would let a timeout masquerade as agreement.
Related
- Cross-Model Independence — why the bound is needed at all: independent models are not guaranteed to converge, and that non-convergence is a feature of the independence, not a bug to fix.
- Adversarial Planning Council — the council's Go/Reshape/Kill verdict is a different forcing function for the same problem (a sprawling critique must end in a decision); this concept forces termination by round count plus fallback rather than by verdict vocabulary.
- Bounded Fan-Out — the sibling bound on the other axis: that one caps how many agents run, this one caps how long they argue. Both treat an unbounded dial as a design variable to justify.
- Decision Log — the durable record of what was decided and why; here it is the negotiation transcript that keeps a capped argument auditable.
- Agent Supervision — the fallback is what the loop does instead of interrupting the human; the cap is where an unattended run would otherwise burn budget invisibly.
- Evidence-Gated Completion — the complementary gate: this concept bounds the argument, evidence gating decides whether the artifact that emerges is actually done.
- Agent Loop — a negotiation is a loop between two agents; caps and fallbacks are its exit conditions.
- Step Isolation — the frozen plan at the negotiation's success exit is the boundary the next stage builds against.
- Spec-Driven Development — the artifact being negotiated is the spec; the cap is a budget on how much attention the plan stage may consume before the build starts.
- Distillate: Fable 5 + GPT 5.6 Sol = CHEAT CODE