Long conversations with language models are increasingly managed by a running summary. After each turn, the model rewrites a short "state" note that stands in for everything said so far, and the old transcript is dropped from the prompt. This keeps cost bounded, but it creates a loop: whatever the summarizer writes becomes the only record the next update sees. If the note gains a plausible but unsupported claim, such as "Anna and Tom are married" because they picked up a child together, that claim is never checked against the transcript again. It can be built on, elaborated, and repeated in every later answer. Small, cheap summarizers, which are the ones people actually want to deploy, are the most likely to make such errors. They are also the least studied in this loop.
We propose to train a compact recursive dialogue-state compressor by knowledge distillation, where a large model's knowledge is transferred into a small one. The distillation is designed against this failure. A large teacher model, which can see the full raw transcript, audits each state the student writes during the student's own rollouts. It labels every claim as stated, inferred, or unsupported, lists salient facts the student dropped, and writes a corrected state. The student is then trained to map its own possibly flawed previous state plus the new turn onto that corrected state. Each claim also carries a pointer to the turn that supports it, so a small checker can later verify the claim against that turn alone. The core bet is that the hallucination problem in recursive memory comes mainly from errors compounding across updates, not from errors within a single update. Distillation that never exposes the student to its own corrupted states cannot teach it to stop that compounding.
Core Claim
Recursive summarization treats the state $S_t$ as a sufficient stand-in for the history $H_{1:t}$. This assumption underlies persistent dialogue-state memories in task-oriented dialogue (Sungdong Kim et al., Su Zhu et al.) and the running scratchpad in LIGHT (Beyond a Million Tokens). None of these works measures what happens when $S_t$ itself is wrong. We make two testable claims.
The first claim is that small recursive compressors exhibit snowballing at the level of the memory state. We define the snowball ratio as
$$\rho = \frac{P(\text{new unsupported claim in } S_{t+1} \mid S_t \text{ contains an unsupported claim})}{P(\text{new unsupported claim in } S_{t+1} \mid S_t \text{ is clean})},$$
where "unsupported" is judged against the raw history $H_{1:t+1}$. DiaHalu reports this kind of doubling-down for chat responses (DiaHalu). We expect $\rho > 1$ for memory states as well, and larger for smaller models.
The second claim is that on-policy, privileged-teacher distillation lowers both the per-step error rate and $\rho$, whereas ordinary offline distillation lowers mainly the former. On-policy means the teacher corrects the student's own rollouts. Privileged means the teacher sees the full transcript while the student does not. Offline distillation here means imitating teacher-written states computed from clean teacher histories.
If the first claim fails and $\rho \approx 1$, the proposal reduces to plain offline distillation. We therefore treat that measurement as the first decisive experiment, not an afterthought.
How This Sits Against Prior Work
The closest work distills compressors for a different target. ACON optimizes natural-language compression guidelines from agent task failures and distills them into students such as Qwen3-14B, which retain over 95% of teacher accuracy (ACON). Its signal is task reward, so a state that swaps a speaker's role but still lets the agent finish the task counts as good. We keep its idea of distilling a compressor but replace the training signal with claim-level faithfulness against the uncompressed history.
MeDistill trains Flan-T5-Large with a dual objective: write a summary and extract structured facts. The student beats its GPT-3.5 teacher on clinical precision (MedBERTScore precision 74.62) (MediExtract). This motivates our use of structured auxiliary supervision. Its setting is single sessions with unverified teacher labels. Ours is many sequential updates with verified labels.
FENICE distills atomic-claim extraction from GPT-3.5 into a T5 model that scores 70.0% balanced accuracy on AggreFact (FENICE). It supplies our representation of a state as atomic claims and our cheap checker. It was never applied to dialogue or to memories that rewrite themselves.
Three findings constrain the design. First, post-hoc correction of dialogue summaries is nearly hopeless at inserting omitted facts; the best corrector reaches $F_{0.5}$ of 15.69 on SAMSum (Reference Matters). This is why we fix omissions at write time rather than repairing afterward. Second, 38% of LLM dialogue-summary errors are "circumstantial inferences," and standard NLI and QA metrics detect them at only 40–50% balanced accuracy (Analyzing LLM Behavior). This is why our states explicitly separate stated from inferred claims, and why we validate with human annotation rather than trusting off-the-shelf metrics. Third, ReMEMBER argues that incremental summarization inherently loses fine-grained evidence and retrieves raw turns instead (Don't Scroll Back). Our provenance pointers partly concede this point: the transcript is kept on disk, outside the prompt, and is consulted only to check specific claims. Rather than abandon compression, we keep it and make it auditable.
Research Program
State format. The state is a short list of atomic claims. Each claim carries a speaker attribution, an epistemic tag (stated, inferred, or retracted), and a pointer to the turn or turns that support it. A few recent raw turns are kept alongside, following the hybrid design of Vishakh Padmakumar et al..
Teacher audit. We use an open-weight large model as the teacher, for reproducibility. At each step it receives the student's proposed $S_{t+1}$ and the full raw history $H_{1:t+1}$. It returns three things: a per-claim verdict, a list of omitted salient facts (with emphasis on the referential, attribute, and relational gaps catalogued by ReMEMBER), and a corrected state. The teacher can itself hallucinate, which is the "distillation of hallucinations" risk. To reduce this, its verdicts are cross-checked by a FENICE-style NLI pass against the cited turns. Disagreements are dropped from training, and a human-annotated audit subset estimates the residual label noise.
Student training. Student sizes are roughly 1B, 4B, and 8B. Training proceeds in DAgger-style rounds (a method that alternates between letting the student act and having the teacher correct those actions). Each round rolls the student through long dialogues and collects teacher corrections at every step. The student is then trained on triples of (its own $S_t$, $U_{t+1}$, corrected $S_{t+1}$), using a MeDistill-style mixed loss: generating the state, plus auxiliary prediction of the per-claim tags. This way the student sees inputs containing its own past errors. It learns to retract earlier claims when a new turn contradicts them, to stop citing claims whose support it cannot point to, and to keep "inferred" claims from becoming premises for new ones.
Training data. Training dialogues come from the long multi-session conversations of LoCoMo and RealTalk. We also use synthetic long dialogues generated in the style of BEAM, keeping BEAM's own dialogues held out for testing.
Inference. At deployment the student runs alone. Optionally, a distilled small checker verifies a claim against its pointed-to turn when the claim is used to answer a question.
Baselines
Naive reference. The do-nothing reference is the same small base model, prompted to update a running summary recursively with no distillation. This is the setting where we expect $\rho$ to be largest. We also report the raw-transcript ceiling at each model's maximum context length, where it fits.
Offline sequence-level distillation. The most important competitor is the student trained on teacher-written recursive states, where the teacher compresses its own clean history. This is how ACON-style and MeDistill-style pipelines would be ported to this setting, and it isolates our key ingredient: training on the student's own trajectories with privileged correction. It uses the same student, the same teacher, the same dialogues, and the same count of teacher-labeled update steps. Both systems receive an equal hyperparameter search budget.
ACON adaptation. We run ACON's guideline optimization with our teacher and distill the result into the same student. This shows whether optimizing for task utility already buys faithfulness.
Retrieval memory. ReMEMBER with its 4B model represents the camp that "abandons summarization." On its streaming benchmark it reports memory recall of 0.6984 against 0.5412 for the best plain retrieval baseline (Don't Scroll Back). This is the strongest reported number in our setting. We run it at matched prompt-token budgets.
LIGHT scratchpad. LIGHT's scratchpad is the strongest compressed-memory system on BEAM, where it is reported up to 12.69% above the strongest baselines (Beyond a Million Tokens). We run it with the full-size model and with our student.
Ablations. Within our method we remove three components one at a time: the provenance pointers, the epistemic tags, and the teacher's omission list.
For per-step factual precision of recursive dialogue-state summarizers, no reported result found on Lacuna. These numbers will be produced here for every baseline.
"Beating" a baseline has a specific meaning. The method should match offline distillation's per-step claim precision and omission rate within noise, and lower $\rho$ and the late-dialogue (final quartile) unsupported-claim rate by a margin outside bootstrap confidence intervals. It should also match or exceed ReMEMBER's summary faithfulness at an equal or smaller prompt budget.
Why not just…?
Why not just distill teacher summaries offline and skip the on-policy loop? This is the real threat. If the student's errors were independent across steps, offline distillation would be enough and much cheaper. The ablation against matched offline distillation settles it. We predict that the two have similar error rates in early turns and diverge late, because only on-policy training ever shows the student a corrupted $S_t$. If they do not diverge, we will report that and recommend offline distillation.
Why not just run a distilled verifier like FENICE on each state and delete flagged claims? Filtering can remove fabrications, but it cannot restore facts the compressor dropped. Reference Matters shows that inserting omitted facts is where post-hoc editing fails almost completely. Filtering is also bounded by detector accuracy on circumstantial inferences, which is weak for standard metrics (Analyzing LLM Behavior). We include "offline student plus checker-filtering" as an extra baseline. If it matches us on precision, our remaining advantage must show up in omission rate, and we will report whether it does.
Why not just keep raw history and retrieve, as ReMEMBER does, or use a long context? On BEAM, vanilla long-context models degrade with length and fail most at contradiction resolution (Beyond a Million Tokens). Retrieval answers the question "what evidence is missing for this window" but keeps no consistent belief about the user, so it cannot notice that a preference has changed. We compare on BEAM's contradiction-resolution category and on ReMEMBER's own benchmark at equal token budgets. Losing on the latter would show that our states compress away evidence that retrieval keeps.
Why not just re-summarize from the raw transcript every k turns? Periodic re-anchoring resets compounding at the cost of a large, growing pass over the full history. We include it at k values matched on total compute. If it dominates, the snowball problem is better solved by scheduling than by training.
Proposed Experiments
The first experiment measures compounding before anything is trained. We run recursive prompting baselines at three student sizes and the teacher size over LoCoMo, RealTalk, and EverMemBench dialogues. A human annotation pass labels claims at about 50 checkpoints per dialogue, using the TofuEval-style sentence-level protocol with professional annotators (TofuEval). From these labels we estimate $\rho$ and the per-step rate of new unsupported claims, broken down by circumstantial-inference versus entity or role errors using the categories from Analyzing LLM Behavior. The go/no-go criterion is a $\rho$ significantly above 1 for the small models.
The second experiment is the main comparison. All baselines above are run on held-out dialogues and scored on three groups of measures: per-step claim precision and omission rate against human labels; $\rho$ together with the error trajectory over turn index; and downstream quality. Downstream quality means BEAM question answering by memory dimension, with contradiction resolution reported separately, and ReMEMBER's composite faithfulness, completeness, and conciseness for streaming summaries.
As a static sanity check, we test whether students trained on long dialogues lower circumstantial inferences in single-shot SAMSum and DialogSum summaries.
The third experiment checks the evaluation and the method's cost. We measure how well the teacher-plus-NLI audit agrees with humans on dialogue claims. The reference points are ChatGPT-MoE's 70.27% balanced accuracy on dialogue summaries (Analyzing LLM Behavior) and FENICE-T5's 70.0% on AggreFact. We also report how much of our gain survives when audit labels are restricted to the human-verified subset. Finally, we report tokens and wall-clock time per update relative to ACON's reported 26–54% peak-token savings.
The proposal succeeds if on-policy privileged distillation specifically reduces late-dialogue compounding and omissions at small model sizes. It fails informatively if compounding turns out to be negligible, or if filtering or re-anchoring explains the gains.
References
- Efficient Dialogue State Tracking by Selectively Overwriting Memory
- Efficient Context and Schema Fusion Networks for Multi-Domain Dialogue State Tracking
- Beyond a Million Tokens: Benchmarking and Enhancing Long-Term Memory in LLMs
- DiaHalu: A Dialogue-level Hallucination Evaluation Benchmark for Large Language Models
- ACON: Optimizing Context Compression for Long-horizon LLM Agents
- Enhancing Medical Dialogue Summarization: A MediExtract Distillation Framework
- FENICE: Factuality Evaluation of summarization based on Natural language Inference and Claim Extraction
- Reference Matters: Benchmarking Factual Error Correction for Dialogue Summarization with Fine-grained Evaluation Framework
- Analyzing LLM Behavior in Dialogue Summarization: Unveiling Circumstantial Hallucination Trends
- Don't Scroll Back: Missing-Evidence Memory for Streaming Dialogue Summarization
- Investigating the Representation of Open Domain Dialogue Context for Transformer Models
- TofuEval: Evaluating Hallucinations of LLMs on Topic-Focused Dialogue Summarization