Recursive summarisation degrades performance in long-horizon tasks. Berkeley researchers have released ABBEL, a framework that treats summaries as natural-language belief states and supervises their content. This approach reduces the gap between summarised and full-context models while cutting training steps and memory usage.
Motivation: the cost of recursive summarisation
Language models assisting with complex tasks like software development must interact over hundreds or thousands of steps. Keeping the entire history in context becomes impractical. The standard workaround is summary generation, or context compaction. Cursor’s Composer 2.5 uses compaction during training, and Grandcode, a system that consistently beats human competitors in online coding competitions, also relies on it despite using efficient attention models.
However, model servers like Cursor recommend against using compaction during active tasks. Performance gaps in benchmarks often appear negligible, but real-world results differ.
Testing on Combination Lock, a Wordle-like game allowing up to 16 guesses, shows the issue clearly. A model trained to summarise itself never closes the performance gap compared to a full-context model, even after reinforcement learning fine-tuning.
Fig. 1: Average attempts to guess the target word on Combination Lock over RL fine-tuning (lower is better). Context-summary policies improve with training but do not close the gap to full-context policies.
Self-summarisation increases learning complexity. Addressing this usually requires more data, but creating high-quality human simulators for training environments remains difficult. Models must learn to summarise effectively from limited, messy interaction trajectories to benefit downstream users.
ABBEL: acting through belief bottlenecks
To improve learning efficiency, the team isolates the summary generation task. Drawing on recursive Bayesian estimation, they formulate summaries as belief states that the model updates periodically based on new information.
Fig. 3: ABBEL rollout. Belief updates from the latest observation alternate with action selection conditioned only on the current posterior belief.
Belief grading
The framework extracts and supervises the contents of these belief states. This acts as an auxiliary reinforcement learning task, using heuristics to define a good belief. For coding, a shorter belief is better, but one that allows reconstruction of the git diff is also better. Balancing these factors yields a useful summary.
Where heuristics are hard to define, the team proposes an autoencoding-inspired grading function. This treats the current language model as both encoder and decoder of information from the history, with belief states serving as the codes. Each belief is graded by how well it allows the model to reconstruct the most recent observation.
Eq. 1: Reconstruction grading objective. Here bt+1 is the updated belief, ot the latest observation, at the action just taken, bt the prior belief, pI the task prompt, and πθ the current model. Higher grades reward beliefs that retain information needed to decode the latest observation.
What do we gain by grading beliefs?
Collaborative coding on CollabBench
The team demonstrates belief grading in human-driven assistive coding using the CollabBench environment. Here, an agent asks clarifying questions before submitting a function scored against hidden unit tests.
Fig. 4: CollabBench collaborative coding environment. The agent asks clarifying questions, then submits a function scored against hidden unit tests.
Using the general reconstruction-based belief grading function, the researchers reduced the performance gap from full-context models by about 50%. Training required 50% fewer steps compared to models summarising without belief grading. After training, ABBEL still used significantly less memory than the full-context setting, measured by peak context token length.
| Model | Test Pass Rate ↑ | Success Rate ↑ | Peak Tokens × 10² ↓ | Training Steps ↓ |
|---|---|---|---|---|
| Full Context | 0.52±0.02 | 0.39±0.02 | 14.08±0.55 | 100 |
| ABBEL (no BG) | 0.46±0.02 | 0.31±0.02 | 4.20±0.37 | 100 |
| ABBEL-rec-BG | 0.48±0.01 | 0.36±0.01 | 6.01±0.33 | 50 |
Fig. 5: CollabBench results. With reconstruction belief grading, ABBEL-rec-BG recovers about half the gap to full context while using fewer peak tokens, and trains in 50 steps instead of 100.
Combination Lock
In Combination Lock, ABBEL with a belief grader leveraging domain knowledge enabled higher learning efficiency than full-context models. This grader computed useful statistics over the history and checked that they could be reconstructed from the belief state.
Fig. 6: Average attempts to guess the target word on Combination Lock (lower is better). With domain-knowledge belief grading, ABBEL approaches or exceeds FULL CTX in this setting; without belief grading, learning is slower.
Multi-objective question answering
In a third environment, multi-objective question answering, the team showed the utility of isolating belief states from reasoning. A Peak Belief length Penalty significantly reduced memory usage with minimal performance degradation. This contrasts with penalising reasoning lengths, which commonly causes performance drops.
Fig. 7: Exact-match score and peak memory versus number of objectives in multi-objective QA. ABBEL with a peak belief penalty (PBP) maintains comparable performance while using less memory than MEM1 and ABBEL without PBP in this evaluation.
What it means
For developers building agents that work over long periods, ABBEL offers a way to manage context without sacrificing performance. By grading summaries to ensure they retain necessary information, the method cuts training time and memory load. This could make long-horizon tasks more viable for models with limited context windows.
