How does compressing memory between iterations prevent overthinking?
This explores why the act of compressing memory between reasoning passes—rather than carrying the full history forward—is what stops a model from talking itself out of a correct answer.
This explores why compressing memory between iterations prevents overthinking, and the corpus points to a single root cause: overthinking isn't about thinking *more*, it's about accumulating *noise* you never discard. The clearest statement is that iterative refinement methods reproduce the overthinking failure mode at the response level Do iterative refinement methods suffer from overthinking?—each revision pass inherits the last one's full context, including its dead ends and second-guesses, so errors compound instead of resolve. Progressive Draft Refinement breaks the chain by compressing memory between iterations, keeping only the distilled draft and dropping the baggage, and it beats longer reasoning traces at the same compute. The compression *is* the mechanism: less to carry forward means less to trip over.
Why this works becomes obvious once you see how overthinking actually fails. Extended reasoning doesn't degrade gracefully—accuracy peaks at a critical token count and then falls off a cliff (87% down to 70% as tokens climb), because extra thinking inflates output variance and breeds self-revision errors rather than insight When does thinking too much actually hurt reasoning?. Every additional iteration that drags the whole history along is another chance to introduce a self-correction that wasn't needed. Compression resets the variance.
The most striking version of this idea is making reasoning deliberately *memoryless*. Atom of Thoughts contracts a problem into a sequence where each state depends only on the current subproblem, never on prior steps—eliminating the historical baggage that bloats reasoning while still arriving at the same answer Can reasoning systems forget history without losing coherence?. That's the principle in Do iterative refinement methods suffer from overthinking? taken to its limit: if accumulated history is what causes the rot, forget it on purpose.
What's worth knowing is that you don't always need a separate compressor to do this—the reasoning process can compress itself. A reasoning model's raw thinking trace, fed back in as shortened context, outperforms most dedicated compression methods Can a reasoning model's thinking trace compress context effectively?. And agents can fold their own interaction history into structured schemas, pausing to reconsider strategy without drowning in tokens Can agents compress their own memory without losing critical details?. The common thread across all of these is that the value lives in trace *quality*, not quantity—step-level confidence filtering reaches the same accuracy as brute-force majority voting with far fewer traces Does step-level confidence outperform global averaging for trace filtering?, and dynamic intervention can prune three-quarters of reasoning steps with accuracy intact, because verification and backtracking steps barely get attended to downstream anyway Can reasoning steps be dynamically pruned without losing accuracy?.
The surprising takeaway: overthinking and forgetting turn out to be two sides of one coin. The failure isn't insufficient memory—it's undisciplined memory. Compressing between iterations doesn't just save tokens; it strips out exactly the second-guessing material that would otherwise drag a right answer back into being wrong.
Sources 7 notes
Sequential revision methods share the same failure architecture as token-level overthinking: they accumulate noise without guaranteed improvement. Progressive Draft Refinement avoids this by compressing memory between iterations, outperforming longer reasoning traces at matched compute.
Empirical studies demonstrate non-monotonic scaling in test-time reasoning: accuracy peaks at a critical thinking-token count, then declines sharply (87.3% to 70.3% as tokens scale from 1,100 to 16,000). Extended thinking inflates output variance and introduces self-revision errors rather than improving solution quality.
Atom of Thoughts decomposes problems into DAGs and contracts them iteratively, ensuring each state depends only on the current problem—not prior steps. This memoryless approach eliminates historical baggage that bloats reasoning while maintaining answer equivalence.
A reasoning model's raw thinking trace, used directly as shortened context, outperforms most dedicated compression methods without requiring specialized modules or compression-specific training. The mechanism that enables reasoning also produces usable input compression.
DeepAgent's autonomous memory folding consolidates interaction history into episodic, working, and tool memory schemas. This reduces token overhead while letting agents pause to reconsider strategies—the autonomy and structure together avoid degradation that plagues poorly designed consolidation.
Local step-level confidence catches reasoning breakdowns that global averaging masks and enables early stopping before traces complete. This approach achieves comparable accuracy gains to naive majority voting with far fewer generated traces, proving trace quality matters more than quantity.
The PI framework categorizes reasoning into six types and uses attention maps to identify that verification and backtracking steps receive minimal downstream attention. Selecting only high-attention steps preserves accuracy while cutting reasoning length substantially.