Context Language Models: A New Way for LLMs to Manage Their Context

A new paper from researchers at the University of Washington and Meta proposes that language models should edit their own context directly instead of relying on separate software to summarize or shorten it. The work, titled “Context Language Models” (CLMs) and posted to arXiv on September 29, 2026, reports better accuracy while using less computing power on long-running agent tasks. The idea is important because managing context has become a major source of cost and reliability problems for coding and research agents.

The figures come from the authors and have not yet been confirmed by outside researchers. Even so, they point to a broader shift in agent design: instead of keeping a growing record of everything that happened, future agents may choose for themselves which information to keep and which to remove.

What the paper proposes

The paper's abstract, by Rulin Shao and colleagues including Luke Zettlemoyer, Mike Lewis, Wen-tau Yih and Pang Wei Koh, describes CLMs as language models that “natively manage their own context.” The basic idea is straightforward. Instead of treating context as a record that only gets longer, the system gives the model an editable file containing that context. According to the full text, the file path is included in the system prompt, and the model can change the file using ordinary Bash commands. After each edit, the updated file is reflected in the model’s active context before the next turn.

The paper contrasts this with the usual approach, where the model’s context simply grows as new outputs are added. In a CLM, the model can actively rewrite that context instead. It can delete an outdated search result, update a plan, or turn a long sequence of tool calls into a short summary.

The same idea can also be used with multiple agents. Each agent keeps its own context in a separate file, and several of those files can stay synchronized at the same time. The authors say this could support systems where multiple agents work together or where a main agent coordinates smaller subagents.

How it was evaluated

The authors test the idea in three ways. First, a zero-shot setting uses existing models without modifying them; the paper names Qwen3.6-27B and GPT-5.6-Sol. Second, an in-context learning setting guides context management through natural-language instructions or evolved skill documents. Third, a reinforcement learning setting trains the behavior directly, using stepwise GRPO with what the paper calls a success-gated efficiency advantage. In practice, the reward gives credit for lower inference cost only when a task is completed successfully. That is meant to prevent the model from making unnecessary edits simply to earn an efficiency bonus.

The baselines include Codex-style summarization, MEM1, Self-Compact, ACM, and recursive language models, all run on the same Mini-SWE-Agent infrastructure. The evaluation covers a wide range of tasks. ContextBench includes four diagnostic tests: Needle Retention, Sudoku Sketchpad, KV Store, and Log Triage. These are designed to separate context management from general reasoning. The authors also use TerminalBench 2.1 and TBLite for coding, BrowseComp-Plus for deep research, EdgeBench-10 for a 12-hour repository optimization task, and Software World for a 24-hour multi-repository task carried out by an agent swarm.

The reported results

According to the authors, zero-shot CLMs achieve 11.4% higher accuracy with 21.5% fewer compute operations on BrowseComp-Plus. On the 12-hour EdgeBench task, they report scores that are 5% higher while using 59% fewer operations. For the 24-hour multi-repository task, the authors report a 65% greater improvement at the same compute level. After reinforcement learning, they report a 47.6% performance gain on BrowseComp-Plus while reducing operations by 12%. A separate serving optimization called Suffix Cache Reuse is credited with cutting server-side compute by a further 35%.

These are comparisons against the authors' chosen baselines on their chosen setups. The abstract does not say whether the percentage gains are relative or absolute, and readers should check the tables in the paper before comparing them with other agent results.

Why it matters for agent builders

Long-running agents can spend a large part of their computing budget repeatedly reading context that is outdated, duplicated, or no longer useful. Today, the usual solution sits outside the model: separate software decides when to summarize information, what to remove, and how to restore earlier state. The weakness is that these rules are set in advance by engineers rather than adapted to the specific task or model.

CLMs move that decision into the model itself. If the approach holds up, it could offer two practical benefits. The first is lower cost, because fewer tokens and fewer operations need to be carried through long-running tasks. The second is flexibility: because context editing becomes part of the model's own behavior, developers can guide it with plain-language instructions or improve it through reinforcement learning, as the paper's three evaluation settings show.

The zero-shot result is especially notable because the method can work with existing models without retraining them. In principle, teams running agents today could test the approach simply by giving the model access to an editable context file and command-line tools. The paper's strongest results, however, come from the version trained with reinforcement learning.

Caveats and open questions

The authors also flag a security risk. Editable context gives prompt injection another way to affect the agent: a model could write unauthorized instructions into its own summaries, and those instructions could influence what it does later. The paper calls for future safeguards that allow context editing without letting harmful instructions persist.

For agents that read untrusted web pages or code repositories, this is a serious concern. A malicious instruction saved into the context could remain active throughout a 12- or 24-hour task, making it harder to detect than a single bad tool response.

There are also limits to what can be concluded so far. The results come from a relatively small set of benchmarks, several of which are long-running and expensive to repeat. The accompanying code repository from Meta's research group includes Harbor integration, in-context learning tools, and reinforcement learning code, and can work with models through OpenAI-compatible APIs. However, it is licensed under CC BY-NC 4.0, which allows research use but restricts commercial use, and the README says ContextBench is "coming soon." Until that evaluation suite is released, outside researchers cannot fully reproduce or verify the paper's diagnostic results.

What to watch next

Several developments will show whether CLMs become a widely used approach or remain mainly a research idea. First, independent researchers need to repeat the BrowseComp-Plus and terminal-coding tests, ideally with different model families. That would show whether the reported gains also appear beyond the models used in the paper. Second, releasing ContextBench would allow other teams to test context management separately from a model's general reasoning ability.

Third is security. If agent frameworks adopt model-editable context, they will need ways to record changes, compare versions, and limit what the model is allowed to edit. That would let reviewers see what information the model chose to keep, change, or remove. The paper itself presents this as the main unresolved issue.

Fourth is licensing. The reference code uses a non-commercial license, which may slow adoption by companies. The underlying idea of storing context in an editable file is simple enough, however, that other teams could build their own versions.

For now, the paper should be treated as a promising proposal with results reported by the authors, rather than a settled finding. Its main idea is to make context something the model can actively edit, not just information it passively receives. That approach could influence how agent systems are designed in the coming months.