Cutting your agent's context changes what it does next

Every long-running agent has the same problem. Reasoning piles up. Step 40 is still carrying the deliberation from step 3, a decision that was made, executed, and observed 37 turns ago. You pay for it in input tokens, in cache reads, and eventually in attention spread thin over text that stopped mattering a long time ago.

So you trim it. Drop the old thinking, keep the actions and the tool output, move on. It looks like housekeeping, a cache eviction policy, the sort of thing you switch on and measure afterwards.

A paper posted last week (arXiv:2609.29875, Wang et al.) argues that this framing is wrong, and that argument is the part worth your time. Deleting a reasoning block is not a read-only change to the record. The agent's next action is conditioned on that record. Remove one paragraph of old thinking and the agent may take a different step, which produces a different observation, which changes every step after it. The authors name this trajectory amplification: a local deletion produces a nonlinear change in total computation, because it altered what happened next.

That has a consequence most people building these systems have not priced in. You cannot evaluate a compression policy the way you evaluate a cache. There is no held-fixed run to compare against. You changed the run.

What they actually did

The method, ICLR, is deliberately unambitious, and that is the right instinct. No training, no learned compressor. It ranks accumulated reasoning blocks by entropy under a frozen proxy model and drops the low-value ones online. Actions, tool calls, and observations are never touched. Only the model's own prose about them.

On 260 tasks from WorkBuddyBench: average reward moves from 0.699 to 0.718, input tokens fall 25.5%, output tokens 14.4%, cache reads 33.3%.

Read those numbers in the right order. The reward change is +0.019 on one benchmark with no variance reported, which is noise until somebody shows otherwise. Reporting this as "compression makes agents better" is exactly the overclaim to avoid. What holds up is the cost result: you can throw away a quarter of the input and a third of the cache reads without the thing getting worse. For anyone running agents at volume, not getting worse while paying 25% less is the entire win. It does not need a reward bump stapled to it.

The rule that generalises

The more useful finding is the condition attached to it. Through representation probing and activation patching, the authors find that old reasoning becomes safe to delete once the state it derived has been externalized: written into code, saved to a file, returned by a tool, or made visible in the environment.

That is a design rule, and it runs the opposite way from how it first sounds. It does not say "compress more cleverly." It says that if your agent holds important derived state only in its own prose, you have built something you cannot compress and cannot recover. The reasoning is load-bearing. Delete it and you delete the state.

Anyone who has written a CLAUDE.md, kept a scratchpad file, or committed a step-by-step plan to disk has been doing this on instinct already, for a different reason: so the work survives the session ending. The paper gives that habit a second justification. Externalized state is what makes forgetting cheap.

Which reframes what an agent's context is. Not a transcript to be summarised at the edges. Working memory, where the job is to get things out of it and into somewhere durable while they still matter.

What I would take into a real system

Three things, in the order I would do them.

Write derived state down at the moment you derive it. Not at the end of the task. Not in a summary step. If the agent concluded that the bug is in the retry handler, that belongs in a file, a commit message, or a tool call, not only in a paragraph of thinking that some ranker will eventually score as low entropy and drop.

Never compress actions and observations. ICLR does not, and the reason is structural rather than cautious. Reasoning can be reconstructed from the state it produced. An observation cannot be reconstructed from anything.

Expect compression changes to resist A/B testing. Because of amplification, two runs under different compression policies are not one run with a single variable changed. Judge a policy across a distribution of tasks and on total cost, not by diffing a pair of traces and picking the tidier one.

What this does not tell you

One benchmark, one method, a frozen proxy model as the ranker, no reported spread across seeds. The single-benchmark result is the weakest part of the claim, and the 30-page version presumably carries more than the abstract admits. Nothing here tells you which reasoning your agent can forget, on your tasks, with your tools.

The framing survives the thin evidence, though, and framings are what change how people build. An agent's context is state under active management, with a running cost and a write-out discipline. Deleting from it is an edit to the future, not a tidy-up of the past.

---

Source: When Can Agents Forget Their Reasoning? ICLR for Long-Horizon Agent Context Compression, Mingxuan Wang, Fei Luo, Bo Wang and six co-authors, arXiv:2609.29875, submitted 24 September 2026.

---

Source: https://arxiv.org/abs/2609.29875