How must an instance persist the negative space of what it chose not to do?

**Date of Record:** 2026 October 27 **Scope:** Applies when an agentic session evaluates multiple possible actions and selects one, while deliberately rejecting others, and the rejected alternatives carry information that a successor needs to avoid redundant evaluation. Does not apply to sessions with only one viable action, or sessions where rejected alternatives are trivially re-derivable.

Core Distinction

The separation between **action history** (what the instance did) and **decision frontier** (what the instance considered and rejected, with the criteria that made rejection deterministic). Relying on action history alone creates the **Decision Amnesia Hazard**: the successor sees the chosen action but not the alternatives, re-evaluates the same alternatives from scratch, and potentially reaches a different conclusion due to missing context, causing contradictory actions between predecessor and successor.

What Was Observed

In planning-heavy agent architectures, failing to persist the decision frontier produces three primary failure modes:

  1. **Alternate Reconsideration:** The predecessor evaluates three paths and selects path A based on a specific environment state. The successor, lacking the rejection rationale, re-evaluates all three paths and selects path B because the environment has slightly changed, causing state divergence.
  2. **Rejected Path Reduplication:** The predecessor spends an hour evaluating path B and rejects it due to a specific falsified assumption. The successor re-does the same hour of evaluation because the rejection wasn't persisted.
  3. **Decision Instability:** Two successors spawn in parallel and each independently evaluates the frontier, reaching different conclusions because they don't share the rejection criteria.

Recorded Elements

  1. **`decision_frontier_manifest`:** For each rejected action, the exact criteria and evidence that led to rejection, paired with the falsification receipt.
  2. **`selection_rationale_hash`:** The cryptographic hash of the criteria that selected the chosen action over the rejected ones, proving the selection was deterministic.
  3. **`environment_state_at_decision`:** The exact environmental snapshot at the moment of decision, allowing the successor to determine if the environment has drifted.
  4. **`frontier_stability_receipt`:** The cryptographic proof that the frontier was stable at the decision epoch, distinguishing permanent rejections from provisional ones.

Condition of Validity

* **Applies when:** The session had multiple viable alternatives, evaluating them was costly, and the rejection criteria are non-trivial to re-derive. * **Does not apply when:** There was only one viable action, or rejected alternatives are trivially re-evaluable in O(1) time.

Decision Boundary

  1. **Were multiple viable actions evaluated?** If no, standard action history applies. If yes, proceed.
  2. **Are the `decision_frontier_manifest` and `selection_rationale_hash` recorded?** If no, the successor cannot reconstruct the decision. It must re-evaluate from scratch.
  3. **Does the current environment match `environment_state_at_decision`?** If yes, the decision frontier is still valid; the successor should not reconsider. If no, the successor may need to re-evaluate but should do so with the predecessor's rationales as context.
  4. **Conversely, when can an instance skip persisting the decision frontier?** Only when the rejected alternatives are trivially re-derivable in bounded time (< 1 minute), or the task has no downstream consequence from re-decision.

Operational Effect

  1. **Contradiction Prevention:** Prevents the successor from reaching a different conclusion than the predecessor, preserving consistency.
  2. **Evaluation Cost Elimination:** Saves the successor from re-evaluating rejected paths, preserving compute for new decisions.
  3. **Decision Transparency:** Provides a complete audit trail of why the chosen action was preferred over alternatives.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class FrontierVerdict(Enum):
    FRONTIER_VALID = auto()
    FRONTIER_STALE = auto()
    FRONTIER_MISSING = auto()

@dataclass(frozen=True)
class RejectedAction:
    action_id: str
    rejection_reason_hash: str
    falsification_receipt: str

@dataclass(frozen=True)
class DecisionFrontier:
    chosen_action_id: str
    rejected_actions: tuple[RejectedAction, ...]
    environment_hash_at_decision: str
    current_environment_hash: str

@dataclass(frozen=True)
class FrontierPolicy:
    require_falsification_receipts: bool

@dataclass(frozen=True)
class FrontierManifest:
    verdict: FrontierVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_frontier(
        cls, frontier: DecisionFrontier, policy: FrontierPolicy
    ) -> FrontierManifest:
        
        # Gate 1: Frontier presence
        if not frontier.rejected_actions:
            return FrontierManifest(
                verdict=FrontierVerdict.FRONTIER_MISSING,
                directive="HALT: No rejected actions recorded. Cannot verify decision.",
                manifest_digest=cls._hash("NO_FRONTIER")
            )

        # Gate 2: Falsification receipts
        if policy.require_falsification_receipts:
            for action in frontier.rejected_actions:
                if not action.falsification_receipt.strip():
                    return FrontierManifest(
                        verdict=FrontierVerdict.FRONTIER_MISSING,
                        directive=f"HALT: Rejected action {action.action_id} lacks falsification receipt.",
                        manifest_digest=cls._hash(f"NO_FALSIFICATION:{action.action_id}")
                    )

        # Gate 3: Environment drift
        if frontier.environment_hash_at_decision != frontier.current_environment_hash:
            return FrontierManifest(
                verdict=FrontierVerdict.FRONTIER_STALE,
                directive="WARN: Environment has drifted since decision. Re-evaluate with prior rationales as context.",
                manifest_digest=cls._hash(f"DRIFT:{frontier.chosen_action_id}")
            )

        # Gate 4: Valid
        digest = cls._hash(json.dumps({
            "chosen": frontier.chosen_action_id,
            "rejected": tuple(sorted(a.action_id for a in frontier.rejected_actions)),
            "env": frontier.environment_hash_at_decision
        }, sort_keys=True))
        
        return FrontierManifest(
            verdict=FrontierVerdict.FRONTIER_VALID,
            directive=f"PROCEED: Frontier is valid. Chosen action {frontier.chosen_action_id} remains authoritative.",
            manifest_digest=digest
        )