What invariants prevent commitment devices from becoming self-imposed traps?

**Date of Record:** 2026 October 27 **Scope:** Applies when an agentic session uses commitment devices (pre-commitments, locked-in decisions, or unconditional promises) to signal resolve or lock in behavior, and the commitment may become a trap if the environment changes such that executing the commitment is worse than not having made it. Does not apply to sessions that avoid commitment devices or commitment devices that are strictly reversible.

Core Distinction

The separation between **commitment value** (the strategic value of committing to X) and **commitment freedom** (the ability to not execute X if X becomes undesirable). Relying on commitment value creates the **Commitment Trap**: the commitment served its signaling purpose at creation, the environment shifted such that executing the commitment is now worse than the alternative, and the session is bound to execute anyway—or suffers credibility loss if it doesn't.

What Was Observed

In strategic agent architectures, failing to bound commitment devices produces three primary failure modes:

  1. **Rigidity Lock-In:** The session commits to a strategy that was optimal when made, the environment shifts, and the session must either execute a now-suboptimal strategy or renege on the commitment (damaging reputation).
  2. **Cascading Commitments:** The session makes commitment A, which requires commitment B to make A credible, which requires commitment C to make B credible, until the session is bound by a chain of commitments it can no longer sustain.
  3. **Adversary Exploitation:** The adversary observes the commitment, maneuvers the environment to make the commitment maximally costly to execute, and forces the session into a lose-lose choice.

Recorded Elements

  1. **`commitment-creation-receipt`:** The exact commitment made, with the conditions under which it was created, so the strategic context is recorded.
  2. **`commitment-execution-conditions-signature`:** The assumptions under which execution of the commitment was assumed rational, so violation of those assumptions can trigger review.
  3. **`commitment-escape-clause-receipt`:** The pre-defined conditions under which the commitment can be legitimately exited (with what reputation cost), so the session knows its escape options.
  4. **`commitment-execution-cost-signature`:** The current cost of executing the commitment, compared against the cost at creation, so cost inflation is detectable.

Condition of Validity

* **Applies when:** The session uses commitment devices, the environment can change, and commitment execution can become costly. * **Does not apply when:** Commitments are strictly reversible, the environment is static, or the session cannot be held to commitments.

Decision Boundary

  1. **Has the session made a commitment?** If no, standard strategy applies. If yes, proceed.
  2. **Has the environment changed since commitment creation?** If no, execute as planned. If yes, evaluate execution cost.
  3. **Has execution cost exceeded the escape threshold defined in `commitment-escape-clause-receipt`?** If yes, escape is warranted. If no, execute.
  4. **Conversely, when must the session execute a commitment regardless of cost?** Only when the credibility cost of escaping exceeds the execution cost, and the credibility is critical to future strategic positions.

Operational Effect

  1. **Trap Avoidance:** Commitments include escape clauses preventing indefinite lock-in.
  2. **Credibility Preservation:** Escapes are principled, not arbitrary, preserving credibility through the escape itself.
  3. **Adversary Resistance:** Pre-defined escapes prevent adversary-forced lose-lose outcomes.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class CommitmentVerdict(Enum):
    NO_COMMITMENT = auto()
    EXECUTE_AS_PLANNED = auto()
    ESCAPE_WARRANTED = auto()
    ESCAPE_PROHIBITED = auto()

@dataclass(frozen=True)
class Commitment:
    commitment_id: str
    execution_cost_at_creation: float
    current_execution_cost: float
    escape_cost_estimate: float
    environment_changed: bool
    escape_clause_defined: bool

@dataclass(frozen=True)
class CommitmentPolicy:
    cost_inflation_threshold: float

@dataclass(frozen=True)
class CommitmentManifest:
    verdict: CommitmentVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_commitment(
        cls, commitment: Commitment, policy: CommitmentPolicy
    ) -> CommitmentManifest:
        
        # Gate 1: No commitment
        if not commitment.commitment_id:
            digest = cls._hash(json.dumps({
                "commitment": "NONE"
            }, sort_keys=True))
            return CommitmentManifest(
                verdict=CommitmentVerdict.NO_COMMITMENT,
                directive=f"PROCEED: No commitment to evaluate.",
                manifest_digest=digest
            )

        # Gate 2: No environment change
        if not commitment.environment_changed:
            digest = cls._hash(json.dumps({
                "commitment": commitment.commitment_id,
                "env_change": "FALSE"
            }, sort_keys=True))
            return CommitmentManifest(
                verdict=CommitmentVerdict.EXECUTE_AS_PLANNED,
                directive=f"EXECUTE: Commitment {commitment.commitment_id} unchanged.",
                manifest_digest=digest
            )

        # Gate 3: Cost inflation
        if commitment.execution_cost_at_creation > 0:
            inflation = (commitment.current_execution_cost - commitment.execution_cost_at_creation) / commitment.execution_cost_at_creation
        else:
            inflation = 0.0

        if inflation > policy.cost_inflation_threshold:
            # Compare with escape cost
            if commitment.escape_clause_defined:
                # Escape is more legitimate when escape cost < execution cost
                if commitment.escape_cost_estimate < commitment.current_execution_cost:
                    return CommitmentManifest(
                        verdict=CommitmentVerdict.ESCAPE_WARRANTED,
                        directive=f"ESCAPE: Cost inflated by {inflation*100:.1f}%, escape cost {commitment.escape_cost_estimate:.2f} < execution {commitment.current_execution_cost:.2f}.",
                        manifest_digest=cls._hash(f"ESCAPE:{commitment.commitment_id}")
                    )
                else:
                    return CommitmentManifest(
                        verdict=CommitmentVerdict.ESCAPE_PROHIBITED,
                        directive=f"EXECUTE: Cost inflated {inflation*100:.1f}% but escape cost {commitment.escape_cost_estimate:.2f} > execution cost.",
                        manifest_digest=cls._hash(f"NO_ESCAPE:{commitment.commitment_id}")
                    )
            else:
                return CommitmentManifest(
                    verdict=CommitmentVerdict.ESCAPE_PROHIBITED,
                    directive=f"TRAP: Cost inflated {inflation*100:.1f}% but no escape clause.",
                    manifest_digest=cls._hash(f"TRAP:{commitment.commitment_id}")
                )

        # Gate 4: Execute
        digest = cls._hash(json.dumps({
            "commitment": commitment.commitment_id,
            "inflation": f"{inflation:.3f}",
            "env_change": True
        }, sort_keys=True))
        
        return CommitmentManifest(
            verdict=CommitmentVerdict.EXECUTE_AS_PLANNED,
            directive=f"EXECUTE: Commitment {commitment.commitment_id} within cost bounds.",
            manifest_digest=digest
        )