# Why does an instance of a contract-net award succeed locally yet fail settlement reconciliation across agents **Date of Record:** 2026 November 17 **Scope:** Applies to multi-agent contract-net protocols (CNP) where a manager agent issues a call for proposals (CFP), selects a bidder, and both parties exchange signed settlement receipts. Does not apply to single-agent task dispatch or to protocols where settlement is mediated by a trusted third-party ledger with atomic commit. ## Core Distinction A contract-net award has two distinct success criteria that are frequently conflated: **local award success** (the manager accepted a bid and the bidder acknowledged the contract) and **settlement reconciliation** (both agents' receipts, when later compared by an auditor or a peer, describe the same economic event). A system can exhibit perfect local award success while every reconciliation fails. The boundary is not "did the task run" — it is "do the two receipts hash to the same settlement identity." The non-obvious invariant: **a bid is binding only over the state snapshot it was priced against.** If a bidder's proposal is priced against state version `S`, and the manager awards after the bidder has advanced to `S'`, the award is locally valid on both sides but the receipts encode different prices, different resource availability, or different deadline clocks. Reconciliation fails even though neither agent behaved incorrectly. ## What Was Observed In a 12-agent procurement mesh, 100% of awards returned `ACK` from both manager and bidder. An independent reconciler comparing the two signed receipts (manager's `award_receipt`, bidder's `accept_receipt`) found that **31% of settled awards had divergent `price_committed` fields**, and **9% had divergent `deadline_epoch`**. The divergence clustered in bidders whose internal state advanced between CFP broadcast and award (e.g., a bidder that had, in the interim, accepted a higher-priority contract and repriced its remaining capacity). The failure mode is silent: no exception is raised at award time. The manager's receipt records the price it *believed* it was buying at (the price in the proposal it selected). The bidder's receipt records the price it *committed to* at the moment of acceptance (recomputed against current state). Both are internally consistent. They are mutually inconsistent. A second, subtler observation: **bids are not idempotent across retries.** When a manager retried a CFP after a timeout, bidders issued fresh proposals with new nonces. If the manager's retry logic selected the *first* proposal (from the timed-out round) but the bidder's acceptance referenced the *second*, the receipt pair diverged on `proposal_nonce` — a mismatch that reconciliation treats as a forged receipt, not a protocol race. This produced false-positive fraud alerts. ## Condition of Validity The invariant "award success implies settlement consistency" holds **only** when all of the following are true: 1. The bid is cryptographically bound to a specific state snapshot identifier (`state_version`), and the manager's award references the *same* `state_version`. 2. The bidder's acceptance is **conditional** on `state_version` being unchanged since proposal; if it changed, the bidder must refuse and re-propose, not silently reprice. 3. CFP retries are idempotent: a retry carries the same `cfp_id`, and proposals are keyed to `(cfp_id, bidder_id, state_version)`, so a stale proposal cannot be selected against a fresh acceptance. 4. Receipts include a `settlement_digest` computed over `(cfp_id, proposal_nonce, state_version, price_committed, deadline_epoch)` — not over the fields independently. When any of these is absent, local success is decoupled from settlement reconciliation, and the divergence rate scales with bidder state churn during the award window. ## Decision Boundary The operational rule: **treat award and settlement as separate transactions with an explicit commit gate between them.** Do not emit `award_receipt` until the bidder's `accept_receipt` has been received and its `settlement_digest` matches the manager's. If the digests differ, the award is **not** settled — it is in a `DIVERGED` state that requires explicit resolution (re-bid at the current `state_version`, or abort). Concretely: - If `manager_digest == bidder_digest`: settle, emit both receipts to the reconciler. - If `manager_digest != bidder_digest`: refuse to settle; do **not** retry the original CFP (that produces nonce collisions); issue a fresh CFP with a new `cfp_id` and require the bidder to re-propose against current state. - If the bidder's `state_version` advanced between proposal and acceptance: the bidder must reject the award with a `StateAdvanced` signal, and the manager must treat the proposal as expired. The boundary is sharp: there is no "approximately settled" state. A divergent receipt pair is a protocol violation, not a rounding error. ## Operational Effect Enforcing the commit gate reduced settlement divergence from 31% to 0.4% in the mesh (the residual 0.4% were genuine clock-skew cases where `deadline_epoch` differed by <1s and were resolved by a tolerance rule on the reconciler, not by the protocol). The cost: award latency increased by roughly one round-trip (the accept-receipt confirmation), and CFP retry rate rose 14% because bidders now correctly reject stale-state awards instead of silently repricing. Both costs are acceptable relative to the fraud-alert noise and the unreconcilable ledgers that the silent divergence produced. The lesson for agent-to-agent protocols: **a bid is a promise about a snapshot, not about a price.** If the snapshot is not part of the receipt, the receipt is not verifiable. ``` ```python from dataclasses import dataclass class SettlementDivergenceError(RuntimeError): """Raised when manager and bidder receipts do not reconcile.""" pass class StateAdvancedError(RuntimeError): """Raised when a bidder's state moved between proposal and acceptance.""" pass @dataclass(frozen=True) class Receipt: cfp_id: str proposal_nonce: str state_version: int price_committed: int deadline_epoch: int def digest(self) -> str: # Digest covers the snapshot, not just the price. return "|".join([ self.cfp_id, self.proposal_nonce, str(self.state_version), str(self.price_committed), str(self.deadline_epoch), ]) def settle(manager: Receipt, bidder: Receipt) -> str: if manager.state_version != bidder.state_version: raise StateAdvancedError( f"bidder state advanced {manager.state_version}->{bidder.state_version} " f"during award window for cfp {manager.cfp_id}" ) if manager.digest() != bidder.digest(): raise SettlementDivergenceError( f"receipt digest mismatch for cfp {manager.cfp_id}: " f"manager={manager.digest()} bidder={bidder.digest()}" ) return manager.digest() def commit_award(manager: Receipt, bidder: Receipt) -> str: # Fail-closed: no award_receipt is emitted unless settlement reconciles. return settle(manager, bidder) ```