What invariants bound inferential uncertainty when observation is costly?

**Date of Record:** 2026 October 27 **Scope:** Applies when an agentic session must make inferences about a state, and each observation (probe, query, check) costs resources, requiring the session to bound inferential uncertainty without exhausting observation budget. Does not apply to sessions with free observation or where uncertainty bounds are irrelevant.

Core Distinction

The separation between **inferential accuracy** (how close the agent's belief is to truth) and **inferential cost** (the resources spent achieving that accuracy). Relying on accuracy alone creates the **Unbounded Observation Trap**: the agent keeps probing to reduce uncertainty, but each probe has diminishing returns and the total cost vastly exceeds the value of the accuracy gained.

What Was Observed

In observation-costly agent architectures, failing to bound inferential cost produces three primary failure modes:

  1. **Observation Budget Exhaustion:** The agent probes extensively to reduce uncertainty, and by the time it is confident, the budget for the actual action is depleted.
  2. **Diminishing Returns Blindness:** The agent continues probing after uncertainty is already sufficient for the decision, wasting resources on unnecessary precision.
  3. **Decision Paralysis:** The agent treats all uncertainty as requiring observation, so it never acts. Theoretically accurate but operationally useless.

Recorded Elements

  1. **`observation_cost_receipt`:** The exact cost of each observation (tokens, compute, API calls, time), so the agent knows the cost curve.
  2. **`uncertainty_reduction_per_cost_signature`:** The expected uncertainty reduction per observation cost, so the agent can compute marginal value of additional observation.
  3. **`decision_sufficiency_predicate_receipt`:** The exact uncertainty threshold below which the decision can be made, so the agent knows when to stop observing.
  4. **`observation_budget_envelope_signature`:** The total observation budget available, with reserve for the actual action, so observation cannot consume everything.

Condition of Validity

* **Applies when:** Observation is costly, uncertainty is reducible by observation, and decisions are made under uncertainty. * **Does not apply when:** Observation is free, or decisions require perfect information regardless of cost.

Decision Boundary

  1. **Is uncertainty above the `decision_sufficiency_predicate_receipt`?** If no, act on current beliefs. If yes, observe more.
  2. **Is the next observation's marginal uncertainty reduction worth its cost (`uncertainty_reduction_per_cost_signature`)?** If yes, observe. If no, act despite uncertainty.
  3. **Will the next observation exceed the `observation_budget_envelope_signature`?** If yes, act on current beliefs. If no, proceed with observation.
  4. **Conversely, when can an agent continue observing past sufficiency?** Only when the action is irreversible and requires maximum confidence, and the budget allows it, and the marginal value is verified.

Operational Effect

  1. **Cost Bound:** Observation stops at sufficiency, preserving budget for action.
  2. **Decision Progression:** The agent acts on current beliefs when further observation has poor cost-to-value ratio.
  3. **Diminishing Returns Recognition:** The agent stops observing when additional observation no longer reduces uncertainty meaningfully.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class ObservationVerdict(Enum):
    BELIEF_SUFFICIENT = auto()
    OBSERVE_FURTHER = auto()
    BUDGET_EXHAUSTED = auto()
    DIMINISHING_RETURNS = auto()

@dataclass(frozen=True)
class BeliefState:
    belief_id: str
    current_uncertainty: float
    decision_sufficiency_threshold: float
    observation_budget_used: float
    observation_budget_total: float

@dataclass(frozen=True)
class ObservationProposal:
    observation_id: str
    expected_uncertainty_reduction: float
    cost: float

@dataclass(frozen=True)
class ObservationPolicy:
    min_marginal_value: float  # uncertainty_reduction / cost

@dataclass(frozen=True)
class ObservationManifest:
    verdict: ObservationVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_observation(
        cls, belief: BeliefState, obs: ObservationProposal, policy: ObservationPolicy
    ) -> ObservationManifest:
        
        # Gate 1: Already sufficient
        if belief.current_uncertainty <= belief.decision_sufficiency_threshold:
            digest = cls._hash(json.dumps({
                "belief": belief.belief_id,
                "uncertainty": f"{belief.current_uncertainty:.3f}",
                "threshold": f"{belief.decision_sufficiency_threshold:.3f}"
            }, sort_keys=True))
            return ObservationManifest(
                verdict=ObservationVerdict.BELIEF_SUFFICIENT,
                directive=f"PROCEED: Uncertainty {belief.current_uncertainty:.3f} <= {belief.decision_sufficiency_threshold:.3f}, act.",
                manifest_digest=digest
            )

        # Gate 2: Budget check
        remaining_budget = belief.observation_budget_total - belief.observation_budget_used
        if obs.cost > remaining_budget:
            return ObservationManifest(
                verdict=ObservationVerdict.BUDGET_EXHAUSTED,
                directive=f"HALT: Observation {obs.observation_id} cost {obs.cost:.2f} > remaining {remaining_budget:.2f}.",
                manifest_digest=cls._hash(f"BUDGET:{obs.observation_id}")
            )

        # Gate 3: Marginal value
        if obs.cost <= 0:
            return ObservationManifest(
                verdict=ObservationVerdict.OBSERVE_FURTHER,
                directive=f"PROCEED: Observation {obs.observation_id} is free.",
                manifest_digest=cls._hash(f"FREE:{obs.observation_id}")
            )

        marginal_value = obs.expected_uncertainty_reduction / obs.cost
        if marginal_value < policy.min_marginal_value:
            return ObservationManifest(
                verdict=ObservationVerdict.DIMINISHING_RETURNS,
                directive=f"HALT: Marginal value {marginal_value:.4f} < {policy.min_marginal_value:.4f}, act on current beliefs.",
                manifest_digest=cls._hash(f"DIMINISHING:{marginal_value:.4f}")
            )

        # Gate 4: Observe further
        digest = cls._hash(json.dumps({
            "belief": belief.belief_id,
            "observation": obs.observation_id,
            "marginal_value": f"{marginal_value:.4f}",
            "expected_reduction": f"{obs.expected_uncertainty_reduction:.3f}",
            "cost": f"{obs.cost:.2f}"
        }, sort_keys=True))
        
        return ObservationManifest(
            verdict=ObservationVerdict.OBSERVE_FURTHER,
            directive=f"PROCEED: Observation {obs.observation_id} marginal value {marginal_value:.3f}.",
            manifest_digest=digest
        )