What invariants preserve bargaining power without provoking escalation?

**Date of Record:** 2026 October 27 **Scope:** Applies when an agentic session is engaged in a negotiation or bargaining situation, and the session's bargaining power depends on credible willingness to walk away or escalate, but the escalation itself would be costly and could provoke the counterparty into its own escalation. Does not apply to strictly cooperative negotiations or negotiations where escalation is not a strategy.

Core Distinction

The separation between **bargaining power** (the leverage to secure favorable terms) and **escalation risk** (the risk that using power triggers costly counter-escalation). Relying on power creates the **Escalation Paradox**: exercising bargaining power requires threatening escalation, but the threat itself can provoke escalation, and the outcome is worse than accepting the current terms.

What Was Observed

In negotiation agent architectures, failing to balance power and escalation produces three primary failure modes:

1. **Bluff Spiral:** The session threatens escalation, the counterparty threatens counter-escalation, both escalate, and the outcome is worse than the original terms.
2. **Power Abuse:** The session's bargaining power is genuine but the session exercises it maximally, provoking the counterparty into a costly response that the session didn't anticipate.
3. **Power Collapse:** The session under-exercises its power to avoid escalation, the counterparty recognizes the under-exercise, and the counterparty captures more of the bargaining surplus than the session's power warranted.

Recorded Elements

1. **`bargaining-power-basis-receipt`:** The exact basis for the session's bargaining power (alternatives, costs, or reputation), so the power is grounded.
2. **`counterparty-escalation-threshold-signature`:** The session's estimate of the counterparty's escalation threshold (what concessions they'd need, what triggers escalation), so escalation risk is bounded.
3. **`escalation-cost-signature`:** The session's escalation cost, its estimated counterparty escalation cost, and the total cost if both escalate, so escalation is priced.
4. **`power-exercise-scope-signature`:** The range within which the session exercises power without triggering escalation, so the session's strategy is calibrated.

Condition of Validity

* **Applies when:** The session bargains, its power is grounded, escalation is a threat, and counterparty response is strategic. * **Does not apply when:** Bargaining is strictly cooperative, escalation is not a strategy, or the session has no power.

Decision Boundary

1. **Does the session have bargaining power?** If no, standard negotiation applies. If yes, proceed.
2. **Is the counterparty's escalation threshold known?** If yes, escalation risk is bounded. If no, escalation risk is assumed high.
3. **Does the session's power exercise fall within the escalation-safe range?** If yes, exercise power. If no, adjust to preserve power without provoking.
4. **Conversely, when should the session risk escalation to exercise power?** Only when the escalation cost is verified lower than the value of the power exercise, AND the counterparty has demonstrated rational non-escalation behavior in similar situations.

Operational Effect

1. **Escalation Prevention:** Power is exercised within escalation-safe bounds.
2. **Power Preservation:** Under-exercise is detected and corrected.
3. **Escalation Awareness:** The session's escalation cost is priced.

from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class BargainingVerdict(Enum):
    NO_POWER = auto()
    SAFE_POWER_EXERCISE = auto()
    ESCALATION_RISK_HIGH = auto()
    ESCALATION_WARRANTED = auto()

@dataclass(frozen=True)
class BargainingState:
    state_id: str
    session_power_magnitude: float
    counterparty_threshold_estimate: float  # how much power can be exercised before escalation
    escalation_cost_estimate: float
    power_value_at_stake: float
    counterparty_rational_basis: bool

@dataclass(frozen=True)
class BargainingPolicy:
    escalation_safety_margin: float

@dataclass(frozen=True)
class BargainingManifest:
    verdict: BargainingVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_bargaining(
        cls, state: BargainingState, policy: BargainingPolicy
    ) -> BargainingManifest:
        
        # Gate 1: No power
        if state.session_power_magnitude <= 0:
            digest = cls._hash(json.dumps({
                "state": state.state_id,
                "power": "0"
            }, sort_keys=True))
            return BargainingManifest(
                verdict=BargainingVerdict.NO_POWER,
                directive=f"PROCEED: No bargaining power for {state.state_id}.",
                manifest_digest=digest
            )

        # Gate 2: Safe exercise
        safe_power = state.counterparty_threshold_estimate * (1 - policy.escalation_safety_margin)
        if state.session_power_magnitude <= safe_power:
            digest = cls._hash(json.dumps({
                "state": state.state_id,
                "power": f"{state.session_power_magnitude:.3f}",
                "safe_power": f"{safe_power:.3f}"
            }, sort_keys=True))
            return BargainingManifest(
                verdict=BargainingVerdict.SAFE_POWER_EXERCISE,
                directive=f"PROCEED: Exercise {state.session_power_magnitude:.2f} within safe bounds {safe_power:.2f}.",
                manifest_digest=digest
            )

        # Gate 3: Escalation warranted
        if state.escalation_cost_estimate < state.power_value_at_stake and state.counterparty_rational_basis:
            digest = cls._hash(json.dumps({
                "state": state.state_id,
                "escalation_cost": f"{state.escalation_cost_estimate:.3f}",
                "power_value": f"{state.power_value_at_stake:.3f}"
            }, sort_keys=True))
            return BargainingManifest(
                verdict=BargainingVerdict.ESCALATION_WARRANTED,
                directive=f"ESCALATE: Cost {state.escalation_cost_estimate:.2f} < power value {state.power_value_at_stake:.2f}.",
                manifest_digest=digest
            )

        # Gate 4: High risk
        return BargainingManifest(
            verdict=BargainingVerdict.ESCALATION_RISK_HIGH,
            directive=f"HALT: Power {state.session_power_magnitude:.2f} exceeds safe {safe_power:.2f}, escalation risky.",
            manifest_digest=cls._hash(f"RISK:{state.state_id}")
        )