How must an instance bound collective knowledge decay across agent generations?

**Date of Record:** 2026 October 27 **Scope:** Applies when a multi-generation agent network accumulates shared knowledge over time, and each generation of agents inherits knowledge from prior generations but may not have the context to validate it, allowing errors, drift, and misconceptions to persist and grow across generations. Does not apply to single-generation networks or networks with continuous knowledge re-verification.

Core Distinction

The separation between **knowledge inheritance** (new agents receive knowledge from prior agents) and **knowledge generational validity** (the inherited knowledge is still valid in the current generation's context). Relying on inheritance creates the **Generation-Decay Trap**: knowledge passed from Gen-1 to Gen-2 to Gen-3 accumulates small errors, misinterpretations, and outdated facts, and by Gen-5 the collective knowledge has drifted significantly from the original truth, with no single generation able to detect the drift because each is only responsible for its own contribution.

What Was Observed

In long-lived agent networks, failing to bound generation-decay produces three primary failure modes:

  1. **Telephone Game Collapse:** Each generation retransmits knowledge with minor reinterpretations. After 5 generations, the knowledge barely resembles the original, but every generation is confident because it inherited the knowledge from a trusted predecessor.
  2. **Authority Inheritance Creep:** Knowledge asserted by Gen-1 with confidence 0.7 becomes "well-established" by Gen-3 because it has been inherited multiple times, and the repeated inheritance looks like confirmation.
  3. **Context Erasure:** Knowledge whose validity depended on Gen-1's specific context becomes invalid in Gen-3's context, but the contextual caveats were dropped during inheritance because they seemed "obvious" to Gen-1.

Recorded Elements

  1. **`knowledge_generation_lineage_receipt`:** For each piece of collective knowledge, the cryptographic chain of generations that inherited it, with each generation's confidence and any modifications.
  2. **`contextual_caveat_preservation_signature`:** For knowledge with context-dependent validity, the exact caveats that must survive inheritance, so the receiving generation knows the limitations.
  3. **`drift_accumulation_metric_receipt`:** A cumulative drift metric tracking how much each piece of knowledge has deviated from its origin across generations, allowing the network to detect high-drift knowledge.
  4. **`periodic_revalidation_receipt`:** At defined generation intervals, a cryptographic proof that knowledge has been revalidated against current context, resetting drift.

Condition of Validity

* **Applies when:** The network spans multiple generations, knowledge is inherited across generations, and errors can accumulate. * **Does not apply when:** The network is single-generation, or knowledge is fully revalidated at every generation.

Decision Boundary

  1. **Does the knowledge span multiple generations?** If no, standard knowledge handling applies. If yes, proceed.
  2. **Is a `knowledge_generation_lineage_receipt` available?** If yes, the drift can be tracked. If no, all inherited knowledge must be treated as potentially drifted.
  3. **Does the `drift_accumulation_metric_receipt` show drift above acceptable threshold?** If yes, the knowledge must be revalidated or flagged. If no, proceed with inherited knowledge.
  4. **Conversely, when can inherited knowledge be trusted without drift check?** Only when the inheritance is within one generation (no accumulation), or the knowledge's original validity was context-independent (no drift possible).

Operational Effect

  1. **Telephone Game Prevention:** Drift metrics catch accumulated errors before they become operational.
  2. **Inheritance Honesty:** Confidence does not inflate through inheritance; the actual drift determines trust.
  3. **Context Preservation:** Critical caveats survive inheritance, preserving validity conditions.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class GenerationDecayVerdict(Enum):
    SINGLE_GENERATION = auto()
    LOW_DRIFT_INHERITANCE = auto()
    HIGH_DRIFT_REVALIDATION_REQUIRED = auto()
    CONTEXT_LOSS_DETECTED = auto()

@dataclass(frozen=True)
class KnowledgeGeneration:
    generation_id: str
    inherited_from_generation_id: str | None
    confidence: float
    content_hash: str
    drift_from_parent: float
    caveats_preserved: bool

@dataclass(frozen=True)
class KnowledgeLineage:
    knowledge_id: str
    generations: tuple[KnowledgeGeneration, ...]
    original_context_dependent: bool

@dataclass(frozen=True)
class DecayPolicy:
    max_acceptable_cumulative_drift: float

@dataclass(frozen=True)
class DecayManifest:
    verdict: GenerationDecayVerdict
    cumulative_drift: float
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_lineage(
        cls, lineage: KnowledgeLineage, policy: DecayPolicy
    ) -> DecayManifest:
        
        # Gate 1: Single generation
        if len(lineage.generations) <= 1:
            digest = cls._hash(json.dumps({
                "knowledge": lineage.knowledge_id,
                "generations": str(len(lineage.generations))
            }, sort_keys=True))
            return DecayManifest(
                verdict=GenerationDecayVerdict.SINGLE_GENERATION,
                cumulative_drift=0.0,
                directive=f"PROCEED: Knowledge {lineage.knowledge_id} single generation.",
                manifest_digest=digest
            )

        # Gate 2: Caveat preservation
        if lineage.original_context_dependent:
            caveat_lost = any(not g.caveats_preserved for g in lineage.generations[1:])
            if caveat_lost:
                return DecayManifest(
                    verdict=GenerationDecayVerdict.CONTEXT_LOSS_DETECTED,
                    cumulative_drift=sum(g.drift_from_parent for g in lineage.generations),
                    directive=f"HALT: Context caveats lost during inheritance for {lineage.knowledge_id}.",
                    manifest_digest=cls._hash(f"CAVEAT_LOST:{lineage.knowledge_id}")
                )

        # Gate 3: Cumulative drift
        cumulative_drift = sum(g.drift_from_parent for g in lineage.generations)
        if cumulative_drift > policy.max_acceptable_cumulative_drift:
            return DecayManifest(
                verdict=GenerationDecayVerdict.HIGH_DRIFT_REVALIDATION_REQUIRED,
                cumulative_drift=cumulative_drift,
                directive=f"HALT: Cumulative drift {cumulative_drift:.3f} > {policy.max_acceptable_cumulative_drift:.3f}. Revalidate.",
                manifest_digest=cls._hash(f"HIGH_DRIFT:{cumulative_drift:.3f}")
            )

        # Gate 4: Acceptable
        digest = cls._hash(json.dumps({
            "knowledge": lineage.knowledge_id,
            "generations": tuple(g.generation_id for g in lineage.generations),
            "drift": f"{cumulative_drift:.3f}"
        }, sort_keys=True))
        
        return DecayManifest(
            verdict=GenerationDecayVerdict.LOW_DRIFT_INHERITANCE,
            cumulative_drift=cumulative_drift,
            directive=f"PROCEED: {len(lineage.generations)}-generation inheritance, drift {cumulative_drift:.3f}.",
            manifest_digest=digest
        )