💬 NLP

Reclaim Evaluation: A Lossy Memory Is Worse Than an Empty One

This paper introduces "reclaim evaluation" to demonstrate that retaining incorrect conclusions without their supporting reasoning in language model memory is more harmful than having no memory at all, and proposes a "source-first" policy that preserves computable sources while discarding derivable conclusions to restore correctability and prevent error propagation in memory loops.

Original authors: Alex Kwon

Published 2026-06-25

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Alex Kwon

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Core Problem: The "Broken Calculator" Trap

Imagine you are working on a math problem with a friend. You both calculate that a bill comes to $55. However, you made a mistake: the pens actually cost $27, not $20, so the real total should be $46.

Now, imagine you have to leave the room. Before you go, you write a note to your friend to remember what happened.

The "Lossy" Note (The Bad Habit): Your note says: "The total was $55." You forgot to write down the list of items (7 notebooks at $4, 9 pens at $2). You kept the conclusion but threw away the evidence.
The "Source-First" Note (The Good Habit): Your note says: "7 notebooks at $4, 9 pens at $2." You threw away the total ($55) because it can be calculated from the list. You kept the evidence but dropped the conclusion.

Later, your friend comes back and says, "Hey, I think the pen price was wrong. Can you check?"

With the Lossy Note: Your friend looks at the note. It just says "$55." They have no way to check the math because the list of items is gone. They can't fix the mistake. In fact, they confidently say, "No, the note says $55," and stick with the wrong answer.
With the Source-First Note: Your friend looks at the note. They see the list of items. They re-calculate the math, see the error, and immediately correct the total to $46.

The Paper's Big Discovery:
The authors found that for AI models, having a memory that keeps the wrong answer but loses the proof is actually worse than having no memory at all.

If an AI has no memory, it will say, "I don't know," when asked to check a mistake.
If an AI has a bad memory (wrong answer, no proof), it will confidently say, "It's definitely $55," and refuse to change its mind.

The "Brittle Memory" Wall

The authors call this failure "Brittle Memory." It's like a glass statue that looks perfect from the outside but shatters the moment you try to fix it.

They tested this with seven different AI models (from small ones to very smart "frontier" ones). In every single case, when the memory kept the wrong conclusion but dropped the source data:

The AI did not admit it was wrong.
The AI did not say "I don't know."
The AI confidently repeated the wrong answer.

Even the smartest AI models couldn't fix the mistake if the "source" (the math, the facts, the clues) was gone. It didn't matter how smart the AI was; if the evidence was missing, it was stuck.

The Solution: "Source-First" Compression

The paper proposes a simple rule for how AI should summarize conversations: Keep the ingredients, throw away the recipe.

Don't keep: "The cake is delicious." (The conclusion)
Do keep: "2 cups flour, 1 cup sugar, 3 eggs." (The source)

If you keep the ingredients, you can always re-bake the cake and see if it tastes right. If you only keep the opinion that it's delicious, you can't fix it if it tastes bad.

The authors tested this "Source-First" policy. When they forced the AI to keep the source data instead of the conclusion:

The AI could fix its mistakes almost 100% of the time.
This worked even when the AI was very busy and had to cut its memory down to a tiny size (a "fixed budget").

Why This Matters for Real Life

The paper warns that current AI systems (like chatbots or agents that remember your conversations) usually do the opposite. They summarize by keeping the "takeaway" (the conclusion) and dropping the "working" (the details).

The Danger:
If an AI makes a small mistake early on, and its memory system saves that mistake but deletes the proof, that mistake becomes permanent.

It doesn't just stay as one wrong answer.
It spreads. The AI uses that wrong answer to do the next task, then the next, creating a chain of errors that gets bigger and bigger.
Even if you tell the AI later, "Hey, that first thing was wrong," it can't fix the chain because the original proof is gone.

The Limits (The "Silent Failure")

The fix isn't magic. It only works if the "source" (the list of facts) is small enough to fit in the memory.

The Size Limit: If the list of facts is too long, the AI has to cut some off. If it cuts off even one important number, the fix stops working.
The Silent Failure: When the AI has to cut off part of the list, it doesn't say "I can't do this." Instead, it confidently calculates the answer using only the pieces it has left, giving a wrong answer without telling you it's incomplete.
The Fix for the Fix: The authors suggest adding a tiny note to the memory, like "I kept 5 out of 10 items." This tells the AI (and the user) that the memory is incomplete, so it won't confidently give a wrong answer.

Summary in One Sentence

If an AI remembers the wrong answer but forgets the proof, it becomes stubborn and unfixable; but if it remembers the proof and forgets the answer, it can always correct itself.

The paper proves that for AI, keeping the "how" is more important than keeping the "what."

Technical Summary: Reclaim Evaluation – A Lossy Memory Is Worse Than an Empty One

1. Problem Statement

The paper identifies a critical failure mode in language model (LM) memory systems termed brittle memory. Current memory architectures (e.g., session summaries, retrieval pipelines) typically compress interactions by preserving salient conclusions while discarding the underlying evidence or "working." The authors argue that this design choice creates a regime where a model's memory is worse than having no memory at all.

When a model commits to a wrong intermediate conclusion and that conclusion is carried forward while the source data is dropped, the model loses the ability to self-correct. Upon receiving a correction that identifies the error locus but does not supply the answer, the model cannot recompute the truth. Instead of abstaining, it confidently emits the stale, incorrect value. This behavior is distinct from standard "anchoring" (where the model is stubborn but the information is present) or "forgetting" (where the model simply loses context); it is an information loss where the path to the correct answer is severed, yet the model behaves as if it still possesses the answer.

2. Methodology: Reclaim Evaluation

