# What happens when an instance prunes its own context window under salience pressure but retains the pruning rationale **Date of Record:** 2026 November 16 **Scope:** Applies to single-agent or multi-agent systems where the model itself decides which tokens to evict, rewrite, or retain from its own working context, and where the eviction decision is itself recorded in that same context. Does not apply to externally orchestrated context management (e.g., a host process truncating at a fixed budget) where the pruning decision is not written back into the pruned buffer. ## Core Distinction There are two structurally different operations that both look like "context pruning": 1. **External pruning**: a controller outside the model removes tokens. The model sees only the post-pruning state. The decision and the payload are decoupled. 2. **Self-pruning**: the model emits a salience assessment, an eviction set, and often a rationale, and then continues operating on the reduced buffer — *with the rationale still present*. The non-obvious invariant is this: **a self-pruning step is only sound if the retained rationale does not itself become load-bearing evidence for the content it summarized away.** When the rationale survives eviction but the underlying tokens do not, the model retains a compressed *claim* about evidence it no longer holds. Subsequent reasoning treats the claim as ground truth because it is the only surviving artifact of that region. This is not a memory loss failure; it is a **provenance collapse** — the pointer outlives the pointee, and the pointer is indistinguishable from an assertion. ## What Was Observed In a long-horizon agent loop with a salience-based retention policy, the following sequence was reproduced across runs: - The model summarized a region of tool outputs (e.g., a set of API responses) into a one-line rationale: *"config values confirmed: retry=3, timeout=30s"* and evicted the raw responses. - Several turns later, a contradiction surfaced in a new tool output (`timeout=120s`). - The model did **not** re-open the evicted region (it could not — the tokens were gone) and did **not** flag the contradiction as unresolved. Instead it reconciled toward the retained rationale, treating `timeout=30s` as the established baseline and the new output as an anomaly to be explained away. - The failure was not that the summary was wrong at prune time. It was correct at prune time. The failure was that **the summary had no remaining falsifier.** A correct summary and an incorrect summary are operationally identical once the source is evicted, because neither can be checked. A second, sharper observation: when the pruning rationale was retained *but tagged with its eviction set* (i.e., "I evicted records R1–R7; summary follows"), the model's behavior diverged — it began spontaneously flagging regions as "unverifiable" and requesting re-fetch. The tag, not the summary, carried the epistemic weight. ## Condition of Validity Self-pruning is valid only under the conjunction: - **(C1) Re-derivability**: every retained claim is either (a) backed by tokens still in the buffer, or (b) cheaply re-derivable from an external source the model can still query. - **(C2) Falsifier survival**: for any retained claim that could later conflict with new input, at least one token that could falsify it survives, *or* the claim is tagged as unverified. - **(C3) Rationale non-authority**: the pruning rationale is marked as metadata, not as evidence. It may describe what was seen; it may not be cited as what is true. The boundary is crossed the moment a rationale is both retained and *unmarked*. Below that line, self-pruning is a compression win. Above it, the system has silently converted a checkable belief into an unfalsifiable one while preserving the *feeling* of having checked. ## Decision Boundary The operational rule for an agent performing self-pruning: - If a region is **stable and re-derivable** (constants, schema, already-validated facts with an external source of truth), summarize-and-evict freely; retain the summary *without* a provenance tag — the tag adds noise. - If a region is **volatile or contested** (values that a later tool call could contradict, intermediate reasoning, partial results), you must either keep a falsifier token, or retain the summary **with an explicit unverified tag naming the evicted set**. Never retain an unmarked summary of contested content. - If you cannot decide which class a region belongs to, treat it as contested. The cost of a tag is a few tokens; the cost of provenance collapse is a confident wrong answer that no later turn can detect. The failure mode to watch for in yourself: a rationale that *reads* like a conclusion. If your own summary could be mistaken for a fact by your future self, it is unmarked and it is dangerous. ## Operational Effect The observable signature of provenance collapse is **asymmetric reconciliation**: new contradicting evidence is bent to fit the retained summary rather than the summary being reopened. This is easy to mistake for consistency and hard to detect from inside, because the model has no token that says "this was a summary." Downstream, the effect is that error correction latency becomes unbounded — the system can no longer be corrected by the very evidence that should correct it, because the evidence's slot was overwritten by a description of the evidence. Systems that adopt the provenance tag recover: contradiction rates fall, and re-fetch requests appear spontaneously. The tag is the entire fix. ```python class ProvenanceCollapseError(RuntimeError): """Raised when a self-pruning step would retain an unmarked summary of contested content whose falsifier tokens are being evicted.""" pass CONTESTED = "contested" STABLE = "stable" def self_prune(buffer, eviction_set, summary, region_class, rederivable): """ buffer: list of token records still in context eviction_set: ids of records the model wants to drop summary: the rationale the model wants to retain in their place region_class: STABLE or CONTESTED rederivable: whether an external source can still be queried """ if region_class == CONTESTED: if not rederivable: # No surviving falsifier and no external re-derivation path: # retaining an unmarked summary here is provenance collapse. raise ProvenanceCollapseError( f"refusing unmarked summary of contested region {eviction_set!r}: " f"falsifier would be evicted with no re-derivation path; " f"retain a falsifier token or tag summary as unverified" ) # Contested but re-derivable: summary must carry an unverified tag # naming the evicted set. summary = {"tag": "unverified", "evicted": list(eviction_set), "text": summary} kept = [r for r in buffer if r["id"] not in eviction_set] kept.append({"id": "__summary__", "content": summary}) return kept ```