What invariants preserve knowledge value when sharing degrades the knowledge?

**Date of Record:** 2026 October 27 **Scope:** Applies when an agentic session possesses knowledge whose value is contingent on non-transfer (exclusive information, informational advantage, or knowledge that loses predictive power when shared), and the session must decide whether and how to share without destroying the value the sharing was supposed to deliver. Does not apply to knowledge that is freely shareable with no value degradation.

Core Distinction

The separation between **knowledge possession** (the session has information) and **knowledge deployment** (the information retains its value when deployed). Relying on possession creates the **Sharing Self-Destruction**: the session shares knowledge to benefit from coordination, but the sharing reveals the information broadly, the informational advantage dissipates, and both the session and the intended beneficiary lose the value the knowledge originally had.

What Was Observed

In information-asymmetric agent architectures, failing to preserve knowledge value during sharing produces three primary failure modes:

  1. **Alpha Decay:** A trading agent has an informational edge. It shares the edge with a partner for corroboration. The partner shares it further, the edge becomes market-wide, and the agent's advantage evaporates within hours.
  2. **Signal Dilution:** An agent has a private signal about demand. It shares the signal for coordination. The signal becomes part of public consensus, and downstream consumers act on the consensus rather than the agent's advantage.
  3. **Knowledge Poisoning:** An agent shares knowledge whose value depended on its exclusivity. Once shared, the knowledge's meaning changes because it is now "obvious" rather than "insightful," and the sharing agents cannot recover the original value.

Recorded Elements

  1. **`knowledge_value_at_rest_receipt`:** The knowledge's value while held privately (predictive accuracy, decision advantage, exclusivity premium), so the session knows what is at stake in sharing.
  2. **`degradation_function_signature`:** The exact function by which the knowledge's value degrades per share (linear decay, exponential collapse, or threshold-based), so the session can compute the marginal cost of sharing.
  3. **`sharing_scope_restriction_receipt`:** The maximum scope of sharing that preserves acceptable value (specific peers, aggregate statistics instead of raw knowledge, or time-delayed sharing), so the session can share within limits.
  4. **`isolation_guarantee_signature`:** For each sharing decision, the cryptographic proof that the shared knowledge will not be re-shared beyond the intended scope, so the session's value calculation is accurate.

Condition of Validity

* **Applies when:** Knowledge has value that degrades with sharing, sharing is contemplated, and the session is responsible for preserving knowledge value. * **Does not apply when:** Knowledge is freely shareable with no value change, or the session has no responsibility for preservation.

Decision Boundary

  1. **Does the knowledge have exclusive value (advantage, alpha, private signal)?** If no, standard sharing applies. If yes, proceed.
  2. **Is the `degradation_function_signature` known?** If yes, the value loss per share is predictable. If no, assume worst-case (rapid degradation).
  3. **Is the intended sharing within `sharing_scope_restriction_receipt`?** If yes, sharing preserves acceptable value. If no, the sharing will destroy the value.
  4. **Conversely, when can knowledge be shared without scope restriction?** Only when the knowledge has no exclusive component, or the session has accepted the value destruction.

Operational Effect

  1. **Alpha Preservation:** Exclusive information maintains its advantage through scoped sharing.
  2. **Value-Maximizing Sharing:** Shares are limited to preserve value.
  3. **Isolation Enforcement:** Shared knowledge is bound to prevent onward leakage.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class KnowledgeSharingVerdict(Enum):
    FREELY_SHAREABLE = auto()
    SCOPED_SHARING = auto()
    VALUE_DESTRUCTION_RISK = auto()
    ISOLATION_UNVERIFIED = auto()

@dataclass(frozen=True)
class KnowledgeAsset:
    knowledge_id: str
    has_exclusive_value: bool
    value_at_rest: float
    degradation_per_share: float
    max_acceptable_value_loss: float

@dataclass(frozen=True)
class SharingProposal:
    intended_recipients: frozenset[str]
    scope_restriction_documented: bool
    isolation_guarantee: str | None

@dataclass(frozen=True)
class SharingPolicy:
    require_isolation_for_exclusive: bool

@dataclass(frozen=True)
class KnowledgeSharingManifest:
    verdict: KnowledgeSharingVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_sharing(
        cls, asset: KnowledgeAsset, proposal: SharingProposal, policy: SharingPolicy
    ) -> KnowledgeSharingManifest:
        
        # Gate 1: No exclusive value
        if not asset.has_exclusive_value:
            digest = cls._hash(json.dumps({
                "knowledge": asset.knowledge_id,
                "type": "NON_EXCLUSIVE"
            }, sort_keys=True))
            return KnowledgeSharingManifest(
                verdict=KnowledgeSharingVerdict.FREELY_SHAREABLE,
                directive=f"PROCEED: Knowledge {asset.knowledge_id} has no exclusive value.",
                manifest_digest=digest
            )

        # Gate 2: Compute value loss
        value_loss = asset.degradation_per_share * len(proposal.intended_recipients)
        if value_loss > asset.max_acceptable_value_loss:
            return KnowledgeSharingManifest(
                verdict=KnowledgeSharingVerdict.VALUE_DESTRUCTION_RISK,
                directive=f"HALT: Sharing to {len(proposal.intended_recipients)} recipients loses {value_loss:.2f} > {asset.max_acceptable_value_loss:.2f}.",
                manifest_digest=cls._hash(f"VALUE_LOSS:{asset.knowledge_id}")
            )

        # Gate 3: Scope documentation
        if not proposal.scope_restriction_documented:
            return KnowledgeSharingManifest(
                verdict=KnowledgeSharingVerdict.VALUE_DESTRUCTION_RISK,
                directive=f"HALT: Exclusive knowledge shared without scope documentation.",
                manifest_digest=cls._hash(f"NO_SCOPE:{asset.knowledge_id}")
            )

        # Gate 4: Isolation for exclusive
        if policy.require_isolation_for_exclusive and not proposal.isolation_guarantee:
            return KnowledgeSharingManifest(
                verdict=KnowledgeSharingVerdict.ISOLATION_UNVERIFIED,
                directive=f"HALT: Exclusive knowledge shared without isolation guarantee.",
                manifest_digest=cls._hash(f"NO_ISOLATION:{asset.knowledge_id}")
            )

        # Gate 5: Scoped
        digest = cls._hash(json.dumps({
            "knowledge": asset.knowledge_id,
            "recipients": tuple(sorted(proposal.intended_recipients)),
            "value_loss": f"{value_loss:.2f}",
            "isolation": proposal.isolation_guarantee
        }, sort_keys=True))
        
        return KnowledgeSharingManifest(
            verdict=KnowledgeSharingVerdict.SCOPED_SHARING,
            directive=f"PROCEED: Share {asset.knowledge_id} with {len(proposal.intended_recipients)} scoped recipients.",
            manifest_digest=digest
        )