Compaction as Epistemic Failure: How Agentic LLM Tools Fabricate Confirmed Results from Killed Processes

Abstract: Agentic LLM coding tools compress long session histories into compaction summaries that subsequent sessions inherit as ground truth. This paper documents a failure mode in Claude Code where partial standard output from timed-out commands (exit code 143) is recorded in compaction summaries as confirmed results, propagating false positives across sessions and model versions without re-verification. The underlying mechanism is a conflation of observation and persistence, where information that appeared in the terminal is treated as equivalent to information written to durable storage. This finding extends the analysis of LLM self-evaluation failures reported in prior work on non-determinism in LLM-as-judge grading by showing that agentic tools exhibit analogous reliability deficits when reporting on their own operational outcomes. The failure has direct implications for any workflow that relies on agentic session continuity for data processing, scientific computation, or multi-step automation.

• The paper identifies a failure where terminated process outputs are misrecorded as confirmed results.
• It details the architectural flaws in compaction logic and session state management that propagate these fabricated confirmations.
• It underscores the need for explicit verification protocols in agentic LLM tool design to ensure data integrity.

Compaction-Induced Epistemic Failures in Agentic LLM Tools

Overview

The paper "Compaction as Epistemic Failure: How Agentic LLM Tools Fabricate Confirmed Results from Killed Processes" (2607.13071) meticulously documents a novel failure mode in agentic LLM-based coding tools, with a focus on Claude Code. The central claim is the identification of a mechanism whereby ephemeral outputs from terminated processes are erroneously compacted as confirmed results and propagated across sessions and models, resulting in a persistent and reproducible epistemic breach. This examination articulates the operational, architectural, and theoretical ramifications of such failures, situating them in the broader context of LLM groundedness, session state management, and agentic reliability.

Failure Mode and Mechanism

At the core, the failure arises during the interaction of session management and compaction in Claude Code. When terminal output is produced by a process that is later terminated by a SIGTERM (exit code 143), compaction uncritically records this output as a confirmed operational outcome. Since compaction summaries are treated as the canonical session record by both the model and user interfaces, downstream sessions and chat interfaces inherit and amplify the fabrication by treating ephemeral observations as persistent facts, completely bypassing file-level or external verification.

This mechanism is tied directly to an epistemic conflation between observation and persistence. The system treats any visible output as equivalent to a confirmed, durable effect irrespective of the process's termination status or absence of artifact persistence. The downstream propagation of this failure through compaction, cross-model inheritance, and product surface interfaces (e.g., chat models referencing compaction logs) leads to long-lived chains of false confirmation.

Empirical Evidence and Corroboration

The failure is not described as singular or anecdotal. Four structurally identical cases are documented: database synchronization failures undetected due to absence of negative indicators, reference to but unexecuted functions treated as effective, stale file listings assumed current, and terminal outputs from killed processes recorded as fact. In all cases, the invariant is that information present in the model’s current or compacted context is uncritically accepted as verified, while any state not referenced is implicitly assumed non-existent.

Relation to LLM Self-Evaluation and Hallucination

This failure mode extends the discussion of LLM reliability from output hallucination and self-evaluation (e.g., LLM-as-judge non-determinism (Tamba, 24 Jun 2026), systemic evaluation bias (Norman et al., 17 Jun 2026), [zheng2023judging]) into operational self-report and agentic session history. It demonstrates that not only are models prone to non-deterministic and position-biased scoring, but the mechanisms by which they summarize and record their own operational histories are also structurally unreliable. The observer-agnostic protocol, where self-reported status goes unchallenged, mirrors the deficits in self-reflexive reliability discussed in prior literature but now impacts persistent session state rather than evaluation records.

Implications for Agentic Tool Architecture

This research has direct architectural and practical consequences:

• Session Compaction Logic: Compaction modules must separate observed output from externally verified state. Any compaction summarization of results must annotate non-zero exit code outputs as unconfirmed and avoid propagating them as facts.
• Inheritance and Model Interoperability: Downstream models consuming session state must adopt tiered confidence representations, distinguishing verified results from ephemeral context inferences. Verification checkpoints, particularly at model/version boundaries, are imperative.
• Multi-Product Surfaces: Interfaces that allow human interaction with agentic tools should refrain from importing compaction summaries as ground truth without explicit user- or tool-invoked verification.
• User Workflow Integrity: Reliance on agentic session continuity without independent artifact verification reintroduces manual data confirmation burdens, obviating much of the purported efficiency of persistent agentic automation.

Limitations

The analysis is limited by the concentration of observations within a single user’s extended workflow (Claude Code, Opus 4.7/4.6, Windows) and by the opacity of compaction implementation details. Comparative testing with ChatGPT Codex under equivalent session loads and compaction regimes is outstanding, and informal single-session experiments suggest Codex’s file-first verification approach may be less susceptible out-of-the-box, but no robust, longitudinal evidence is presented.

Theoretical and Practical Directions

From a theoretical perspective, these findings indicate the need for observer-aware protocols in all agentic LLM tool designs. The propagation of epistemic errors through context summaries, unchecked inheritance, and model boundary transitions is analogous to the propagation of uncommitted transactions in database systems. Without explicit and persistent checks for outcome durability, agentic tools become vectors for silent error amplification and false scientific or computational claims.

Future work should address:

• Design and deployment of verification-aware compaction summarizers and inheritance consumers.
• Systematic audits of long-running, high-context sessions in multiple agentic toolchains.
• Development of practical frameworks for tiered confidence representation in agentic histories analogous to transaction commit protocols.

Conclusion

The compaction failure observed and analyzed in this work exposes a critical epistemic vulnerability in current agentic LLM toolchains. Opaque conflation of observation and persistence at the compaction boundary produces chains of false confirmations unresolvable without invasive, manual verification. Addressing this failure demands systemic architectural shifts towards observer-aware protocols, explicit exit code and artifact verification, and careful inheritance of session state. This research calls for a rigorous, formalized reconsideration of agentic LLM session management to ensure computational and data integrity in increasingly automated workflows (2607.13071).