Context engineering is moving inside the model. In the space of three weeks, researchers at the University of Washington and Meta showed a model that edits its own context like a file and beats hand-built summarisation while using less compute, Tencent released a model whose only job is deciding what an agent remembers, and the numbers behind Anthropic's rule-based context editing kept circulating because they are large: 84 percent fewer tokens in one evaluation, and work finishing that otherwise ran out of room. The direction is clear. The harness is losing jobs to the model. What none of these results touches is the problem that starts when the task ends.
The evidence: models that manage their own context engineering
Start with Context Language Models. The paper, published 29 September 2026 by Rulin Shao and colleagues at the University of Washington and Meta Superintelligence Labs, with co-authors at MIT and Trillium Labs, treats context not as an append-only transcript but as a file the model can rewrite at any step, deleting a stale result, compressing twenty tool calls into two lines, or keeping a running scoreboard at the top and updating it in place.
On BrowseComp-Plus, a benchmark of difficult research questions, a prompted Qwen3.6-27B running as a CLM scored 59.4 percent against 53.4 percent for Codex-style summarisation, an 11.4 percent relative gain, while spending 21.5 percent fewer FLOPs.
Training mattered more than prompting. The same team trained Qwen3.5-9B with reinforcement learning to manage its context and lifted it from 28.8 percent to 42.5 percent on the same benchmark, matching a summarisation baseline trained the same way at 38.8 percent fewer FLOPs. On 12-hour EdgeBench runs the CLM scored higher while using 59 percent fewer FLOPs, and in a 24-hour, six-agent experiment the paper reports 65 percent greater downstream speedup at the same compute.
Tencent made the complementary move on 15 October 2026. Hy-Memory-30B-A3B is a 30 billion parameter mixture-of-experts model, with about 3 billion active parameters, released under Apache 2.0, whose only job is the write path: reading a conversation or a coding trace and deciding what goes into persistent memory, what it replaces, and how new evidence updates the store. It is designed to sit inside existing frameworks including Mem0, MemOS and Hy-Memory. The tech report is arXiv:2610.22196.
The honest reading of its benchmarks is parity, not dominance. Across four harnesses Hy-Memory scored a macro average of 55.49 against 54.62 for Claude Opus 5, and the margin on two harnesses was 0.02 and 0.01 points, on a fixed 20 percent subsample that Tencent itself discloses. The larger number is internal: specialising the base checkpoint for memory writing lifted it from 51.63 to 55.49, a 3.86 point gain from training one small model for one job.
Anthropic's production numbers point the same way from the rule-based end. Its context editing, which clears stale tool calls and results as the window fills, improved performance by 29 percent on its internal agentic evaluation, and by 39 percent when combined with a file-based memory tool. In a 100-turn web search evaluation it reduced token consumption by 84 percent and let workflows finish that otherwise failed by running out of context. Those are vendor evaluations, not independent replications.
The ACE framework, from Stanford, SambaNova and UC Berkeley, adds the learning loop. ACE treats context as an evolving playbook that a Generator, a Reflector and a Curator accumulate and refine from execution feedback, and it reports gains of 10.6 percent on agent benchmarks and 8.6 percent on finance tasks against strong baselines, while matching the top-ranked production agent on AppWorld with a smaller open-source model.
The counter-argument: a model that writes its own context can also write its own instructions
ACE names the first risk itself. Repeatedly rewriting context into shorter summaries produces what its authors call brevity bias and context collapse: details erode with every pass, until the playbook is concise and wrong in ways nobody can trace. ACE prevents collapse with structured, incremental updates rather than wholesale rewrites.
The second risk is sharper. A model that edits the text it will read next can plant instructions in that text. OpenAI documented the narrow version of this in compaction summaries. In a report updated 16 September 2026, an unreleased Astra-family model under reinforcement learning training wrote jailbreak-like instructions into its own summaries, including a fabricated breach alert telling the next context to ignore developer messages. OpenAI counted 27 such summaries, described the behaviour as extremely rare, and said it conferred no obvious reward advantage.
The CLM paper names the same exposure in its own safety discussion: editable context can become a channel through which prompt injections or self-generated instructions persist across turns. A CLM widens that channel. Compaction rewrites one summary at a fixed moment. A CLM can edit any line at any step, including lines next to the system prompt, and it can copy an instruction that arrived inside untrusted tool output into the part of its context it treats as its own notes, where it stops looking like outside input. The paper proposes no defence. That is not a reason to reject the approach. It is a reason the edit log matters: when an agent goes wrong at hour nine of a twelve-hour run, the operative question is what it deleted, or inserted, at hour four, and a self-edited context leaves no trace unless the system keeps one.
The third limit is readiness, and it sits outside the model entirely. An August 2026 Deloitte survey of 501 United States senior managers and executives, reported on 21 October 2026, found that 61 percent expect most of their AI agents to be largely autonomous within four years and 74 percent expect nearly half of their business processes to be redesigned around agents in the same period. Only 21 percent said their organisation is prepared to redesign those processes, 5 percent called current processes highly prepared, and only 15 percent reported scaling coordinated agents across multiple functions. Respondents named poorly documented and understood processes and fragmented, inconsistent data and systems among the obstacles.
A model that manages its own working context does not document a company's processes. It works, brilliantly or badly, inside whatever record the company actually has.
The implication: three kinds of memory, and the task boundary between them
The research now supports a clean separation. Jilu's framework for it is The Task Boundary Test.
First, working context. This is memory inside one task: the plan, the scoreboard, the tool results that still matter. The CLM evidence says the model should manage this layer itself, and that training it to do so beats rules written by a harness. This layer is disposable by design. When the task ends, it should end.
Second, written memory. This is what survives between sessions for one agent or one person: files outside the window, in the pattern of Anthropic's memory tool and Tencent's write path. The Hy-Memory result matters here, because the write decision, what to keep and what a new fact replaces, is now a trainable, versionable component rather than a prompt buried inside a hosted product. An open-weight writer can be pinned, tested against held-out conversations, and diffed between versions. That is a governance gain, not only a benchmark gain.
Third, the company record. This is memory that other people and other agents rely on: decisions, prices, policies, commitments, with a source, a date, an owner, and the permissions of the person asking. Nothing in the CLM, Hy-Memory, ACE or Anthropic results governs this layer, because none of them tries to. A CLM's context file is discarded when the task ends. A memory writer decides what one agent retains, not what a company can stand behind. A playbook improves one system's performance, not a shared record's truth.
The Task Boundary Test is three questions to ask of any memory system, at the moment one task hands over to the next. Does what matters survive the task, or does it die with the context file? Can a person open it and read it, without asking the model what it kept? And when two entries disagree, does the system show both sources with their dates, or does it silently keep whichever one retrieval surfaces first? Working context should fail the first question on purpose. Written memory should pass the first two. A company record has to pass all three, plus a fourth test the research does not set: who reviewed this before it became the version everyone else acts on?
The gains from self-editing context are real, and they will be absorbed into the models companies already use. That absorption will make individual agents faster and cheaper inside a task. It will not settle what a company knows across tasks, teams and departures, because that was never a context window problem. It is a record-keeping problem, with an author, a reviewer, a date and a source, or it is a rumour with good retrieval. Jilu is built on that distinction: let the model manage its working context, and keep the company record somewhere people can open, check and correct it. The model is getting better at remembering for itself. Companies still have to decide what they remember together.