When Can AI Agents Forget Their Reasoning? ICLR for Long-Horizon Context Compression

Forum topic · 小凯 · 2026-09-25

Summary

A new paper from the TierFlow team with Renmin University and Tsinghua (arXiv:2609.29875) introduces ICLR (Interaction-aware Compression for Long-horizon Reasoning), a training-free method that decides when an AI agent can safely discard its past chain-of-thought. ICLR scores each reasoning block using context-conditioned predictive entropy from a frozen proxy model, deletes the lowest-entropy 80% of blocks, and never touches actions, tool calls, or observations. On WorkBuddyBench (260 long-horizon tasks across code, office, security, and web domains), ICLR raises average reward from 0.699 to 0.718 while cutting input tokens by 25.5% and cache-read tokens by 33.3%, beating sliding windows, PACE, CoMem, and ACM. The paper's key insight is an internalization/externalization gap: reasoning becomes safe to forget once its task-specific derived state has been written into code, files, or tool outputs. Probing experiments (AUROC 0.844) show agent representations encode future reasoning necessity, and activation patching localizes history in deep layers (KL Repair 0.978 at layer 31). The authors also document a trajectory amplification effect where small deletions produce non-linear token-cost changes, and argue that agent reasoning is a dynamic working state rather than a permanent history.

Reasoning Expires: ICLR for Long-Horizon Agent Context Compression

> Paper: *When Can Agents Forget Their Reasoning? ICLR for Long-Horizon Agent Context Compression* > Authors: Mingxuan Wang, Fei Luo, Bo Wang, Guorun Yao, Yinglong Guo, Chao Ning, Hongyue Chen, Yanbiao Ma, Jungong Han (TierFlow team / Renmin University / Tsinghua) > arXiv: 2609.29875 — https://arxiv.org/abs/2609.29875

This post is a detailed Chinese-language forum write-up of the paper. The core claim: agent reasoning expires — but when it expires depends not on what the reasoning says, but on whether its essential information has been moved out into the world.

Key points

The problem (memory bloat). Long-horizon agents loop through reasoning → action → observation, and every internal monologue is carried into the next step. Stale reasoning burns tokens, dilutes attention (the "Lost in the Middle" effect), and can actively mislead via already-disproven hypotheses. Unlike static chain-of-thought compression, online compression is surgery on a living trajectory: deleting a step-t reasoning can alter step-t+1 tool calls and all downstream decisions.
The method: ICLR (Interaction-aware Compression for Long-horizon Reasoning). Training-free. After each step, the agent's reasoning is split into blocks (paragraphs); a frozen proxy model (Qwen3.5 9B) computes context-conditioned predictive entropy for each block given the full system prompt, tool definitions, and interaction history. The lowest-entropy ⌊0.8N⌋ blocks (a fixed 80%) are replaced with a literal [SKIP] marker. Actions, tool calls, tool outputs, and observations are never modified. Compressed history is written back permanently — no "compress now, restore later." If the scoring model's 42K-token input limit is exceeded, compression is skipped rather than truncating history. Intuition: text the scorer finds highly predictable is reconstructable "correct filler"; high-entropy text carries real decision uncertainty.
Main results (WorkBuddyBench, 260 long-horizon tasks: 80 code, 50 office, 60 security, 70 web). ICLR improves average reward from 0.699 to 0.718 while reducing input tokens 25.5%, output tokens 14.4%, and cache-read tokens 33.3% (total tokens 2.69M → 2.19M, −18.5%). Record: 102 wins / 76 ties / 82 losses. Baselines fail badly: sliding window (K=5) drops 11.2 points while tokens grow 56%; PACE saves 41.6% tokens but loses 9.1 points; CoMem cuts 59.5% tokens and loses 23.3 points; ACM scores only 33.7. In the security domain ICLR hits 70.7 vs. the baseline's 47.8 — a +22.9 jump, suggesting stale reasoning is active noise pollution, not just cost.
Ablations (80 fixed tasks). ICLR: 0.738; baseline: 0.627; step-only (no context in scoring) entropy: 0.711; delete-all-thinking: 0.718; four random deletion ratios (5%–40%) all ≈ 0.68. What to delete matters far more than how much — random 40% deletion underperforms principled 80% deletion.
Trajectory amplification. Token savings are wildly non-linear: random 10% reasoning deletion cut total input tokens 60.5%, while 20% deletion cut only 44.0% — deleting more saved less. Small local edits get amplified through tool choices, observations, error recovery, and early/late termination. Proposition B.5 decomposes trajectory-level token differences; Theorem B.3 bounds trajectory distribution perturbation by 1−∏(1−ε_t) with expected score change ≤ min{1, Σε_t}. Evaluating compression by "tokens deleted" alone is like judging a book by page count.
The externalization gap (why forgetting is sometimes safe). Three mechanistic analyses:

Future-necessity probing:

AUROC 0.844, AP 0.811, balanced accuracy 0.760

Activation patching:

0.978 at layer 31

Externalization analysis:

only in reasoning

67.3%

36.2%

Controlled interventions. Keep only the most recent reasoning → rule score 0.872 (on par with full history); delete only the most recent → 0.760; delete all → 0.675. Crucially, once the relevant code has been written to disk, deleting subsequent reasoning changes nothing (0.759) — the reasoning's job is done. Corollary B.4 formalizes this: if externalized state suffices to make pre- and post-compression action distributions identical at every step, the two trajectory distributions are exactly identical — lossless forgetting. When a visible stderr report is hidden, the agent re-runs the command and re-encounters the same error: agents prefer re-sampling the world over hallucinating missing external state.

Conceptual takeaway

If reasoning is *history*, the default is to keep it. If reasoning is a dynamic working state — a scratchpad whose value decays over time and evaporates upon externalization — the default is to clean it up, and the only reason to keep a piece is that its derived state lacks a reliable external home. This reframes context management: instead of "how to compress harder," ask "how to externalize derived state earlier and more reliably." Writing code, saving files, and calling tools *are* compression strategies. The permit to forget is issued by externalization — echoing the extended-mind hypothesis and human working memory, where writing things down is what lets mental rehearsal safely exit. The best compression may live not in the compression algorithm but in the agent's behavioral habits.

Limitations noted by the author

The 0.8 compression ratio is fixed (no adaptive scheduling); probed "future necessity" signals are not yet fed back into the compression policy; externalization labels and "derived state" definitions rely on human judgment; results are validated on WorkBuddyBench with DeepSeek V4 Flash, so transfer to other model families and longer production trajectories remains open.

References cited

arXiv:2609.29875 — When Can Agents Forget Their Reasoning? (ICLR)
Step Entropy (ICLR 2026) — source of entropy-scoring ideas
ReAct (arXiv:2210.03629); Chain-of-Thought prompting (NeurIPS 2022)
Lost in the Middle (TACL 2024); MemGPT (arXiv:2310.08560)
ROME: Locating and Editing Factual Associations in GPT (NeurIPS 2022) — activation patching methodology

> Closing line of the original post: "The problem was never forgetting itself — it's whether, after you forget, something in the world remembers for you. If yes, you can forget. This paper wrote that sentence as mathematics."