在完成任务的同时让模型自我总结会增加学习问题的复杂性。虽然通常可以通过更多数据的训练来解决，但在现实交互环境中观察到的性能下降，很可能源于我们在有效创建和使用人类模拟器以生成高质量训练环境方面的困难（Lin et al., 2025：https://jessylin.com/2025/07/10/user-simulators-1/, Tomlin et al., 2025：https://nickatomlin.github.io/blog/user-simulators-2.html）。因此，你在有限且混乱的多轮交互轨迹上学习总结的能力越强，你的模型对下游用户就会越有利。
--> 图 2：受自编码器启发的信念评分。模型将先验信念、动作和观察（b t、a t、o t）编码为后验信念 b t+1，并根据从该信念中重构历史中所选信息的效果进行奖励。
这个设置在技术上可以用更高效的计算工具来解决，但它作为一个灵活的测试平台，用于研究递归总结的特性。Bertsimas 等人，2022：https://wordle-page.s3.amazonaws.com/assets/Wordle_Paper_Final.pdf，显示对于以 JavaScript 游戏原始词汇表实例化的 Wordle 游戏，可以通过动态规划找到精确解，但显然，将 Wordle 一般化为使用 K 个字母进行猜测的游戏，并且有 L 次尝试和某个有效词典以及正确词 D 的情况下，要确定所需的最少步数是 NP 难的。↩：#fnref:wordlehard
在实践中，总结有一个 O(N/K) 的额外开销。N 是动作的总数。K 是触发总结前的动作数。对于任何总结方法，这都是必然的。为了便于说明，这个 gif 使用 K = 1。在我们的实验中，为了更强调总结的弱点，我们也使用 K = 1。在实践中开销很小，因为 K 可以选择接近高效硬件的限制。↩：#fnref:videoabbelslow
--> Overview of ABBEL compared to traditional recursive summarization. Beliefs replace the full interaction history as the agent’s working context, and belief grading improves performance by supervising the contents of each belief state..
As task horizons grow, LLM contexts can’t scale forever. Self-summarization enables concise, interpretable contexts, but at a significant performance cost, especially for human assistance domains where high quality data is scarce, e.g., collaborative code generation. We address this with ABBEL：https://arxiv.org/abs/2512.20111: a framework that isolates and supervises the information content of summaries in the form of natural-language belief states.
For language models to effectively assist with increasingly complex tasks such as software development, they must be able to interact with us over hundreds or even thousands of steps. For such long tasks, it is impractical to keep the history of the entire interaction in context. The heuristic approach used so far has been summary generation, sometimes called context compaction. For example, Cursor’s latest model composer 2.5 uses compaction during training for improved performance (Cassano et al., 2026：https://cursor.com/blog/self-summarization). Alongside composer, Grandcode (DeepReinforce et al., 2026：https://arxiv.org/abs/2604.02721), the first system to consistently beat all human competitors in online coding competitions, despite using one of the newest efficient attention models (Qwen 3.5-397B), 1 ：#fn:efficientattn still found it necessary to employ context summarization.
But compaction has a problem. Despite seemingly low performance gaps in benchmarks, model servers like Cursor continue to recommend that users avoid compaction with their coding assistants in the middle of a task (Heule et al., 2026：https://cursor.com/blog/continually-improving-agent-harness).
To understand why, see below the performance over RL fine-tuning of a Context summary model compared to full context models in Combination Lock, a Wordle-like game that allows up to 16 guesses. 2 ：#fn:wordlehard Though both model types improve over the course of training, the summary model never closes the gap.
--> 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.
Making models self-summarize while completing a task increases the complexity of the learning problem. While this could typically be addressed by training with more data, the performance degradation observed in real world interactive settings likely arises from the difficulty we have in creating and using human simulators effectively to generate high quality training environments (Lin et al., 2025：https://jessylin.com/2025/07/10/user-simulators-1/, Tomlin et al., 2025：https://nickatomlin.github.io/blog/user-simulators-2.html). Thus, the better you can learn to summarize on the limited and messy multiturn interaction trajectories you can collect, the better off your model will be for downstream users.
--> Fig. 2: Autoencoder-inspired belief grading. The model encodes prior belief, action and observation (b t , a t , o t ) into posterior belief b t+1 and is rewarded for how well select information from the history can be reconstructed from that belief.
To address poor learning efficiency, we isolate the summary generation task. Drawing inspiration from recursive Bayesian estimation, we formulate summaries as belief states, which we periodically prompt the model to update based on new information. 3 ：#fn:videoabbelslow
We then extract and supervise the contents of the belief states (Fig. 2, Belief Grading). Belief grading can be thought of as adding an auxiliary RL task, using heuristics designed to capture what makes a good belief as the reward. An example heuristic for coding could be shorter is better, but closer to being able to reconstruct the git diff is also better, so balancing these would yield a good belief. In domains where good heuristics are hard to define, we propose a general autoencoding-inspired grading function, which treats the current language model π θ as both encoder and decoder of information from the history, and the belief states as the codes. We grade each belief b t+1 by how well it can be used by the current model π θ to reconstruct the most recent observation o t :
--> Eq. 1: Reconstruction grading objective. Here b t+1 is the updated belief, o t the latest observation, a t the action just taken, b t the prior belief, p I the task prompt, and π θ the current model. Higher grades reward beliefs that retain information needed to decode the latest observation.
We demonstrate the utility of belief grading in our motivating domain of human-driven assistive coding, with the CollabBench environment from Sweet-RL (Zhou et al., 2025：https://arxiv.org/pdf/2503.15478).
--> Fig. 4: CollabBench collaborative coding environment. The agent asks clarifying questions, then submits a function scored against hidden unit tests.
We see that with the general reconstruction-based belief grading function we reduce the performance gap from full context models by about 50%, and train in 50% fewer steps compared to training models to summarize without belief grading (no BG). After training, ABBEL still uses significantly less memory than the full context setting, as measured by the peak context token length (Peak Tokens).
Additionally, in CombinationLock, we demonstrate that ABBEL with a belief grader which leverages domain knowledge (by computing useful statistics over the history and checking that they can be reconstructed from the belief state), enables even higher learning efficiency than full context (FULL CTX) models.
--> 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.
In a third environment, multi-objective question answering (from MEM1 Zhang et al., 2025：https://arxiv.org/pdf/2512.24601, a recent work which performed end-to-end optimization in a modified version of typical recursive summarization), we demonstrate the utility of isolating belief states from reasoning, by showing that a Peak Belief length Penalty (more details in paper) significantly reduces memory usage with minimal performance degradation, unlike is commonly observed when penalizing reasoning lengths (Arora et al., 2025：https://proceedings.neurips.cc/paper_files/paper/2025/file/579b5b84311e122584dedab1d3b7613f-Paper-Conference.pdf).
--> 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.
Many more possibilities are enabled through using explicit belief states as information bottlenecks for multi-step interaction. You could reward actions based on their effect on the belief state to guide exploration, transmit the explicit belief states for better communication between agents, or even improve user controllability by directly modifying the memories on which the agents’ decisions are based.
Some forms of information, e.g., what a person looks like, are not represented well by text alone. A continuously learning system will also have to capture such information. Additionally, if we want a system to learn to communicate in a brand new language or to play a brand new game better than any person in the world, the skills accumulated over the lifetime of conversations or games must be stored in a very compressed form, essentially taking on the role of the weights of the model itself.
More powerful systems will likely utilize a combination of multiple forms of memory, where the contents of the context may correspond to working memory while other approaches are used for short and long-term memory. How to instantiate these other forms of memory, for instance via test-time training, adapter memories, continuous context memories, or some combination thereof, presents an exciting challenge.
If abbel was inspiring for your future work, please cite us with this! And here is some advice：https://jakob-bjorner.github.io/abbel-advice.html for doing similar research!
With newer models the number of tokens till 50% compute spend is on attention gets much larger than 25K. Interleaving linear attention alternatives with full attention as is done with gpt-oss and DeepSeekv4, results in massive flops reductions for the attention computation. For example with DeepSeekv4-Pro (1.6T A49B) it requires nearly 450 thousand tokens to reach the 50% tradeoff point. Grandcode uses Qwen-3.5-397B-A17B a model which hits 50% FLOPs for attention at ~150 thousand tokens. ↩：#fnref:efficientattn
This setting is technically solvable with much more computationally effective tools, but serves as a flexible test bed to study properties of recursive summarization. Bertsimas et al., 2022：https://wordle-page.s3.amazonaws.com/assets/Wordle_Paper_Final.pdf, showed that an exact solution for the wordle game instantiated with the original vocabulary of the javascript game can be found with dynamic programming, but evidently the general formulation of wordle as a guessing game on K letters with L attempts and some dictionary of valid words and correct words D is NP hard to determine the minimal number of moves required. ↩：#fnref:wordlehard
In practice there is an O(N/K) overhead cost for summary. N is the total number of actions. K is the number of actions till summarization is triggered. This is necessarily true for any summary approach. For ease of illustration this gif uses K = 1. In our experiments, to put more emphasis on summarization weaknesses we also use K=1. In practice overhead is small as K can be chosen to be near the efficient hardware limit. ↩：#fnref:videoabbelslow
扫码直达文章详情