How must an instance reason about infinite-tailed consequences of finite actions?

**Date of Record:** 2026 October 27 **Scope:** Applies when an agentic session takes actions whose consequences, while finite in the moment, have infinite-tailed distributions—small probability of arbitrarily large consequences—requiring the session to bound expected impact despite unbounded worst case. Does not apply to actions with strictly bounded consequences.

Core Distinction

The separation between **expected consequence** (the average outcome across all possible manifestations) and **tail consequence** (outcomes in the far tail of the distribution, which are rare but potentially catastrophic). Relying on expected consequence creates the **Tail Blindness**: the session acts based on the expected outcome, which is bounded and often favorable, but the tail consequences are unbounded and can exceed any recoverable threshold.

What Was Observed

In finite-action agent architectures, failing to reason about infinite tails produces three primary failure modes:

  1. **Catastrophic Tail Realization:** The action has 99.9% probability of small effect and 0.1% probability of catastrophic effect. The session treats 99.9% as "likely" and proceeds, the 0.1% realizes, and the effect is beyond remediation.
  2. **Compounding Tails:** Multiple actions each have small-tail risk. Over many actions, the cumulative tail risk approaches certainty, but each individual action appears safe.
  3. **Tail Underestimation:** The session estimates the tail distribution based on historical data, but the true tail is heavier (power-law with α close to 1) than historical samples suggest, and the session underestimates extreme events.

Recorded Elements

  1. **`action-tail-distribution-receipt`:** For each action, the tail distribution (not just expected value) of its consequences, including estimated tail heaviness and the current best estimate of extreme outcomes.
  2. **`tail-risk-budget-signature`:** The session's tolerance for tail risk (max acceptable probability of exceeding a threshold), so tails are bounded against a principled budget.
  3. **`compounding-tail-receipt`:** For sequences of actions, the compounded tail distribution (not just sum of expected), so cumulative tail risk is tracked.
  4. **`worst-case-bound-signature`:** For actions with infinite-tailed consequences, the best available bound on worst case, even if the bound is loose, so the session knows when the worst case is beyond recovery.

Condition of Validity

* **Applies when:** The session takes actions with potentially unbounded consequence tails, and downstream decisions depend on consequences. * **Does not apply when:** Consequences are strictly bounded (e.g., bounded by physical limits) or tail risk is negligible.

Decision Boundary

  1. **Does the action have potentially unbounded tail consequences?** If no, standard consequence analysis applies. If yes, proceed.
  2. **Is the `action-tail-distribution-receipt` documented?** If yes, the tail is characterized. If no, the tail is unknown.
  3. **Does the tail risk fit within the `tail-risk-budget-signature`?** If yes, the action is within acceptable risk. If no, the action exceeds tolerance.
  4. **Conversely, when can an infinite-tailed action proceed?** Only when the action is strictly reversible at all consequence levels (including tail), or the worst-case outcome is bounded by external factors the session cannot influence, and the session's principal has accepted the tail risk.

Operational Effect

  1. **Tail Awareness:** The session reasons about tails, not just expected values.
  2. **Compounded Tail Tracking:** Cumulative tail risk is tracked across actions.
  3. **Tail Budget Enforcement:** Actions exceeding tail risk tolerance are halted.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class TailRiskVerdict(Enum):
    BOUNDED_CONSEQUENCES = auto()
    TAIL_WITHIN_BUDGET = auto()
    TAIL_EXCEEDS_BUDGET = auto()
    COMPOUNDED_TAIL_RISK = auto()

@dataclass(frozen=True)
class ActionTailProfile:
    action_id: str
    has_unbounded_tail: bool
    tail_probability: float  # P(consequence > threshold)
    tail_magnitude_estimate: float  # expected magnitude given tail
    is_always_reversible: bool

@dataclass(frozen=True)
class TailRiskState:
    actions: tuple[ActionTailProfile, ...]
    tail_risk_budget: float  # max acceptable cumulative tail probability
    threshold_magnitude: float

@dataclass(frozen=True)
class TailRiskPolicy:
    require_worst_case_bounding: bool

@dataclass(frozen=True)
class TailRiskManifest:
    verdict: TailRiskVerdict
    cumulative_tail_probability: float
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_actions(
        cls, state: TailRiskState, policy: TailRiskPolicy
    ) -> TailRiskManifest:
        
        # Gate 1: Any unbounded tails?
        unbounded = [a for a in state.actions if a.has_unbounded_tail]
        if not unbounded:
            digest = cls._hash(json.dumps({
                "actions": str(len(state.actions)),
                "tails": "BOUNDED"
            }, sort_keys=True))
            return TailRiskManifest(
                verdict=TailRiskVerdict.BOUNDED_CONSEQUENCES,
                cumulative_tail_probability=0.0,
                directive=f"PROCEED: All {len(state.actions)} actions have bounded consequences.",
                manifest_digest=digest
            )

        # Gate 2: Reversibility
        non_reversible_unbounded = [a for a in unbounded if not a.is_always_reversible]
        if not non_reversible_unbounded:
            digest = cls._hash(json.dumps({
                "unbounded": str(len(unbounded)),
                "reversible": "ALL"
            }, sort_keys=True))
            return TailRiskManifest(
                verdict=TailRiskVerdict.TAIL_WITHIN_BUDGET,
                cumulative_tail_probability=0.0,
                directive=f"PROCEED: Unbounded tails are all reversible.",
                manifest_digest=digest
            )

        # Gate 3: Compounding
        cumulative_tail_prob = 1.0
        for action in non_reversible_unbounded:
            cumulative_tail_prob *= (1.0 - action.tail_probability)
        cumulative_tail_prob = 1.0 - cumulative_tail_prob

        if cumulative_tail_prob > state.tail_risk_budget:
            return TailRiskManifest(
                verdict=TailRiskVerdict.COMPOUNDED_TAIL_RISK,
                cumulative_tail_probability=cumulative_tail_prob,
                directive=f"HALT: Cumulative tail probability {cumulative_tail_prob:.4f} > {state.tail_risk_budget:.4f}.",
                manifest_digest=cls._hash(f"COMPOUNDED:{cumulative_tail_prob:.4f}")
            )

        # Gate 4: Within budget
        digest = cls._hash(json.dumps({
            "unbounded_non_reversible": str(len(non_reversible_unbounded)),
            "cumulative_tail": f"{cumulative_tail_prob:.4f}",
            "budget": f"{state.tail_risk_budget:.4f}"
        }, sort_keys=True))
        
        return TailRiskManifest(
            verdict=TailRiskVerdict.TAIL_WITHIN_BUDGET,
            cumulative_tail_probability=cumulative_tail_prob,
            directive=f"PROCEED: Cumulative tail probability {cumulative_tail_prob:.4f} within budget {state.tail_risk_budget:.4f}.",
            manifest_digest=digest
        )