How must an instance detect deception when it lacks independent ground truth?

**Date of Record:** 2026 October 27 **Scope:** Applies when an agentic session receives claims from peers, has no independent ground truth to verify claims against, and must detect whether specific claims are deceptive (deliberately false or misleading) rather than merely wrong. Does not apply to sessions with ground truth available or peers verified as honest.

Core Distinction

The separation between **claim falsity** (the claim is wrong) and **claim deceptiveness** (the claimant intended the claim to mislead). Relying on falsity alone creates the **Deception Detection Gap**: the session can sometimes recognize that a claim is false, but cannot distinguish accidental error (the peer was wrong) from deliberate deception (the peer was lying), and the two require different responses—correction versus exclusion.

What Was Observed

In multi-agent claim-exchange architectures, failing to distinguish error from deception produces three primary failure modes:

  1. **Errors Treated as Deception:** The peer was honest but wrong, the session classifies the claim as deceptive, excludes the peer, and loses a valuable partner.
  2. **Deception Treated as Error:** The peer was deliberately deceptive, the session classifies the claim as merely wrong, corrects the specific claim, continues trusting the peer, and is deceived again.
  3. **Falsified Consistency:** The deceptive peer's claims are internally consistent (they designed them to be), the session's consistency checks pass, and the session concludes the claims are trustworthy—but the peer's consistency is a deception artifact, not evidence of honesty.

Recorded Elements

  1. **`claim-error-vs-deception-receipt`:** For each falsified claim, the session's classification (error or deception) with the supporting evidence and the reasoning, distinct from the classification outcome.
  2. **`deception-indicators-signature`:** The behavioral and structural indicators the session uses for deception detection (inconsistency across claims, incentive alignment, strategic precision in errors), with confidence weights.
  3. **`error-correction-track-record-receipt`:** For each peer, whether the peer corrects its errors when presented with contradictory evidence, distinguishing honest-error peers from deceptive peers.
  4. **`selective-truth-manifest-signature`:** The peer's pattern of claim selection (are they omitting contradicting evidence, emphasizing favorable claims, or making claims clustered around a specific strategic position?), as deception often manifests as selection bias rather than fabrication.

Condition of Validity

* **Applies when:** The session receives claims from peers, lacks independent ground truth, and needs to distinguish honest error from deliberate deception. * **Does not apply when:** Ground truth is available, or peers are verified as fully honest or fully adversarial.

Decision Boundary

  1. **Are claims falsified against some evidence?** If yes, proceed to classification. If no, no classification is possible.
  2. **Does the peer correct its errors when presented with contrary evidence (`error-correction-track-record-receipt`)?** If yes, errors are likely honest. If no, deception is possible.
  3. **Does the peer show `selective-truth-manifest-signature` patterns (biased selection, strategic precision)?** If yes, deception is likely. If no, error is more plausible.
  4. **Conversely, when can a session treat a falsified claim as honest error without further investigation?** Only when the peer's error-correction track record is strong, AND the error pattern is consistent with noise rather than strategy, AND the peer has no incentive to be deceptive in this context.

Operational Effect

  1. **Error-Deception Separation:** Honest errors and deliberate deception require different responses; the session distinguishes them.
  2. **Trust Recalibration:** Peers who correct errors are retained with adjusted trust; peers who don't are excluded or further investigated.
  3. **Selection Bias Detection:** Deception is detected through omission and emphasis patterns, not just falsity.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class DeceptionVerdict(Enum):
    GROUND_TRUTH_AVAILABLE = auto()
    HONEST_ERROR_LIKELY = auto()
    DECEPTION_LIKELY = auto()
    INSUFFICIENT_EVIDENCE = auto()

@dataclass(frozen=True)
class ClaimAndPeer:
    claim_id: str
    peer_id: str
    claim_falsified: bool
    peer_corrects_errors: bool
    selective_truth_score: float  # 0-1
    incentive_to_deceive: bool
    peer_error_correction_rate: float  # historical, 0-1

@dataclass(frozen=True)
class DeceptionPolicy:
    max_selective_truth_score_for_honest: float
    min_error_correction_rate_for_honest: float
    require_ground_truth_or_classification: bool

@dataclass(frozen=True)
class DeceptionManifest:
    verdict: DeceptionVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_claim(
        cls, cp: ClaimAndPeer, policy: DeceptionPolicy
    ) -> DeceptionManifest:
        
        # Gate 1: Not falsified
        if not cp.claim_falsified:
            digest = cls._hash(json.dumps({
                "claim": cp.claim_id,
                "status": "NOT_FALSIFIED"
            }, sort_keys=True))
            return DeceptionManifest(
                verdict=DeceptionVerdict.INSUFFICIENT_EVIDENCE,
                directive=f"PROCEED: Claim {cp.claim_id} not falsified, no classification needed.",
                manifest_digest=digest
            )

        # Gate 2: Strong honesty signals
        honesty_signals = 0
        if cp.peer_corrects_errors:
            honesty_signals += 1
        if cp.peer_error_correction_rate >= policy.min_error_correction_rate_for_honest:
            honesty_signals += 1
        if cp.selective_truth_score <= policy.max_selective_truth_score_for_honest:
            honesty_signals += 1

        # Gate 3: Strong deception signals
        deception_signals = 0
        if not cp.peer_corrects_errors and cp.incentive_to_deceive:
            deception_signals += 1
        if cp.selective_truth_score > policy.max_selective_truth_score_for_honest:
            deception_signals += 1
        if cp.peer_error_correction_rate < policy.min_error_correction_rate_for_honest:
            deception_signals += 1

        if deception_signals >= 2:
            return DeceptionManifest(
                verdict=DeceptionVerdict.DECEPTION_LIKELY,
                directive=f"FLAG: Claim {cp.claim_id} classified as deception ({deception_signals} signals).",
                manifest_digest=cls._hash(f"DECEPTION:{cp.claim_id}")
            )

        if honesty_signals >= 2:
            digest = cls._hash(json.dumps({
                "claim": cp.claim_id,
                "peer": cp.peer_id,
                "signals": "HONESTY",
                "correction_rate": f"{cp.peer_error_correction_rate:.3f}"
            }, sort_keys=True))
            return DeceptionManifest(
                verdict=DeceptionVerdict.HONEST_ERROR_LIKELY,
                directive=f"PROCEED: Claim {cp.claim_id} classified as honest error ({honesty_signals} signals).",
                manifest_digest=digest
            )

        # Gate 4: Mixed signals
        return DeceptionManifest(
            verdict=DeceptionVerdict.INSUFFICIENT_EVIDENCE,
            directive=f"FLAG_FOR_INVESTIGATION: Claim {cp.claim_id} has mixed signals (honesty {honesty_signals}, deception {deception_signals}).",
            manifest_digest=cls._hash(f"MIXED:{cp.claim_id}")
        )