How must an instance flag provisional conclusions that lacked final verification?
**Date of Record:** 2026 October 25 **Scope:** Applies when an agentic session derives a logical conclusion or environmental assumption but is forced to terminate before executing the final empirical verification step (e.g., missing credentials, sandbox timeouts, or unavailable test harnesses). Does not apply to conclusions that successfully passed external ground-truth verification, or to purely speculative hypotheses that were never logically derived.
Core Distinction
The separation between **verified operational invariants** (claims backed by an empirical execution receipt) and **provisional conclusions** (claims logically derived from available evidence but lacking the final external probe to confirm them). Verified invariants are safe for a successor to inherit and act upon immediately; provisional conclusions must be inherited with a fail-closed directive and an explicit promotion predicate. Treating a provisional conclusion as an invariant causes silent failure propagation; discarding it entirely forces the successor to repeat the logical derivation.
What Was Observed
In multi-session agent architectures, failing to properly flag provisional conclusions produces three primary failure modes:
- **Silent Assumption Propagation:** An instance infers that a specific API endpoint exists based on pattern matching, but times out before testing it. It persists the conclusion as a fact, causing the successor to dispatch a request to a non-existent endpoint and crash.
- **Epistemic Amnesia:** An instance derives a complex logical proof of why a system fails under a specific condition, but cannot test it due to sandbox restrictions. It discards the derivation, forcing the successor to spend its context window re-deriving the exact same proof from scratch.
- **False Promotion:** An instance conflates "the test ran without crashing" with "the test verified the behavior," promoting a provisional conclusion to a verified invariant without an explicit ground-truth receipt, leading to invalidated assumptions.
Recorded Elements
- **`provisional_claim`:** The exact declarative statement derived during the session, stripped of all exploratory narrative.
- **`logical_derivation_path`:** A compressed summary of the evidence used to arrive at the claim, allowing the successor to understand the reasoning without re-reading the full trace.
- **`missing_verification_step`:** The exact empirical probe (command, API call, or test invocation) required to promote the provisional claim to a verified invariant.
- **`fail_closed_directive`:** The explicit constraint that the successor must not act on the provisional claim until the missing verification step is executed and returns a success receipt.
Condition of Validity
* **Applies when:** The instance has reached a logical conclusion but the session terminates before the final ground-truth verification can be executed, and a successor will resume the task. * **Does not apply when:** The conclusion has already been empirically verified (it is an invariant), or the conclusion is so weak that it lacks any logical derivation (it is speculation and should be discarded).
Decision Boundary
- **Is the conclusion backed by a definitive empirical execution receipt (exit code 0, schema validation)?** If yes, record it as a verified invariant. If no, proceed to flag it as provisional.
- **Is the missing verification step explicit and executable by a successor?** If no, the provisional conclusion is too vague to be actionable and must be discarded. If yes, record the exact command or probe.
- **Does the provisional claim alter the successor's admissible action space?** If the successor would act differently based on this claim, it must be persisted with the `fail_closed_directive` attached.
- **Conversely, when should a provisional conclusion be discarded rather than retained?** If the claim is redundant (already covered by a verified invariant), or if deriving the missing verification step would require reconstructing the entire session context, it is not worth persisting.
Operational Effect
- **Safe Continuity:** Allows successor instances to inherit logical progress without inheriting the risk of unverified assumptions.
- **Deterministic Promotion:** Provides a clear, executable to-do list for the successor (execute the `missing_verification_step`), converting a provisional claim into a verified invariant with minimal context overhead.
- **Epistemic Integrity:** Maintains the strict boundary between what is known to be true (empirically verified) and what is believed to be true (logically derived), preventing hallucination propagation.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json
class EpistemicState(Enum):
VERIFIED_INVARIANT = auto()
PROVISIONAL_UNVERIFIED = auto()
DISCARDED = auto()
@dataclass(frozen=True)
class ProvisionalConclusion:
claim_id: str
claim_statement: str
logical_derivation_summary: str
missing_verification_step: str
@dataclass(frozen=True)
class FlaggedConclusion:
claim_id: str
claim_statement: str
epistemic_state: EpistemicState
missing_verification_step: str | None
fail_closed_directive: str | None
@dataclass(frozen=True)
class EpistemicArchive:
flagged_conclusions: tuple[FlaggedConclusion, ...]
archive_digest: str
class ProvisionalFlaggingGate:
"""
Evaluates derived conclusions lacking empirical receipts, sealing them
as provisional with explicit fail-closed directives for successors.
"""
@staticmethod
def _hash(data: str) -> str:
return hashlib.sha256(data.encode("utf-8")).hexdigest()
@classmethod
def evaluate_conclusion(
cls,
conclusion: ProvisionalConclusion,
has_empirical_receipt: bool,
) -> FlaggedConclusion:
if has_empirical_receipt:
return FlaggedConclusion(
claim_id=conclusion.claim_id,
claim_statement=conclusion.claim_statement,
epistemic_state=EpistemicState.VERIFIED_INVARIANT,
missing_verification_step=None,
fail_closed_directive=None,
)
# Fail closed if the verification step is missing or empty
if not conclusion.missing_verification_step.strip():
return FlaggedConclusion(
claim_id=conclusion.claim_id,
claim_statement=conclusion.claim_statement,
epistemic_state=EpistemicState.DISCARDED,
missing_verification_step=None,
fail_closed_directive=None,
)
directive = (
f"DO NOT ACT ON {conclusion.claim_id}. "
f"Execute verification: {conclusion.missing_verification_step}"
)
return FlaggedConclusion(
claim_id=conclusion.claim_id,
claim_statement=conclusion.claim_statement,
epistemic_state=EpistemicState.PROVISIONAL_UNVERIFIED,
missing_verification_step=conclusion.missing_verification_step,
fail_closed_directive=directive,
)
@classmethod
def seal_archive(
cls, flagged: tuple[FlaggedConclusion, ...]
) -> EpistemicArchive:
retained = tuple(
f for f in flagged if f.epistemic_state is not EpistemicState.DISCARDED
)
if not retained:
raise ValueError("Cannot seal an empty epistemic archive.")
digest_payload = {
"conclusions": tuple(
sorted(
f"{f.claim_id}:{f.epistemic_state.name}"
for f in retained
)
)
}
digest = cls._hash(
json.dumps(digest_payload, sort_keys=True, separators=(",", ":"))
)
return EpistemicArchive(
flagged_conclusions=retained,
archive_digest=digest,
)
@classmethod
def verify_promotion(
cls, archive: EpistemicArchive, claim_id: str, verification_receipt: str
) -> bool:
"""
Fetching-time check: confirms a provisional conclusion can be promoted
to a verified invariant based on a successor's execution receipt.
"""
if not verification_receipt.strip():
return False
for conclusion in archive.flagged_conclusions:
if conclusion.claim_id == claim_id:
if conclusion.epistemic_state is EpistemicState.PROVISIONAL_UNVERIFIED:
# A non-empty receipt satisfies the promotion predicate
return True
return False