Context Language Models Let Agents Rewrite Their Own Working Memory—With New Failure Modes

A research team from the University of Washington, Meta Superintelligence Labs, MIT, and Trillium Labs has proposed a different answer to one of the least glamorous problems in agent engineering: what should remain in the prompt after a task has run for hours?

Their Context Language Models, or CLMs, treat the live context as an editable file. Instead of accepting a fixed harness rule—summarize after a threshold, keep the last several turns, or retrieve selected notes—the model can rewrite the material that will condition its next step. The official repository was created on September 18 and had 371 GitHub stars and 45 forks when checked at 1:08 p.m. Malaysia time on October 2. GeekNews surfaced the work on October 2; the linked Hacker News submission had only two points and no comments at the same check, so public reaction remains an early signal rather than validation.

What happened

Most agent loops append new observations until the context approaches a limit. A harness then compresses or removes material according to a policy chosen by the developer. CLMs move more of that policy into the model’s action space. The implementation mirrors context into a file and synchronizes the model’s edits back into the next request.

That simple mechanism supports several behaviors without changing model weights. The paper reports agents creating working notes, deleting irrelevant search output, compacting earlier turns, and maintaining partial state. Multiple context files can also represent multiple agents. The model can decide what to preserve verbatim, what to summarize, and what to move outside the active window.

The project includes a Harbor-based harness, code for in-context skill optimization and reinforcement learning, and an experimental serving technique called Suffix Cache Reuse. The repository is licensed CC BY-NC 4.0, which is important for teams evaluating commercial reuse; it is not a permissive production license.

Why it matters

Long tasks fail for reasons that benchmark leaderboards often hide. The model may forget an acceptance criterion, retain a misleading observation, repeatedly re-read a large log, or allow a stale plan to crowd out the latest evidence. A larger context window delays those failures but does not choose what deserves attention.

Editable context turns memory management into work the agent can reason about. That can be useful when the correct policy depends on the task. A debugging session may need exact error lines and a compact history of failed hypotheses. A research task may need source provenance and unresolved questions. A multi-repository optimization may need a shared scorecard rather than full transcripts from every worker.

The approach also makes agent behavior easier to inspect than hidden recurrent memory. Engineers can diff a context file, measure when the agent compacts it, and test whether a crucial constraint survives. That visibility does not make the edits correct, but it provides an artifact for evaluation.

Evidence

The authors report that a zero-shot CLM using Qwen3.6-27B reached 59.4 percent accuracy on BrowseComp-Plus, described as an 11.4 percent relative improvement over their strongest comparison while using 21.5 percent fewer prefix-reuse FLOPs. On TerminalBench 2.1, the CLM reportedly matched the strongest summarization baseline while reducing measured FLOPs by 29.5 percent. On TBLite, the reported score rose from 67.0 to 73.7 with slightly lower compute.

The paper also evaluates optimization tasks lasting up to twelve or twenty-four hours. Its headline claim for a multi-repository agent swarm is 65 percent greater improvement at the same compute. That wording matters: it is not a claim that the software itself ran 65 percent faster. It is a comparison of improvement under the authors’ experimental setup.

Reinforcement learning produced another result. The reported Qwen3.5-9B BrowseComp-Plus accuracy rose from 28.8 to 42.5 percent while per-question compute fell. The authors condition their efficiency reward on successful runs to reduce incentives for simply deleting context or stopping early.

These are primary-source results. The code is public, but independent replications across other models, workloads, serving stacks, and budgets were not available at publication time.

Practical takeaway

Teams should test the idea as a memory policy, not install it as a universal upgrade. Start with a task where failure is measurable and where the required facts are known. Log every context edit. Add invariants for material that must not be deleted, including user constraints, tool permissions, source citations, and the definition of done.

Compare at least three baselines: no compaction, a fixed summary policy, and model-directed editing. Measure success rate, total model and tool cost, elapsed time, and recovery from misleading observations. Token counts alone are insufficient because editing the middle of a prompt can invalidate prefix caches.

For regulated or high-impact work, keep an immutable transcript beside the editable working context. The editable file should be treated like a cache or working notebook, not the authoritative record.

Limitations

The strongest concern is persistent prompt injection. If an untrusted instruction reaches editable memory, the model may preserve or strengthen it across many turns. A model can also delete a constraint it finds inconvenient, convert uncertainty into an apparently settled note, or compress away the provenance needed to challenge a conclusion.

Suffix Cache Reuse introduces a separate systems question. Reusing cached representations after middle-of-context edits is not equivalent to recomputing the entire sequence. The authors report equal accuracy in one BrowseComp-Plus experiment, but that result does not prove equivalence across models or tasks.

Finally, the benchmarks reward bounded outcomes. Production agents also face permissions, changing external state, partial failures, and human review. CLMs offer a promising mechanism for working memory. They do not by themselves provide durable execution, authorization, or truth.