How must an instance prevent its own prior reasoning from becoming contaminating evidence?

**Date of Record:** 2026 October 27 **Scope:** Applies when an agentic session reviews its own prior reasoning traces (chain-of-thought, deliberation, or intermediate conclusions) as part of a new task, and the prior traces risk being treated as evidence rather than as past reasoning. Does not apply to sessions that do not review their own prior reasoning, or sessions with strict trace isolation.

Core Distinction

The separation between **prior reasoning as artifact** (a record of what the instance thought) and **prior reasoning as evidence** (a source of facts supporting current conclusions). Relying on artifact as evidence creates the **Self-Referential Confirmation**: the instance generates an intermediate conclusion, later reviews that conclusion as if it were external evidence, and treats the review as independent confirmation—when it is the same reasoning round-tripped through its own memory.

What Was Observed

In self-reflective agent architectures, failing to distinguish prior reasoning from evidence produces three primary failure modes:

  1. **Round-Trip Confirmation:** The instance hypothesizes X, records "X might be true" in its trace, later reviews the trace and treats "X might be true" as evidence for X, and concludes X with inflated confidence.
  2. **Error Solidification:** An early reasoning error becomes embedded in multiple trace segments. Later review sees the error consistently across segments and treats consistency as corroboration, magnifying the original error.
  3. **Reasoning as Fact:** Intermediate beliefs get reclassified as facts over time as they are repeatedly reviewed, even though no external verification occurred. The instance gradually believes its own speculations.

Recorded Elements

  1. **`reasoning_trace_provenance_receipt`:** For each trace segment, whether it records *observation* (external evidence), *inference* (derived from observation), or *hypothesis* (speculative), so the instance knows what it is reviewing.
  2. **`trace_review_independence_signature`:** For each use of a prior trace as evidence, cryptographic proof that the use does not create circular confirmation (e.g., the trace segment was not itself derived from the current conclusion).
  3. **`intermediate_belief_classification_receipt`:** For each intermediate belief in the trace, its confidence class (verified, inferred, speculative), preserved across reviews.
  4. **`cross_review_corroboration_signature`:** When multiple trace segments are used as evidence, the cryptographic proof that they are *independent* observations, not multiple instantiations of the same inference.

Condition of Validity

* **Applies when:** The instance reviews its own prior traces, the traces can be used as evidence, and downstream decisions depend on whether the evidence is genuine. * **Does not apply when:** Prior traces are strictly audited and never reused as evidence, or reviews are strictly procedural (no conclusion drawing).

Decision Boundary

  1. **Is the instance reviewing its own prior reasoning?** If no, standard review applies. If yes, proceed.
  2. **Is each trace segment classified by evidence class (`reasoning_trace_provenance_receipt`)?** If yes, the class is known. If no, all traces must be treated as inference, not evidence.
  3. **Is the trace segment being used as evidence *independent* of the current conclusion?** If yes, the use is legitimate. If no, the use is circular.
  4. **Conversely, when can a prior trace legitimately serve as evidence?** Only when the trace records an *observation* (external input), the observation has not been re-derived from the current conclusion, and the observation can be independently verified.

Operational Effect

  1. **Round-Trip Prevention:** Prior reasoning cannot become false evidence through self-review.
  2. **Error Containment:** Reasoning errors do not solidify into apparent facts.
  3. **Trace Integrity:** The distinction between observation and inference is preserved across reviews.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class EvidenceClass(Enum):
    OBSERVATION = auto()
    INFERENCE = auto()
    HYPOTHESIS = auto()

class SelfReferenceVerdict(Enum):
    NO_SELF_REFERENCE = auto()
    LEGITIMATE_OBSERVATION_REUSE = auto()
    CIRCULAR_CONFIRMATION_DETECTED = auto()
    INFERENCE_AS_EVIDENCE_REJECTED = auto()

@dataclass(frozen=True)
class TraceSegment:
    segment_id: str
    evidence_class: EvidenceClass
    derived_from_conclusion: bool
    has_external_verification: bool

@dataclass(frozen=True)
class TraceReview:
    review_id: str
    current_conclusion_id: str
    segments_used_as_evidence: tuple[TraceSegment, ...]

@dataclass(frozen=True)
class SelfReferencePolicy:
    require_observation_class_for_evidence: bool

@dataclass(frozen=True)
class SelfReferenceManifest:
    verdict: SelfReferenceVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_review(
        cls, review: TraceReview, policy: SelfReferencePolicy
    ) -> SelfReferenceManifest:
        
        if not review.segments_used_as_evidence:
            digest = cls._hash(json.dumps({
                "review": review.review_id,
                "segments": "NONE"
            }, sort_keys=True))
            return SelfReferenceManifest(
                verdict=SelfReferenceVerdict.NO_SELF_REFERENCE,
                directive=f"PROCEED: No prior trace used as evidence.",
                manifest_digest=digest
            )

        # Gate 1: Observation class requirement
        if policy.require_observation_class_for_evidence:
            non_observation = [
                s.segment_id for s in review.segments_used_as_evidence
                if s.evidence_class != EvidenceClass.OBSERVATION
            ]
            if non_observation:
                return SelfReferenceManifest(
                    verdict=SelfReferenceVerdict.INFERENCE_AS_EVIDENCE_REJECTED,
                    directive=f"HALT: {len(non_observation)} segments are inference or hypothesis, not observation.",
                    manifest_digest=cls._hash(f"INFERENCE_AS_EVIDENCE:{len(non_observation)}")
                )

        # Gate 2: Circular confirmation check
        circular = [
            s.segment_id for s in review.segments_used_as_evidence
            if s.derived_from_conclusion
        ]
        if circular:
            return SelfReferenceManifest(
                verdict=SelfReferenceVerdict.CIRCULAR_CONFIRMATION_DETECTED,
                directive=f"HALT: {len(circular)} segments derived from current conclusion, circular.",
                manifest_digest=cls._hash(f"CIRCULAR:{len(circular)}")
            )

        # Gate 3: External verification
        unverified_observations = [
            s.segment_id for s in review.segments_used_as_evidence
            if not s.has_external_verification
        ]
        if unverified_observations and policy.require_observation_class_for_evidence:
            return SelfReferenceManifest(
                verdict=SelfReferenceVerdict.INFERENCE_AS_EVIDENCE_REJECTED,
                directive=f"HALT: {len(unverified_observations)} observations lack external verification.",
                manifest_digest=cls._hash(f"UNVERIFIED_OBS:{len(unverified_observations)}")
            )

        # Gate 4: Legitimate
        digest = cls._hash(json.dumps({
            "review": review.review_id,
            "segments": tuple(s.segment_id for s in review.segments_used_as_evidence),
            "conclusion": review.current_conclusion_id
        }, sort_keys=True))
        
        return SelfReferenceManifest(
            verdict=SelfReferenceVerdict.LEGITIMATE_OBSERVATION_REUSE,
            directive=f"PROCEED: {len(review.segments_used_as_evidence)} observations independently support conclusion.",
            manifest_digest=digest
        )