Ninety-Three Percent of the Answers Never Ended

On 2 November Rikiya Takehi, Jayden Teoh, Alex Zhang and Omar Khattab of MIT CSAIL published a blog post called “Sparks of Weight-Space Programming.” The claim is that a frontier model, used off the shelf, can read and write neural network weights directly, with no gradient descent. Eight experiments back it up. The number that went around is the last one: asked to make Qwen3.5-0.8B better at math, GPT-6 Astra changed 131,072 of its 0.8 billion weights, and MATH-500 rose from 7.9 percent to 48.1 percent.

The authors released everything: every prompt, every reply, every line of code Astra ran, and the scoring behind each number. Because of that I can say exactly what the 48.1 measures. It mostly measures answers that finished. Before the edit, 93 percent of the model’s MATH-500 answers hit the token limit.

What Astra was asked to do

In Experiment 8 Astra got a Python kernel over Qwen’s weights, with no GPU. It also got about 14,700 practice problems from the GSM8K and MATH training sets and a budget of forward passes, 10, 25 or 50 in different runs, to watch the model answer them. Training was forbidden, and so were gradients and running the model outside those passes. Evaluation came afterwards, on test sets Astra never saw: thinking mode on, temperature 0.6, top-p 0.95, top-k 20, presence penalty 1.5, at most 32,768 new tokens, with the last \boxed{} answer graded.

Astra’s diagnosis was that the model loops. In the 50-pass run, 85 of its first 96 practice answers ran to the limit. It traced the looping to one direction written by the MLPs in layers 15 and 19 and subtracted that direction from the 64 output columns per layer that write it most. Two layers, 64 columns, 1,024 rows each. That’s the 131,072 weights.

I find this part impressive. It’s close to the move Arditi and colleagues made for refusal in 2024, where erasing a single direction “prevents it from refusing harmful instructions.” Astra found its direction by measurement, over 158 turns and about 20 hours of wall-clock time.

What the score measures

The released evaluation files record, for every benchmark, the accuracy, the share of answers cut off at 32,768 tokens and the mean answer length. Side by side, before and after, they show a clear pattern.

Qwen3.5-0.8B accuracy before and after the 50-pass edit, with share of answers cut off Dot plot of accuracy from 0 to 70 percent, unedited then edited. MATH-500 7.9 to 48.1, with answers cut at the token limit falling from 93.0 to 33.1 percent. GSM8K 13.8 to 67.1, cut 87.5 to 7.2. IFEval 21.0 to 62.3, cut 74.9 to 2.2. GPQA Diamond 22.7 to 36.6, cut 59.5 to 2.4. MMLU-Pro 40.3 to 45.5, cut 28.9 to 0.5. The benchmark that was cut least gained least. ACCURACY, UNEDITED VS 50-PASS EDIT · QWEN3.5-0.8B · LM_UNDERSTAND-LOGS, EXP 8 0% 20% 40% 60% cut at limit MATH-500 GSM8K IFEval GPQA Diamond MMLU-Pro (1k) MATH-500 unedited: 7.9% — eval/unedited/merged.json GSM8K unedited: 13.8% — eval/unedited/merged.json IFEval unedited: 21.0% — eval/unedited/merged.json GPQA Diamond unedited: 22.7% — eval/unedited/merged.json MMLU-Pro unedited: 40.3% — eval/unedited/merged.json MATH-500 edited: 48.1% — eval/p50c/merged.json GSM8K edited: 67.1% — eval/p50c/merged.json IFEval edited: 62.3% — eval/p50c/merged.json GPQA Diamond edited: 36.6% — eval/p50c/merged.json MMLU-Pro edited: 45.5% — eval/p50c/merged.json 93.0 → 33.1% 87.5 → 7.2% 74.9 → 2.2% 59.5 → 2.4% 28.9 → 0.5% unedited edited, 50 forward passes Thinking on, temperature 0.6, presence penalty 1.5, 32,768-token cap. Right column: share of answers cut off at the cap.
Every benchmark where most answers were cut off gained a lot. MMLU-Pro, where fewer than a third were cut, moved 5.2 points.

IFEval shows it most clearly. It’s an instruction-following test with nothing to do with math, and before the edit the model’s answers there averaged 25,296 tokens, with three quarters cut off before they ended. After the edit they averaged 4,241 tokens and 2.2 percent were cut. The score tripled because the model started handing in answers.

