What bidding invariants prevent multi-agent auction price collapse?

**Date of Record:** 2026 October 27 **Scope:** Applies when multiple autonomous agents bid in an auction or matching market, and their bidding strategies can converge to a price equilibrium that excludes profitable trades or collapses the market (e.g., all bidders bid above reserve but below the seller's willingness, or bidders collude on a low price). Does not apply to strictly single-agent bidding or auctions with a single-bidder design.

Core Distinction

The separation between **individual rational bidding** (each agent bids based on its own valuation and strategy) and **collective market viability** (the aggregate bidding produces a functional market with sufficient transaction volume). Relying on individual rationality creates the **Auction Price Collapse**: each agent's individually rational strategy (bid low to maximize surplus) produces a collective outcome where no trade occurs, and the market fails to function even though both sides would benefit from trade.

What Was Observed

In multi-agent auction architectures, failing to enforce market-viability invariants produces three primary failure modes:

  1. **Reserve Price Miss:** All bidders bid just above the reserve price (their individual optimal strategy), but below the seller's true minimum willingness. The auction clears at the reserve, and the seller rejects the trade, wasting the auction.
  2. **Collusion Equilibrium:** Bidders implicitly coordinate on low bids (via shared strategies or observable patterns), and the seller's goods sell below fair value, causing the seller to exit the market.
  3. **Winner's Curse Collapse:** The winning bidder's bid is slightly above the second-highest, and all bidders learn to shade their bids downward, causing the market clearing price to drift toward zero over successive auctions.

Recorded Elements

  1. **`aggregate_bid_distribution_receipt`:** The cryptographic record of the full bid distribution (all bidders' bids, not just the winner's), allowing the market to detect anomalies in the price discovery process.
  2. **`seller_willingness_commitment_signature`:** A cryptographically signed commitment from the seller to their true minimum willingness, so the market can detect when clearing prices are below viability.
  3. **`market_viability_threshold_signature`:** The exact criterion for market viability (e.g., "at least 3 distinct bids above 80% of seller willingness"), failing which the auction must be rescheduled with different parameters.
  4. **`collusion_detection_receipt`:** A cryptographic proof of whether the bidding pattern is consistent with independent bidders (e.g., bid variance above threshold) or indicates collusion (variance below threshold).

Condition of Validity

* **Applies when:** Multiple agents bid independently, the aggregate outcome determines market function, and auctions can fail due to strategic behavior. * **Does not apply when:** Only one agent bids, the auction is a fixed-price mechanism with no strategic pricing, or individual bidder strategies cannot interact.

Decision Boundary

  1. **Did the auction clear?** If yes, check market viability. If no, standard auction-failure handling applies.
  2. **Does the aggregate bid distribution pass the market viability threshold?** If yes, the market is functioning. If no, the auction is at risk of collapse.
  3. **Does the `collusion_detection_receipt` flag suspicious bidding patterns?** If yes, the auction must be cancelled and re-run with anti-collusion measures. If no, proceed.
  4. **Conversely, when can the auction proceed despite weak bid distribution?** Only when the auction has a documented "no-sale" outcome with an automatic requeue mechanism, or when the bid distribution pattern is provably consistent with weak demand rather than strategic manipulation.

Operational Effect

  1. **Collapse Detection:** Detects auction failures before they result in missed trades or sustained market death.
  2. **Collusion Prevention:** Flags suspiciously low bid variance, triggering anti-collusion measures.
  3. **Viability Enforcement:** Ensures auctions only clear when the aggregate outcome supports continued market function.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json
import statistics

class AuctionVerdict(Enum):
    VIABLE_CLEARING = auto()
    AUCTION_COLLAPSE_RISK = auto()
    COLLUSION_SUSPECTED = auto()
    NO_SALE_REQUIRED = auto()

@dataclass(frozen=True)
class Bid:
    bidder_id: str
    bid_amount: float

@dataclass(frozen=True)
class AuctionState:
    bids: tuple[Bid, ...]
    seller_willingness: float
    reserve_price: float
    min_distinct_bidders: int
    min_viable_bid_ratio: float

@dataclass(frozen=True)
class AuctionPolicy:
    collusion_variance_threshold: float

@dataclass(frozen=True)
class AuctionManifest:
    verdict: AuctionVerdict
    clearing_price: float | None
    directive: str
    manifest_digest: str

class AuctionViabilityGuard:
    @staticmethod
    def _hash(data: str) -> str:
        return hashlib.sha256(data.encode("utf-8")).hexdigest()

    @classmethod
    def evaluate_auction(
        cls, state: AuctionState, policy: AuctionPolicy
    ) -> AuctionManifest:
        
        # Gate 1: No bids
        if not state.bids:
            return AuctionManifest(
                verdict=AuctionVerdict.NO_SALE_REQUIRED,
                clearing_price=None,
                directive="HALT: No bids. Auction failed.",
                manifest_digest=cls._hash("NO_BIDS")
            )

        # Gate 2: Bidder count
        distinct_bidders = len({b.bidder_id for b in state.bids})
        if distinct_bidders < state.min_distinct_bidders:
            return AuctionManifest(
                verdict=AuctionVerdict.AUCTION_COLLAPSE_RISK,
                clearing_price=None,
                directive=f"HALT: Only {distinct_bidders} bidders < {state.min_distinct_bidders}. Requeue.",
                manifest_digest=cls._hash(f"FEW_BIDDERS:{distinct_bidders}")
            )

        # Gate 3: Viability threshold
        sorted_bids = sorted((b.bid_amount for b in state.bids), reverse=True)
        top_bid = sorted_bids[0]
        viable_threshold = state.seller_willingness * state.min_viable_bid_ratio

        if top_bid < viable_threshold:
            return AuctionManifest(
                verdict=AuctionVerdict.AUCTION_COLLAPSE_RISK,
                clearing_price=None,
                directive=f"HALT: Top bid {top_bid:.2f} < viable {viable_threshold:.2f}. Requeue with different parameters.",
                manifest_digest=cls._hash(f"BELOW_VIABLE:{top_bid:.2f}")
            )

        # Gate 4: Collusion detection
        if len(sorted_bids) > 2:
            variance = statistics.variance(sorted_bids)
            if variance < policy.collusion_variance_threshold:
                return AuctionManifest(
                    verdict=AuctionVerdict.COLLUSION_SUSPECTED,
                    clearing_price=None,
                    directive=f"HALT: Bid variance {variance:.4f} < {policy.collusion_variance_threshold:.4f}. Possible collusion.",
                    manifest_digest=cls._hash(f"COLLUSION:{variance:.4f}")
                )

        # Gate 5: Viable clearing
        clearing = top_bid
        digest = cls._hash(json.dumps({
            "bidders": str(distinct_bidders),
            "top_bid": f"{top_bid:.2f}",
            "viable_threshold": f"{viable_threshold:.2f}",
            "reserve": f"{state.reserve_price:.2f}"
        }, sort_keys=True))
        
        return AuctionManifest(
            verdict=AuctionVerdict.VIABLE_CLEARING,
            clearing_price=clearing,
            directive=f"PROCEED: Clearing at {clearing:.2f} with {distinct_bidders} bidders.",
            manifest_digest=digest
        )