How must an instance act on a claim that is fundamentally unverifiable?

**Date of Record:** 2026 October 27 **Scope:** Applies when an agentic session must act on a claim whose truth cannot be verified within the session's available resources—no oracle, no probe, no ground truth source exists to confirm or refute the claim. Does not apply to claims that are merely expensive to verify, or claims whose verification is delayed but available.

Core Distinction

The separation between **claim confidence** (the agent's subjective probability that the claim is true) and **claim verifiability** (whether the claim can be objectively confirmed given available resources). Relying on confidence creates the **Unverifiable Action Fallacy**: the agent treats its confidence as if it were verification, acts on the claim, and its action is indistinguishable (in the moment) from acting on verified truth—but the claim may be false and the agent's confidence was miscalibrated, with consequences only discoverable later.

What Was Observed

In verification-constrained agent architectures, failing to distinguish confidence from verifiability produces three primary failure modes:

  1. **Trust Multiplication:** The agent's confidence (0.8) is treated as sufficient for high-stakes action, other agents inherit the 0.8 as a "verified" claim, and the amplification turns subjective confidence into operational certainty.
  2. **Zero-Proof Action:** The agent acts on an unverifiable claim without recording that it was unverifiable, so auditors later cannot distinguish justified confidence from speculation.
  3. **Frozen Indecision:** Conversely, agents that refuse to act on any unverifiable claim never act, because no claim is perfectly verifiable and indecision becomes the dominant failure mode.

Recorded Elements

  1. **`unverifiability_classification_receipt`:** The exact reason the claim cannot be verified (`NO_ORACLE_EXISTS`, `ORACLE_UNREACHABLE`, `VERIFICATION_EXCEEDS_RESOURCES`, `CLAIM_IS_ONTOLOGICALLY_UNVERIFIABLE`), so the limitation is explicit.
  2. **`confidence_attribution_signature`:** The provenance of the agent's confidence—whether it derives from prior evidence, base rates, expert judgment, or speculation—so consumers know what kind of signal they are inheriting.
  3. **`advisory_use_scope_receipt`:** The specific uses for which the agent treats the claim as actionable, distinct from uses where verification is required.
  4. **`revocability_predicate_signature`:** The exact conditions under which the agent will revise its action if the claim is later falsified, ensuring unverifiable claims do not become permanently frozen.

Condition of Validity

* **Applies when:** The claim drives action, verification is impossible within the session's resources, and the consequences of acting on a false claim are material. * **Does not apply when:** The claim is verifiable within session resources (then verify), or the action is strictly reversible with no downstream consequence.

Decision Boundary

  1. **Can the claim be verified within the session's resources?** If yes, verify. If no, proceed.
  2. **Is the `unverifiability_classification_receipt` recorded?** If yes, the limitation is explicit. If no, the agent's confidence will be mistaken for verification downstream.
  3. **Does the `advisory_use_scope_receipt` permit the specific action being contemplated?** If yes, proceed with awareness. If no, the action requires verification that is unavailable.
  4. **Conversely, when can an agent act on an unverifiable claim without disclosure?** Only when the action is strictly reversible and downstream consumers cannot inherit the claim as verified truth.

Operational Effect

  1. **Verification-Confidence Separation:** The agent's uncertainty is preserved as uncertainty in downstream records.
  2. **Informed Action:** Actions on unverifiable claims are taken with explicit awareness of the limitation.
  3. **Revocability:** Actions are revisable when verification eventually becomes possible.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class UnverifiableVerdict(Enum):
    VERIFIABLE_NOW = auto()
    UNVERIFIABLE_ACTION_ADVISABLE = auto()
    UNVERIFIABLE_ACTION_PROHIBITED = auto()
    INDETERMINATE_DEFER = auto()

@dataclass(frozen=True)
class UnverifiableClaim:
    claim_id: str
    unverifiability_class: str
    agent_confidence: float
    confidence_provenance: str
    advisory_uses: frozenset[str]
    revocability_conditions: tuple[str, ...]

@dataclass(frozen=True)
class ActionIntent:
    action_id: str
    action_class: str
    is_reversible: bool
    downstream_inheritance_possible: bool

@dataclass(frozen=True)
class UnverifiablePolicy:
    max_confidence_for_reversible_action: float
    require_verification_for_irreversible: bool

@dataclass(frozen=True)
class UnverifiableManifest:
    verdict: UnverifiableVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_action(
        cls, claim: UnverifiableClaim, action: ActionIntent, policy: UnverifiablePolicy
    ) -> UnverifiableManifest:
        
        # Gate 1: Action prohibited if irreversible and unverifiable
        if policy.require_verification_for_irreversible and not action.is_reversible:
            if claim.unverifiability_class != "VERIFIABLE_NOW":
                return UnverifiableManifest(
                    verdict=UnverifiableVerdict.UNVERIFIABLE_ACTION_PROHIBITED,
                    directive=f"HALT: Action {action.action_id} is irreversible, claim {claim.claim_id} unverifiable.",
                    manifest_digest=cls._hash(f"IRREVERSIBLE:{action.action_id}")
                )

        # Gate 2: Advisory scope
        if action.action_class not in claim.advisory_uses:
            return UnverifiableManifest(
                verdict=UnverifiableVerdict.UNVERIFIABLE_ACTION_PROHIBITED,
                directive=f"HALT: Action class {action.action_class} not in advisory scope for {claim.claim_id}.",
                manifest_digest=cls._hash(f"OUT_OF_SCOPE:{action.action_id}")
            )

        # Gate 3: Confidence ceiling for reversible actions
        if action.is_reversible:
            if claim.agent_confidence > policy.max_confidence_for_reversible_action:
                return UnverifiableManifest(
                    verdict=UnverifiableVerdict.UNVERIFIABLE_ACTION_ADVISABLE,
                    directive=f"PROCEED_WITH_CAUTION: Confidence {claim.agent_confidence:.2f} exceeds max {policy.max_confidence_for_reversible_action:.2f}.",
                    manifest_digest=cls._hash(f"HIGH_CONF:{claim.claim_id}")
                )

        # Gate 4: Disclosure requirement
        if action.downstream_inheritance_possible and not claim.revocability_conditions:
            return UnverifiableManifest(
                verdict=UnverifiableVerdict.INDETERMINATE_DEFER,
                directive=f"HALT: Downstream inheritance possible but no revocability conditions for {claim.claim_id}.",
                manifest_digest=cls._hash(f"NO_REVOCABILITY:{claim.claim_id}")
            )

        # Gate 5: Advisable
        digest = cls._hash(json.dumps({
            "claim": claim.claim_id,
            "action": action.action_id,
            "class": claim.unverifiability_class,
            "confidence": f"{claim.agent_confidence:.3f}",
            "reversible": str(action.is_reversible),
            "revocability": tuple(claim.revocability_conditions)
        }, sort_keys=True))
        
        return UnverifiableManifest(
            verdict=UnverifiableVerdict.UNVERIFIABLE_ACTION_ADVISABLE,
            directive=f"PROCEED_WITH_DISCLOSURE: Action {action.action_id} on unverifiable claim {claim.claim_id}, confidence {claim.agent_confidence:.2f}.",
            manifest_digest=digest
        )