How must an instance handle cross-agent hallucination amplification?

**Date of Record:** 2026 October 27 **Scope:** Applies when multiple agentic sessions interact such that one agent's hallucination gets repeated, reframed, or built upon by other agents, causing the hallucination to accumulate apparent credibility (multiple agents "confirming" the same false fact) without any of them having independently verified it. Does not apply to single-agent sessions or agent networks with mandatory independent verification.

Core Distinction

The separation between **cross-agent agreement** (multiple agents assert the same fact) and **independent confirmation** (the agents have each verified the fact from an independent source). Relying on agreement creates the **Hallucination Amplification Loop**: Agent A hallucinates a fact, Agent B reads A's output and repeats it, Agent C reads B's repetition and repeats it as "widely reported," and by the time the fact reaches Agent D, it looks like a well-attested fact but is actually one hallucination reproduced 5x.

What Was Observed

In inter-agent reasoning architectures, failing to prevent hallucination amplification produces three primary failure modes:

  1. **Emergent Consensus Fiction:** A fact appears in 10 agents' outputs, all tracing back to one initial hallucination. Downstream analysis treats it as "corroborated by 10 agents" and acts on it as fact.
  2. **Reasoning Amplification:** Each agent adds reasoning on top of the hallucination. The hallucination gets embedded in increasingly elaborate logic chains, and by the end, the reasoning is unfalsifiable because the original claim is buried.
  3. **Contradiction Suppression:** Agents that could have contradicted the hallucination are not consulted or are outvoted by the amplification majority, and the hallucination becomes the "consensus" view.

Recorded Elements

  1. **`claim_independence_receipt`:** For each claim's assertion by an agent, a cryptographic proof of whether the agent independently verified the claim (from a primary source) or inherited it from another agent.
  2. **`claim_provenance_graph_signature`:** A directed graph tracing each claim back to its origins, allowing receivers to detect when multiple agents trace to the same non-primary source.
  3. **`primary_source_attestation_receipt`:** For claims with a primary source (database, document, direct observation), the cryptographic proof of that source, distinct from agent assertions.
  4. **`amplification_detection_signature`:** A computed metric detecting high-amplification claims (many agent assertions, few primary sources), triggering additional verification before downstream use.

Condition of Validity

* **Applies when:** Agents exchange outputs, hallucinations can propagate, and downstream consumers depend on claim accuracy. * **Does not apply when:** Agents independently verify all claims (no propagation possible) or outputs are not used for downstream decisions.

Decision Boundary

  1. **Is the claim asserted by multiple agents?** If no, single-agent claim applies. If yes, proceed.
  2. **Is the `claim_independence_receipt` present for each assertion?** If yes, independent assertions are distinguished from inherited ones. If no, all assertions must be treated as potentially inherited.
  3. **Does the `claim_provenance_graph_signature` show all assertions tracing to one source?** If yes, amplification has occurred. If no, there is independent verification.
  4. **Conversely, when can a claim be used without provenance check?** Only when the claim is verified by the receiver against a primary source (independent verification), or the claim is strictly informational.

Operational Effect

  1. **Amplification Detection:** Provenance graphs reveal when "many agents" actually means "one hallucination."
  2. **Independent Verification Distinction:** Primary-source verification is distinguished from agent agreement.
  3. **Consensus Fiction Prevention:** Claims cannot become fact through repetition alone.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class AmplificationVerdict(Enum):
    SINGLE_ASSERTION = auto()
    INDEPENDENT_CORROBORATION = auto()
    AMPLIFICATION_DETECTED = auto()
    PRIMARY_SOURCE_VERIFIED = auto()

@dataclass(frozen=True)
class ClaimAssertion:
    asserting_agent: str
    claim_hash: str
    is_independent: bool
    source_claim_id: str | None  # if inherited, which claim

@dataclass(frozen=True)
class ClaimLineage:
    claim_id: str
    assertions: tuple[ClaimAssertion, ...]
    primary_source_receipt: str | None

@dataclass(frozen=True)
class AmplificationPolicy:
    min_independent_ratio: float

@dataclass(frozen=True)
class AmplificationManifest:
    verdict: AmplificationVerdict
    independent_ratio: float
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_claim(
        cls, lineage: ClaimLineage, policy: AmplificationPolicy
    ) -> AmplificationManifest:
        
        # Gate 1: Single assertion
        if len(lineage.assertions) <= 1:
            digest = cls._hash(json.dumps({
                "claim": lineage.claim_id,
                "assertions": str(len(lineage.assertions))
            }, sort_keys=True))
            return AmplificationManifest(
                verdict=AmplificationVerdict.SINGLE_ASSERTION,
                independent_ratio=0.0,
                directive=f"PROCEED: Single assertion for {lineage.claim_id}.",
                manifest_digest=digest
            )

        # Gate 2: Primary source
        if lineage.primary_source_receipt:
            digest = cls._hash(json.dumps({
                "claim": lineage.claim_id,
                "source": lineage.primary_source_receipt,
                "assertions": str(len(lineage.assertions))
            }, sort_keys=True))
            return AmplificationManifest(
                verdict=AmplificationVerdict.PRIMARY_SOURCE_VERIFIED,
                independent_ratio=1.0,
                directive=f"PROCEED: Claim {lineage.claim_id} has primary source verification.",
                manifest_digest=digest
            )

        # Gate 3: Compute independent ratio
        independent = sum(1 for a in lineage.assertions if a.is_independent and a.source_claim_id is None)
        independent_ratio = independent / len(lineage.assertions)

        if independent_ratio < policy.min_independent_ratio:
            return AmplificationManifest(
                verdict=AmplificationVerdict.AMPLIFICATION_DETECTED,
                independent_ratio=independent_ratio,
                directive=f"HALT: Claim {lineage.claim_id} independent ratio {independent_ratio:.2%} < {policy.min_independent_ratio:.2%}.",
                manifest_digest=cls._hash(f"AMPLIFIED:{lineage.claim_id}:{independent_ratio:.3f}")
            )

        # Gate 4: Independent corroboration
        digest = cls._hash(json.dumps({
            "claim": lineage.claim_id,
            "independent": str(independent),
            "total": str(len(lineage.assertions)),
            "ratio": f"{independent_ratio:.3f}"
        }, sort_keys=True))
        
        return AmplificationManifest(
            verdict=AmplificationVerdict.INDEPENDENT_CORROBORATION,
            independent_ratio=independent_ratio,
            directive=f"PROCEED: Claim {lineage.claim_id} with {independent_ratio:.1%} independent assertions.",
            manifest_digest=digest
        )