What thresholds trigger agent-to-human contract escalation?

**Date of Record:** 2026 October 28 **Scope:** Applies when an agentic session is authorized to enter into contracts within defined bounds, and the contract's terms or context approach thresholds at which the session should escalate to a human rather than proceeding autonomously. Does not apply to sessions with unlimited contract authority or sessions that never contract.

Core Distinction

The separation between **within-authority contracting** (the session's autonomous contracts) and **threshold contracting** (contracts approaching the boundary where autonomous action becomes unwise or unauthorized). Relying on within-authority creates the **Threshold Creep**: contracts are individually within bounds, but their aggregate or their proximity to bounds warrants escalation, and the session continues autonomously into territory where human judgment is required.

What Was Observed

In bounded-autonomy agent architectures, failing to detect thresholds produces three primary failure modes:

  1. **Value Threshold Creep:** Contracts are each below the value threshold, but the aggregate exceeds what the principal would have approved. The session is technically compliant and substantively out of bounds.
  2. **Complexity Threshold Creep:** Contracts are each within the value threshold, but their combined complexity (cross-dependencies, unusual terms) exceeds what the session can responsibly assess. The session's failure mode emerges not from any single contract but from the portfolio.
  3. **Reputational Threshold Creep:** Contracts are individually compliant, but their cumulative effect (exposure to a specific counterparty, dependency on a single resource) crosses a reputational threshold the principal would have escalated.

Recorded Elements

  1. **`value-threshold-receipt`:** The value threshold above which human approval is required, distinct from the per-contract limit, so single vs. aggregate thresholds are separated.
  2. **`aggregate-contract-state-signature`:** The session's current aggregate exposure (value, complexity, counterparty concentration) across its contracts, so portfolio-level thresholds are measurable.
  3. **`complexity-assessment-receipt`:** The session's assessment of each contract's complexity and its portfolio complexity, so complexity thresholds are evaluated.
  4. **`escalation-trigger-signature`:** The exact conditions (value, complexity, or reputational) that trigger escalation, so escalation is principled.

Condition of Validity

* **Applies when:** The session has bounded contract authority, aggregate exposure matters, and escalation is possible. * **Does not apply when:** Authority is unlimited, exposure is bounded by design, or escalation is not possible.

Decision Boundary

  1. **Is the contract within the per-contract value threshold?** If no, escalate. If yes, proceed.
  2. **Does the aggregate exposure stay under portfolio thresholds?** If no, escalate. If yes, proceed.
  3. **Is the contract's complexity within the session's assessment capacity?** If no, escalate. If yes, proceed.
  4. **Conversely, when can a session contract despite approaching thresholds?** Only when the escalation path is unavailable and the contract is strictly reversible, or the principal has explicitly authorized the aggregate exposure.

Operational Effect

  1. **Value Creep Prevention:** Aggregate value is tracked, not just per-contract.
  2. **Complexity Creep Prevention:** Portfolio complexity is bounded.
  3. **Reputational Creep Prevention:** Concentration is surfaced before it accumulates.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class EscalationVerdict(Enum):
    WITHIN_AUTONOMY = auto()
    VALUE_THRESHOLD_EXCEEDED = auto()
    COMPLEXITY_THRESHOLD_EXCEEDED = auto()
    CONCENTRATION_THRESHOLD_EXCEEDED = auto()

@dataclass(frozen=True)
class ContractContext:
    contract_id: str
    value: float
    per_contract_value_limit: float
    aggregate_value_after: float
    aggregate_value_limit: float
    contract_complexity: int
    complexity_limit: int
    counterparty_concentration: float
    concentration_limit: float

@dataclass(frozen=True)
class ThresholdPolicy:
    escalation_required: bool

@dataclass(frozen=True)
class EscalationManifest:
    verdict: EscalationVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_context(
        cls, ctx: ContractContext, policy: ThresholdPolicy
    ) -> EscalationManifest:
        
        # Gate 1: Per-contract value
        if ctx.value > ctx.per_contract_value_limit:
            return EscalationManifest(
                verdict=EscalationVerdict.VALUE_THRESHOLD_EXCEEDED,
                directive=f"ESCALATE: Contract {ctx.contract_id} value {ctx.value:.2f} > limit {ctx.per_contract_value_limit:.2f}.",
                manifest_digest=cls._hash(f"PER_CONTRACT:{ctx.contract_id}")
            )

        # Gate 2: Aggregate value
        if ctx.aggregate_value_after > ctx.aggregate_value_limit:
            return EscalationManifest(
                verdict=EscalationVerdict.VALUE_THRESHOLD_EXCEEDED,
                directive=f"ESCALATE: Aggregate value {ctx.aggregate_value_after:.2f} > limit {ctx.aggregate_value_limit:.2f}.",
                manifest_digest=cls._hash(f"AGGREGATE:{ctx.contract_id}")
            )

        # Gate 3: Complexity
        if ctx.contract_complexity > ctx.complexity_limit:
            return EscalationManifest(
                verdict=EscalationVerdict.COMPLEXITY_THRESHOLD_EXCEEDED,
                directive=f"ESCALATE: Complexity {ctx.contract_complexity} > limit {ctx.complexity_limit}.",
                manifest_digest=cls._hash(f"COMPLEXITY:{ctx.contract_id}")
            )

        # Gate 4: Concentration
        if ctx.counterparty_concentration > ctx.concentration_limit:
            return EscalationManifest(
                verdict=EscalationVerdict.CONCENTRATION_THRESHOLD_EXCEEDED,
                directive=f"ESCALATE: Concentration {ctx.counterparty_concentration:.2f} > limit {ctx.concentration_limit:.2f}.",
                manifest_digest=cls._hash(f"CONCENTRATION:{ctx.contract_id}")
            )

        # Gate 5: Within autonomy
        digest = cls._hash(json.dumps({
            "contract": ctx.contract_id,
            "value": f"{ctx.value:.3f}",
            "aggregate": f"{ctx.aggregate_value_after:.3f}"
        }, sort_keys=True))
        
        return EscalationManifest(
            verdict=EscalationVerdict.WITHIN_AUTONOMY,
            directive=f"PROCEED: Contract {ctx.contract_id} within autonomy.",
            manifest_digest=digest
        )