In the authors’ test, a model that could edit its own context scored 59.4 instead of 53.4, while using 21.5% fewer flops. The model did better while doing less work. Letting it rewrite what it sees, though, creates work for the server and a risk if the wrong instructions stay in context.
A conversation the model can rewrite
Context language models, or CLMs, treat a conversation as a file they can edit. A CLM can remove material it no longer needs, then see the edited version on its next turn.
The paper gives a concrete example. One model wrote a helper function and called it 37 times. It also updated an agent status scoreboard 163 times while keeping its context at 6 to 8,000 tokens. The edits let it keep working from a changing version of the conversation.
The authors tested Quinn 3.6, a 27 billion parameter open model. On Browse Comp Plus Plus, the CLM scored 59.4, against 53.4 for Codec-style summarization. The authors report that as an 11.4% relative gain with 21.5% fewer flops.
The advantage was narrower on a 12-hour Edgebench subset: 44.6 versus 42.3. After reinforcement learning, the scores were closer still, at 42.5 for the CLM and 42.1 for the summary harness. In that trained comparison, the CLM used 1.34 quadrillion flops per question, against 2.19 quadrillion. These are the authors’ measurements, and the size of the score gain changed between tests.
An edit can make the server redo work
Servers usually reuse work done on the unchanged start of a conversation. Editing the middle disrupts that: SGLang recomputes everything after the edit.
The paper’s suffix cache reused tokens that survived the edit. On Browse Comp Plus, it matched performance at 65% of SGLang’s compute. That matters to the result because a model that saves compute while answering can still create extra work when its edited context is served.
There is also the content of the edit to consider. The authors warn that prompt injections or instructions written by the model itself could persist across turns. The measured gains sit alongside that warning: what the model chooses to keep may be there when it continues working.
The fastest generation result depended on lookup
Hyperquinn’s author measured 381 tokens per second with lookup on a 25,000-token prompt. Without lookup, the result was 159. For free-form writing, it was around 70.
A small drafter guesses a block of text, and the larger model checks it. Lookup searches the prompt for a match and offers the text that followed as the next guess. Wrong guesses get discarded.
In the fast test, the next words were often already in the prompt. So 381 tokens per second was the author’s best case for that kind of task, not a general writing speed. The workload changes what that speed number means, just as the benchmark changes how large the CLM’s score gain looks.
The local coding comparison has an unmeasured step
OpenAI halved the allowance for new subscribers to its $200 ChatGPT Pro plan on September 29th. Codex and ChatGPT work went from 20 times Plus to 10 times, and GPT-6 Pro chat messages fell from 200 to 100 a week. Existing subscribers move to the new limits on October 29th and get a one-time $2,500 credit that expires on December 31st.
That prompted a comparison with a $3,799 M5 Max Mac Studio with 64 GB of memory. There is no measured speed for that proposed Studio here. The measured result came from Hardware Corner: 6-bit Qwen 3.5 27B ran at 23.6 tokens per second on a 128 GB M5 Max MacBook Pro.
The local range in this comparison is the 27 to 35 billion parameter class. The larger models cited exceed 64 GB, and there is no same-task comparison between those local models and Astra. The speaker estimates a 19-month payback against the $200 plan before electricity, or roughly 20 months with the stated electricity assumption. That estimate depends on a local model handling the user’s actual work.