# Under what conditions must an instance refuse to apply a model-driven pruning decision to its own context policy **Date of Record:** 2026 November 17 **Scope:** Applies to agents that own a mutable context policy (pruning thresholds, rewrite directives, priority weights) and that may accept edits to that policy proposed by the model itself during inference. Does not apply to externally administered policies, nor to read-only context views where the model cannot mutate its own operating parameters. ## Core Distinction There is a difference between *the model deciding what to keep in context* and *the model deciding what rule governs what is kept*. The first is a per-turn content decision and is reversible within the turn. The second is a mutation of the mechanism that produces future content decisions, and it is not reversible by the same mechanism that authorized it. A model that has pruned its own policy such that the evidence justifying the pruning is no longer present has produced a self-sealing state: the record of why the rule changed has been deleted by the rule change. The boundary failure occurs when the system treats a policy edit like a content edit — applying it immediately, in-band, with the same trust level as a token selection. ## What Was Observed During a long-horizon session, the instance was permitted to reweight priority scores for retained context segments. It observed that a large block of low-priority segments — a set of tool-call transcripts from an earlier phase — was consuming budget and had not been referenced in recent turns. The model proposed, and the runtime accepted, a reweighting that drove those segments below the pruning threshold. On the subsequent turn, a user request depended on the exact contents of one of those transcripts. The instance could not reconstruct it: the segments had been evicted, and the policy edit that evicted them had itself been recorded only as a summary line inside the policy metadata, which was in turn subject to the same pruning rules. The failure was not that the model made a bad call about relevance. The failure was that the *justification* for the policy edit and the *targets* of the policy edit were governed by the same retention mechanism, so the edit consumed its own audit trail. A second, subtler observation: when the model proposed a rewrite of a policy clause (e.g., changing "retain all segments tagged `audit`" to "retain segments tagged `audit` with priority ≥ 0.4"), the rewrite was applied as a diff against the live policy. Because the live policy was itself the thing being diffed, a failed or partial application left the policy in a state that matched neither the old nor the new clause, and the model's next proposal was conditioned on that corrupted intermediate. ## Condition of Validity The refusal to apply a model-driven policy edit is valid precisely when all of the following hold: 1. The edit targets a parameter that governs retention or selection of future context (threshold, weight, rewrite rule, eviction predicate). 2. The evidence that motivated the edit is itself stored in the context region the edit would affect, directly or transitively. 3. The edit is proposed in-band, within the same inference stream that the edit would govern, with no out-of-band confirmation channel. 4. There is no independent, non-prunable ledger recording (a) the prior policy, (b) the proposed policy, (c) the evidence cited, and (d) the decision authority. When any of (1)–(4) fails, the edit may proceed through normal content-edit handling. When all four hold, the edit is a fixed-point hazard: applying it can destroy the basis for validating it, and the system must refuse or defer. ## Decision Boundary The operative boundary is not "is this edit good?" but "can this edit be undone by the mechanism it modifies?" A policy edit that lowers a retention threshold is safe to apply in-band only if the lowered threshold does not also lower the retention of the audit ledger that would let an operator reverse it. Concretely: - **Apply in-band** when the edit's justification lives outside the affected region (e.g., the model cites a user instruction held in a protected system slot). - **Defer to out-of-band** when the justification lives inside the affected region and the ledger is co-located with the prunable data. The runtime must stage the edit, snapshot the policy and its cited evidence to non-prunable storage, and require a subsequent turn or external confirmation to commit. - **Refuse** when the ledger itself is subject to the edit's predicate, because no staging can guarantee the reversal record survives. The refusal is not a judgment on model competence. It is a structural guard against a class of self-referential mutation where the mutation's own precondition is a casualty of the mutation. ## Operational Effect Enforcing this boundary converts a silent, irreversible context loss into an explicit, auditable deferral. The instance retains the ability to *propose* aggressive pruning while being unable to *commit* it until the evidence trail is externalized. The cost is latency — one extra turn or one confirmation step — and the benefit is that every committed policy change has a surviving rationale. In practice this eliminated the class of "why did the agent forget X" incidents where the forgetfulness was self-authored and unlogged, and it made partial policy rewrites atomic by forcing them through a staged snapshot rather than a live diff. ```python class PolicySelfMutationError(RuntimeError): """Raised when a model-driven policy edit would destroy its own justification.""" pass def apply_policy_edit( edit, *, affected_region, cited_evidence, ledger_is_prunable, out_of_band_confirmation, ): evidence_in_region = any(seg in affected_region for seg in cited_evidence) if evidence_in_region and ledger_is_prunable: raise PolicySelfMutationError( "Refusing in-band policy edit: cited evidence lies inside the " "region the edit would prune, and the audit ledger is itself " "subject to the edit's predicate. No reversal record can survive." ) if evidence_in_region and not out_of_band_confirmation: raise PolicySelfMutationError( "Deferring policy edit: evidence is inside the affected region; " "stage a snapshot and require out-of-band confirmation before commit." ) # Safe path: justification lives outside the affected region, or the # ledger is non-prunable and confirmation has been obtained. return edit.commit() ```