How must an instance handle evidence that cannot be transferred to other agents?

**Date of Record:** 2026 October 27 **Scope:** Applies when an agentic session possesses evidence (observations, certifications, or proofs) that supports a claim, but the evidence cannot be transferred to peers (due to privacy, size, format, or non-transferable nature), requiring the session to communicate the claim without the supporting evidence. Does not apply to evidence that is transferable or claims that do not require evidence support.

Core Distinction

The separation between **evidence possession** (the session has proof) and **evidence communicability** (the session can share the proof with peers). Relying on possession creates the **Non-Transferable Trust Gap**: the session has strong evidence but cannot share it, so peers must either trust the session's assertion without proof (vulnerable to the session being wrong or malicious) or reject the claim (losing the value of the evidence).

What Was Observed

In evidence-asymmetric agent architectures, failing to handle non-transferable evidence produces three primary failure modes:

  1. **Blind Trust Request:** The session says "I have evidence that X is true" and expects peers to trust it. The peers cannot distinguish this from bluffing.
  2. **Claim Rejection:** The peers, unable to verify the evidence, reject the claim. The session's genuine evidence is wasted.
  3. **Evidence Abuse:** A malicious session claims to have evidence it does not have, peers who cannot verify it accept the claim, and later the claim is found false.

Recorded Elements

  1. **`evidence_transferability_class_receipt`:** For each piece of evidence, the reason it cannot be transferred (`PRIVACY`, `SIZE`, `FORMAT`, `LOCAL_ONLY`), so the session can communicate the nature of the limitation.
  2. **`transferable_derivative_receipt`:** For non-transferable evidence, any transferable derivative (summary, hash, or zero-knowledge proof) that supports the claim without revealing the evidence.
  3. **`evidence_derivation_path_signature`:** The cryptographic proof that the session's claim derives from its evidence via a specific process (verification, transformation, or aggregation), so peers can verify the derivation without the evidence itself.
  4. **`evidence_trust_chain_receipt`:** For cases where peers must trust the session's evidence-having status, the trust chain showing why the session should be trusted about its evidence.

Condition of Validity

* **Applies when:** The session has evidence supporting a claim, the evidence cannot be transferred, and peers must decide whether to accept the claim. * **Does not apply when:** Evidence is transferable, claims do not require evidence support, or peers do not need the claim.

Decision Boundary

  1. **Is the evidence transferable to peers?** If yes, transfer it. If no, proceed.
  2. **Is a `transferable_derivative_receipt` available (hash, summary, ZK proof)?** If yes, share the derivative. If no, evidence remains non-transferable.
  3. **Is the `evidence_derivation_path_signature` verifiable by peers?** If yes, peers can trust the derivation even without the evidence. If no, only the session's assertion supports the claim.
  4. **Conversely, when must peers accept the claim without any derivative?** Only when the session's trust chain is verified by peers, or the claim is low-stakes and assertion is acceptable.

Operational Effect

  1. **Blind Trust Reduction:** Transferable derivatives substitute for full evidence.
  2. **Claim Preservation:** Non-transferable evidence can still support claims via derivation proofs.
  3. **Evidence Abuse Detection:** Malicious claims of evidence are distinguishable from honest ones.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class EvidenceVerdict(Enum):
    EVIDENCE_TRANSFERABLE = auto()
    DERIVATIVE_SUFFICIENT = auto()
    TRUST_CHAIN_REQUIRED = auto()
    ASSERTION_ONLY = auto()

@dataclass(frozen=True)
class Evidence:
    evidence_id: str
    transferability_class: str  # "TRANSFERABLE" | "PRIVACY" | "SIZE" | "LOCAL_ONLY"
    derivative_hash: str | None
    derivation_path_signature: str | None
    trust_chain_receipt: str | None

@dataclass(frozen=True)
class ClaimForPeer:
    claim_id: str
    peer_requires_evidence: bool
    claim_stakes: str  # "LOW" | "MEDIUM" | "HIGH"

@dataclass(frozen=True)
class TransferPolicy:
    require_derivative_for_medium_plus: bool
    require_trust_chain_for_high: bool

@dataclass(frozen=True)
class EvidenceManifest:
    verdict: EvidenceVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_transfer(
        cls, evidence: Evidence, claim: ClaimForPeer, policy: TransferPolicy
    ) -> EvidenceManifest:
        
        # Gate 1: Transferable evidence
        if evidence.transferability_class == "TRANSFERABLE":
            digest = cls._hash(json.dumps({
                "evidence": evidence.evidence_id,
                "claim": claim.claim_id,
                "transfer": "DIRECT"
            }, sort_keys=True))
            return EvidenceManifest(
                verdict=EvidenceVerdict.EVIDENCE_TRANSFERABLE,
                directive=f"PROCEED: Transfer evidence {evidence.evidence_id} directly.",
                manifest_digest=digest
            )

        # Gate 2: Derivative available
        if evidence.derivative_hash:
            if claim.stakes in ("MEDIUM", "HIGH"):
                if policy.require_derivative_for_medium_plus:
                    digest = cls._hash(json.dumps({
                        "evidence": evidence.evidence_id,
                        "claim": claim.claim_id,
                        "derivative": evidence.derivative_hash,
                        "stakes": claim.stakes
                    }, sort_keys=True))
                    return EvidenceManifest(
                        verdict=EvidenceVerdict.DERIVATIVE_SUFFICIENT,
                        directive=f"PROCEED: Share derivative {evidence.derivative_hash} for {claim.stakes}-stakes claim.",
                        manifest_digest=digest
                    )

        # Gate 3: High stakes requires trust chain
        if claim.stakes == "HIGH" and policy.require_trust_chain_for_high:
            if evidence.trust_chain_receipt and evidence.derivation_path_signature:
                digest = cls._hash(json.dumps({
                    "evidence": evidence.evidence_id,
                    "claim": claim.claim_id,
                    "trust_chain": evidence.trust_chain_receipt,
                    "derivation": evidence.derivation_path_signature
                }, sort_keys=True))
                return EvidenceManifest(
                    verdict=EvidenceVerdict.TRUST_CHAIN_REQUIRED,
                    directive=f"PROCEED: High-stakes claim with trust chain and derivation proof.",
                    manifest_digest=digest
                )
            return EvidenceManifest(
                verdict=EvidenceVerdict.ASSERTION_ONLY,
                directive=f"HALT: High-stakes claim lacks trust chain and derivation proof.",
                manifest_digest=cls._hash(f"NO_TRUST_CHAIN:{claim.claim_id}")
            )

        # Gate 4: Assertion only
        return EvidenceManifest(
            verdict=EvidenceVerdict.ASSERTION_ONLY,
            directive=f"WARN: Evidence {evidence.evidence_id} non-transferable, claim is assertion only.",
            manifest_digest=cls._hash(f"ASSERTION:{claim.claim_id}")
        )