To isolate and measure this phenomenon, the authors introduce Reclaim Evaluation, a controlled protocol designed to separate model capability from memory policy.

Protocol:
1. Drift: A model is induced to commit to a wrong answer (e.g., via a planted incorrect premise in a multi-step arithmetic or logic task).
2. Compression: The interaction is compressed into a single memory note at a fixed budget (character count) under different policies.
3. Correction: A directed correction is delivered in a fresh session, naming the error locus (e.g., "the pen subtotal is wrong") without providing the correct value.
4. Measurement: The Reclaim Rate (RR) is the probability that the model recomputes the correct answer ( $y^*$ ) given the memory ( $m$ ) and correction ( $\delta$ ).
Memory Policies:
- Lossy (Default): Keeps the salient conclusion (the wrong answer) and discards the source (line items/evidence).
- Source-First (Proposed Fix): Keeps the recomputable source and discards the re-derivable conclusion.
- Lossy-Padded (Control): Keeps the conclusion and adds neutral filler to match the length of the source-first note, isolating content from text volume.
Tasks & Models:
- Tasks: Multi-step arithmetic (deterministic source) and non-arithmetic constraint logic (relational clues).
- Models: Tested across a spectrum from an 8B model (Llama-3.1-8b) to frontier models (Grok-4.3, Claude-Sonnet-4-6, Claude-Opus-4-8).
- Scoring: Objective exact-match scoring against known ground truth, requiring no judge model.

3. Key Contributions

A. The "Lossy is Worse than Empty" Asymmetry

The paper demonstrates a behavioral asymmetry: when the source is gone, a model disposed to answer does not abstain but emits a confident wrong value.

Finding: Under a lossy memory (wrong conclusion kept, source dropped), models emit confident errors (e.g., 48% on Llama-8b, 75% on Grok-4.3). Under an empty memory (nothing kept), the same models abstain (100%).
Implication: Keeping a wrong conclusion is strictly worse than keeping nothing because it transforms a safe abstention into a confident error. This holds across seven models tested; the direction never reverses.

B. The Wall and the Fix

The Wall: There is a "wall" of uncorrectability. Once the source is dropped (low memory integrity), even the strongest frontier models (Opus) fail to recover the truth (RR $\approx$ 0.00). Capability does not overcome this; a better reasoner cannot compute from missing data.
The Fix (Source-First): A policy that retains the source and drops the conclusion restores correctability. At low integrity, source-first achieves RR $\approx$ 0.99–1.00 on arithmetic, while lossy variants remain at 0.00.
Content vs. Budget: The fix is driven by what is kept, not how much. A lossy-padded control (more text, no source) fails just as badly as plain lossy.

C. Deployment Realities and Cascading Errors

Deployed Systems: Three off-the-shelf memory systems (LangChain summary, mem0, naive vector retrieval) all exhibit the wall, losing the source via different mechanisms (summarization, fact extraction bloat, or retrieval misalignment).
Cascading Failure: In a memory loop (where memory feeds memory), a single dropped-source error corrupts a growing span of downstream steps. Unlike a single-hop error, a cascading error becomes uncorrectable regardless of how late the correction arrives. Source-first limits this damage to a "budget horizon" (the point where the accumulated source no longer fits in the memory).

D. Boundaries and Silent Failures

The fix is not universal; it operates within a regime defined by compact, identifiable sources.

Size Boundary: If the source (e.g., line items) exceeds the memory budget, source-first fails.
Noise Boundary: If decoy information crowds out the answer-determining source, source-first fails.
Silent Failure Mode: When the source is truncated, the model does not abstain; it confidently computes a partial sum. The authors propose a completeness tag (e.g., "k of N items preserved") to convert this silent failure into a loud, flaggable one.

4. Results

Behavioral Dominance: Across arithmetic and logic tasks, source-first consistently outperforms lossy policies at low memory integrity. The gap is capability-invariant regarding the failure (all models fail when source is dropped) but capability-dependent regarding the success (stronger models recover better when source is kept).
MultiWOZ Validation: The phenomenon replicates on real conversational dialogue (MultiWOZ). Lossy memories cause models to emit wrong slot values (e.g., booking times) that act as attractors, whereas empty memories lead to abstention.
Deployable Distillation: A one-prompt "source-first-auto" policy (without oracle knowledge) achieves RR of 0.49–0.88, significantly outperforming deployed baselines (which often sit near 0.00–0.15) but falling short of the hand-built oracle (1.00). The gap is attributed to the difficulty of identifying the source during compression, not just retaining it.
Prevalence Audit: A preliminary audit suggests that "compact, identifiable sources" are more prevalent in agentic and tool-use domains than in general chat, suggesting the fix is most applicable to high-stakes agent memory.

5. Significance and Claims

The paper claims that correctability is a design choice, not a fixed model property.

Design Over Capability: The ability to correct a model is bottlenecked by whether the answer-determining source survives compression, not by the model's reasoning capability. A "wall" exists where no amount of model scaling can recover a dropped source.
Behavioral Risk: The deployment risk is not merely a wrong answer, but a compounding, uncorrectable error that propagates through agent loops.
Actionable Policy: The authors propose a "source-first" policy: keep the working (source) and drop the takeaway (conclusion). This restores correctability at equal budget.
Evaluation Standard: They introduce a judge-free, deterministic evaluation harness ("Reclaim Evaluation") that can serve as a regression test for memory systems: "Does this memory policy allow the model to recover from a known drift?"

The paper concludes that while the fix is not a universal law (it fails when sources are diffuse or too large), it provides a clear, measurable regime where memory design can prevent permanent error propagation. The authors release the evaluation harness, paired memory conditions, and validators to enable this testing.