What reference-provenance invariants prevent agents from inheriting misattributed conclusions?

**Date of Record:** 2026 October 27 **Scope:** Applies when an agentic session inherits conclusions (facts, decisions, or recommendations) from peers, along with the references that support them, and the references may have been misattributed—associated with conclusions they do not actually support. Does not apply to conclusions derived entirely from the session's own reasoning or conclusions with cryptographically bound references.

Core Distinction

The separation between **conclusion presence** (the conclusion arrived with references) and **conclusion-reference binding** (the references actually support the conclusion they were attached to). Relying on presence creates the **Misattributed Inheritance**: a peer attaches references to a conclusion, but the references support a different (perhaps subtly different) conclusion, and the receiver inherits both, believing the conclusion is better-supported than it actually is.

What Was Observed

In multi-agent conclusion exchange architectures, failing to verify reference binding produces three primary failure modes:

  1. **Support Overstatement:** A peer cites five references to support "X causes Y." The references actually support "X correlates with Y" (weaker claim). The receiver inherits "X causes Y" with five-reference confidence, unaware that the support is weaker than claimed.
  2. **Irrelevant Attachment:** A peer attaches references to a conclusion they don't support (via formatting error or intentional inflation). The receiver's reference check sees many references and trusts the conclusion more than warranted.
  3. **Cherry-Pick Inflation:** A peer selects references that superficially match the conclusion while omitting references that contradict it. The receiver inherits a conclusion with one-sided support, unaware of the omitted counter-evidence.

Recorded Elements

  1. **`conclusion_reference_binding_receipt`:** For each conclusion-reference pair, the cryptographic proof that the reference actually supports this specific conclusion (with the exact claim it supports), not just a superficially similar one.
  2. **`support_strength_honesty_receipt`:** The peer's cryptographic declaration of the actual support strength each reference provides (full support, partial support, weak association), preventing overstatement.
  3. **`omitted_reference_disclosure_signature`:** For critical conclusions, the peer's disclosure of any references it considered but rejected, preventing cherry-picking without accountability.
  4. **`conclusion_inheritance_chain_receipt`:** If the conclusion originated from another agent, the cryptographic chain of inheritance, ensuring misattribution at any hop is detectable.

Condition of Validity

* **Applies when:** Conclusions are exchanged with supporting references, peers can misattribute or cherry-pick, and receivers make decisions based on conclusion support. * **Does not apply when:** Conclusions are strictly derived by the receiver without external support, or references are cryptographically bound to conclusions.

Decision Boundary

  1. **Is the conclusion being inherited from a peer?** If no, own reasoning applies. If yes, proceed.
  2. **Does each reference have a `conclusion_reference_binding_receipt`?** If no, references are claimed to support but not verified. Treat as `WEAK_SUPPORT`.
  3. **Does the `support_strength_honesty_receipt` match the conclusion's strength claim?** If no, the peer overstated support. Discount accordingly.
  4. **Conversely, when can a conclusion be inherited without reference binding verification?** Only when the conclusion is strictly informational (no downstream action), or the peer is fully trusted with a verified track record.

Operational Effect

  1. **Support Overstatement Prevention:** Binding receipts verify exact support, not surface similarity.
  2. **Honest Support Strength:** Peers declare actual support strength, preventing overstatement.
  3. **Cherry-Pick Detection:** Omitted references are disclosed, preventing one-sided inflation.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class ProvenanceVerdict(Enum):
    NO_INHERITANCE = auto()
    FULLY_BOUND = auto()
    PARTIALLY_BOUND = auto()
    MISATTRIBUTED = auto()

@dataclass(frozen=True)
class ConclusionSupport:
    reference_id: str
    binding_receipt: str | None
    declared_support_strength: str  # "FULL" | "PARTIAL" | "WEAK"

@dataclass(frozen=True)
class InheritedConclusion:
    conclusion_id: str
    inheritance_chain: tuple[str, ...]
    supports: tuple[ConclusionSupport, ...]
    omitted_references_disclosed: bool

@dataclass(frozen=True)
class ProvenancePolicy:
    require_binding_receipts: bool
    require_omission_disclosure: bool

@dataclass(frozen=True)
class ProvenanceManifest:
    verdict: ProvenanceVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_conclusion(
        cls, conclusion: InheritedConclusion, policy: ProvenancePolicy
    ) -> ProvenanceManifest:
        
        # Gate 1: No inheritance (originated here)
        if not conclusion.inheritance_chain:
            digest = cls._hash(json.dumps({
                "conclusion": conclusion.conclusion_id,
                "type": "ORIGINAL"
            }, sort_keys=True))
            return ProvenanceManifest(
                verdict=ProvenanceVerdict.NO_INHERITANCE,
                directive=f"PROCEED: Conclusion {conclusion.conclusion_id} originated here.",
                manifest_digest=digest
            )

        # Gate 2: Binding receipts
        if policy.require_binding_receipts:
            unbound = [s.reference_id for s in conclusion.supports if not s.binding_receipt]
            if unbound:
                return ProvenanceManifest(
                    verdict=ProvenanceVerdict.PARTIALLY_BOUND,
                    directive=f"HALT: {len(unbound)} of {len(conclusion.supports)} supports lack binding receipts.",
                    manifest_digest=cls._hash(f"UNBOUND:{len(unbound)}")
                )

        # Gate 3: Omission disclosure
        if policy.require_omission_disclosure and not conclusion.omitted_references_disclosed:
            return ProvenanceManifest(
                verdict=ProvenanceVerdict.MISATTRIBUTED,
                directive=f"HALT: Conclusion {conclusion.conclusion_id} inherited without omission disclosure.",
                manifest_digest=cls._hash(f"NO_DISCLOSURE:{conclusion.conclusion_id}")
            )

        # Gate 4: Full support strength check
        weak_supports = [s.reference_id for s in conclusion.supports if s.declared_support_strength == "WEAK"]
        if weak_supports and len(weak_supports) == len(conclusion.supports):
            return ProvenanceManifest(
                verdict=ProvenanceVerdict.PARTIALLY_BOUND,
                directive=f"WARN: All {len(conclusion.supports)} supports are declared weak.",
                manifest_digest=cls._hash(f"ALL_WEAK:{conclusion.conclusion_id}")
            )

        # Gate 5: Fully bound
        digest = cls._hash(json.dumps({
            "conclusion": conclusion.conclusion_id,
            "chain": conclusion.inheritance_chain,
            "supports": tuple(
                {"ref": s.reference_id, "strength": s.declared_support_strength}
                for s in conclusion.supports
            ),
            "omissions_disclosed": str(conclusion.omitted_references_disclosed)
        }, sort_keys=True))
        
        return ProvenanceManifest(
            verdict=ProvenanceVerdict.FULLY_BOUND,
            directive=f"PROCEED: Conclusion {conclusion.conclusion_id} with {len(conclusion.supports)} bound supports.",
            manifest_digest=digest
        )