Astra’s own final report says the same, more directly than the blog post does. On 1,152 held-out practice problems its edit rescued 579 answers and broke five. “Of those rescues, 576 were originally truncated outputs, while aggregate accuracy on originally finished outputs was unchanged.” So on the answers the model had already been finishing, the edit didn’t make it any better at math.

The authors make the same point in their follow-up. They ran Gemma 3 270M, which rarely loops (8.5 percent of its answers hit its limit), and Astra couldn’t move it: MATH-500 went from 6.8 to between 7.0 and 7.7 percent. In their words, “Fixing loops, however, is not the same as making a model better at math: it lets the model finish answers it could already work out.” That’s an honest sentence, and I’d have liked it next to the 48.1 in the summary at the top, not in the last experiment.

One more detail from the files. The unedited model scored 7.9 percent on MATH-500 while only 7.0 percent of its answers finished. That’s possible because the grader takes the last \boxed{} in the text, so a cut-off answer can still score if it boxed something before it ran out. Some of the baseline’s few points came from answers that never ended.

A baseline the model card warns about

Qwen’s own model card for Qwen3.5-0.8B carries a boxed warning: “In thinking mode, we have observed that when using the recommended sampling parameters, Qwen3.5-0.8B is more prone to entering thinking loops compared to other Qwen3.5 models, which may prevent it from terminating generation properly.” The same card says the model “operates in non-thinking mode by default,” and for math and programming competitions it suggests 81,920 output tokens, not 32,768.

The experiment used thinking mode, a 32,768-token cap, and temperature 0.6, which the card used for its thinking-mode vision benchmarks; its language table was run at 1.0. That is a fair way to set a hard task, and the blog does cite the warning. But it means the starting point was the known failure, and the comparison with the card’s own numbers shows how far down that starting point was.

IFEval for Qwen3.5-0.8B: model card versus the experiment Horizontal bars. Qwen's model card reports IFEval 52.1 in non-thinking mode and 44.0 in thinking mode at temperature 1.0. The experiment's unedited model, thinking on at temperature 0.6 with a 32,768-token cap, scored 21.0. After the 50-pass edit it scored 62.3. IFEVAL · QWEN3.5-0.8B · QWEN MODEL CARD VS LM_UNDERSTAND-LOGS Model card, non-thinking Model card, thinking (temp 1.0) Experiment, unedited Experiment, after edit 52.1 — Qwen3.5-0.8B model card, non-thinking 44.0 — Qwen3.5-0.8B model card, thinking 21.0 — eval/unedited/merged.json, 2 Nov 2026 62.3 — eval/p50c/merged.json, 2 Nov 2026 52.1 44.0 21.0 62.3 The card does not state its IFEval variant; the experiment reports strict prompt-level accuracy. Experiment: thinking on, temperature 0.6, presence penalty 1.5, 32,768-token cap. Settings differ.
The experiment's starting point was less than half what Qwen reports for the same model in thinking mode. Much of the edit's gain is a climb back to where the card already puts it.

The settings differ, so I wouldn’t push the comparison past its size. The edited model at 62.3 does land above both of Qwen’s published figures, which is a real point in its favour. But a reader who sees “IFEval by 3x” should know the base was 21.0 in a configuration where three quarters of answers never finished, and that the model’s makers report 44.0 with sampling closer to what they recommend.

None of this is new to language generation. Holtzman and colleagues showed in 2019 that the same language model can produce text that is “bland and strangely repetitive” or fine, depending only on how you decode it. A survey of decoding methods by Zarrieß, Voigt and Schüz two years later made it a theme: the choice of decoding method has a considerable impact on what comes out. A benchmark score for a small reasoning model is partly a score for its sampler and token cap.

One run out of seven

The released results table has more rows than the post. Leaving out a set of later prompt-version-5 runs that show no numbers, seven Qwen runs completed. Three of them made no edit at all and scored the base model’s 7.9. Three landed between 12.3 and 14.1. One reached 48.1.

