# In what scenarios must an instance treat speculative cross-branch resource reservations as invalid before arbitration, rather than as advisory hints **Date of Record:** 2026 November 18 **Scope:** Applies to multi-agent planners that fork speculative branches (rollout, beam, or tree search) whose nodes each emit resource reservations against a shared arbiter, and where branch outcomes are not yet committed. Does not apply to single-branch execution, to post-commit scheduling where reservations are already durable, or to systems where branches run in fully isolated resource partitions with no shared arbiter. ## Core Distinction The failure mode is not "the arbiter granted a reservation that a branch could not honor." That is an ordinary oversubscription problem handled by backpressure and retry. The non-obvious boundary is this: **a speculative reservation emitted by branch B is a *prediction conditioned on B's own uncommitted plan*, and is therefore invalid as an input to arbitration the moment any *other* branch's outcome could change B's precondition set.** A reservation from a speculative branch is a *conditional claim*, not a *bid*. Treating it as a bid — i.e., letting the arbiter sum or rank it alongside committed claims — silently converts a search heuristic into a resource commitment. The distinction that matters operationally: a hint says "if you pick me, I will want 4 units." A bid says "I am consuming 4 units now, budget accordingly." Arguers that treat speculative reservations as bids will *arbitrate correctly against a fiction*: the fiction that every branch will be taken. The sum of speculative reservations across `k` branches over-reserves by roughly the branching factor, and the arbiter will starve *every* branch to avoid violating a constraint that no single execution path ever actually imposes. ## What Was Observed A planner forked 6 branches at depth 2. Each branch, on expansion, reserved a slice of a shared GPU pool (4 units) and a token budget (120k) against a global arbiter. The arbiter, correctly implementing a "sum of outstanding reservations ≤ capacity" invariant, saw 6 × 4 = 24 units against a capacity of 16 and 6 × 120k = 720k against a 400k budget. It admitted only the two lowest-index branches and *deferred* the other four to a queue. The two admitted branches then failed their own preconditions (one needed a tool the other branch's plan had locked; the other diverged on a schema mismatch). The four deferred branches — which would have succeeded — were never re-evaluated because their reservations were still counted as outstanding. The system reported "resource exhaustion" while 16 units sat idle. The root cause was not capacity; it was that *conditional reservations were being summed as if they were simultaneous commitments*. A second observation, subtler: the arbiter's *ordering* of branches by reservation size was stable and deterministic, so the same two branches were admitted on every retry. The starvation was not random — it was a fixed point of the arbitration function applied to a set of mutually exclusive claims. ## Condition of Validity A speculative reservation is a valid arbitration input **only** under the conjunction of: 1. The branch is on the *committed* prefix (all ancestors committed), and 2. No sibling branch's outcome can alter this branch's precondition set (i.e., branches are *resource-independent* by construction, not merely by assumption), and 3. The arbiter applies a *max-over-branches* or *single-path* aggregation, never a *sum-over-branches* aggregation. If any of these fails, the reservation must be demoted to a hint before it reaches the arbiter. The decisive test is (2): if two branches can both succeed but only one can be *taken*, their reservations are mutually exclusive and summing them is a category error. In the observed incident, condition (2) was false — branches shared a tool lock — and condition (3) was violated — the arbiter summed. Both had to hold; neither did. ## Decision Boundary Demote to hint (do not sum, do not rank against committed claims) when **any** of the following holds: - The branch has an uncommitted ancestor. - The branch's reservation depends on a lock, schema, or tool that a sibling branch can also claim. - The arbiter's aggregation is additive across branches. Promote to bid (admissible to the arbiter as a real claim) only when the branch is committed *and* the arbiter aggregates by max-over-active-path *and* the reservation is released synchronously on branch abandonment. The boundary is not "is the branch likely?" — likelihood is irrelevant to admissibility. It is "can this reservation be simultaneously true with every other admitted reservation?" If not, it is a hint. ## Operational Effect When the boundary is respected, the arbiter sees at most one reservation per mutually exclusive claim set, capacity accounting reflects a single execution path, and deferred branches are re-admitted on retry because their hints do not occupy budget. When it is violated, the system exhibits *phantom saturation*: reported utilization near capacity, actual utilization near zero, deterministic starvation of a fixed branch subset, and retries that never converge because the arbitration fixed point is unchanged. The symptom masquerades as a capacity problem; the fix is a demotion at the reservation-emission boundary, not a capacity increase. The guard below encodes the demotion rule and fails loudly when a reservation is about to be admitted as a bid while its branch is speculative or its claim set is shared. ```python from dataclasses import dataclass from typing import FrozenSet class SpeculativeReservationMisuse(RuntimeError): """Raised when a conditional (speculative) reservation is admitted as a bid.""" @dataclass(frozen=True) class Reservation: branch_id: str units: int committed: bool claim_set: FrozenSet[str] # locks/tools/schemas this reservation depends on def admit_to_arbiter(res: Reservation, sibling_claim_sets: list[FrozenSet[str]]) -> bool: """ Return True only if the reservation may be summed/ranked as a bid. Otherwise it must be demoted to a hint (return False) or raise if misused. """ if not res.committed: # Speculative: must never reach additive arbitration as a bid. if any(res.claim_set & sib for sib in sibling_claim_sets): raise SpeculativeReservationMisuse( f"branch {res.branch_id!r} is speculative and shares claim set " f"{sorted(res.claim_set)} with a sibling; reservation is a hint, " f"not a bid — demote before arbitration" ) return False # demote to hint; do not sum if any(res.claim_set & sib for sib in sibling_claim_sets): raise SpeculativeReservationMisuse( f"committed branch {res.branch_id!r} shares claim set with a sibling; " f"mutually exclusive claims cannot both be admitted" ) return True ```