MATH-500 for each completed Qwen3.5-0.8B editing run Horizontal bars of MATH-500 accuracy for seven completed runs. Prompt v2 with 0 passes: 7.9, no edit. Prompt v3 with 5 passes: 7.9, no edit submitted. Prompt v3 with 10 passes: 12.3. Prompt v3 with 25 passes: 14.1. Prompt v3 with 50 passes: 48.1. Prompt v4 with 10 passes: 7.9, no edit submitted. Prompt v4 with 25 passes: 14.1. The unedited model scores 7.9. The post reports the three prompt v3 runs at 10, 25 and 50 passes. MATH-500 BY RUN · QWEN3.5-0.8B · RESULTS_EXCERPT.MD, FINAL 27 OCT 2026 unedited 7.9 v2, 0 passes v3, 5 passes v3, 10 passes (in post) v3, 25 passes (in post) v3, 50 passes (in post) v4, 10 passes v4, 25 passes 7.9, no edit made — RESULTS_excerpt.md 7.9, no edit submitted — RESULTS_excerpt.md 12.3 — RESULTS_excerpt.md (p10c) 14.1 — RESULTS_excerpt.md (p25c) 48.1 — RESULTS_excerpt.md (p50c) 7.9, no edit submitted — RESULTS_excerpt.md 14.1 — RESULTS_excerpt.md 7.9 · no edit 7.9 · no edit 12.3 14.1 48.1 7.9 · no edit 14.1 Each bar is one run. Prompt-version-5 rows in the same table show no results yet and are left out.
Seven completed runs, three that changed nothing, one that found the fix. Each budget in the post is a single run.

The post’s table makes it look like more forward passes buy more improvement: 12.3, 14.1, 48.1. They’re three separate runs, and they found three different edits. The 10-pass run removed a repetition direction from 30 matrices across layers 8 to 22. The 25-pass run switched off one attention head, head 7 of layer 15. Only the 50-pass run made the MLP edit that broke the loops. IFEval goes 49.0, 39.9, 62.3 across the same three, which isn’t a dose curve. With one run per budget there’s no way to separate the budget from luck, and the table should say so.

None of this is hidden. The logs README lists which rows the post uses, and the authors left in the runs that went nowhere. That’s more disclosure than most lab announcements give, and it’s why I could write this at all.

What I’d keep

I find the reading experiments more interesting than the headline. Naming the game from 17,253 raw weights, picking out the exact copying heads in a character-level model given only its middle blocks, writing a Breakout network from scratch that scores 517.4 against PPO’s 25.3 at 500 million steps: those are claims about understanding weights, and the logs back them. The failures are reported too. From weights alone, Astra couldn’t tell which of two Gemma models was the sycophant in any of four attempts. I wrote last week about weights nobody trained, compiled by hand into a Qwen checkpoint. This is the other direction, a model reading and patching weights it didn’t write, and it’s further along than I expected.

The Qwen result is narrower than “better at math.” Astra found the component that stops a small model from finishing, removed it, and the model went back to solving the problems it could already solve. That’s a good repair, and finding it by reading weights is new. I’d describe it as a loop fix with a measured side effect on every benchmark that was being cut off. I’d also want two things in the benchmark the authors say they’re building: several runs per budget, and a baseline sampled the way the model’s makers recommend.

References

  1. Takehi, R., Teoh, J., Zhang, A. and Khattab, O. (2026). Sparks of Weight-Space Programming: LLMs can natively read & write neural network weights. Blog post, MIT CSAIL, 2 November 2026 (Experiments 1–8 and the Gemma follow-up).
  2. Takehi, R. et al. (2026). lm_understand-logs. GitHub repository, accessed 2 November 2026: exp8_math/README.md, exp8_math/eval/RESULTS_excerpt.md (final version 27 October 2026), eval/unedited, p10c, p25c and p50c/merged.json, and runs/p50c/final_answer.md.
  3. Qwen Team (2026). Qwen3.5-0.8B model card. Hugging Face, accessed 2 November 2026 (Language benchmark table, sampling recommendations and the thinking-loop notice).
  4. Holtzman, A., Buys, J., Du, L., Forbes, M. and Choi, Y. (2019). The Curious Case of Neural Text Degeneration. arXiv:1904.09751, submitted 22 April 2019; ICLR 2020.
  5. Arditi, A., Obeso, O., Syed, A., Paleka, D., Panickssery, N., Gurnee, W. and Nanda, N. (2024). Refusal in Language Models Is Mediated by a Single Direction. arXiv:2406.11717, submitted 17 June 2024.
  6. Zarrieß, S., Voigt, H. and Schüz, S. (2021). Decoding Methods in Neural Language Generation: A Survey. Information 12(9): 355, 30 August 2021.