Qwen Wouldn't Stop Rambling: GPT-6 Astra Tweaked 0.016% of Its Weights

In short

• Four researchers at MIT CSAIL (MIT's computer science and AI lab) asked GPT-6 Astra, an OpenAI model according to their logs, to make another model, the small Qwen3.5-0.8B, better at math by directly editing its weights, with no training.
• Astra changed 131,072 weights out of 0.8 billion, or 0.016%: Qwen's share of correct answers on the MATH-500 math test goes from 7.9% to 48.1%, by the authors' measurement. A second measurement, run by Ahsen Khaliq of Hugging Face (the big platform for sharing models), gives 51.0%.
• This is a blog post, and I found no matching scientific paper on arXiv. On the other hand, the full logs, the exact edit and the modified model are published.

In plain words: an AI that tweaks another AI

I started with the post, then opened the experiment logs, because a headline saying "large language models can natively read and write the weights of neural networks" deserves a check of the plumbing.

A language model is an immense table of numbers: the weights. Qwen3.5-0.8B, a small open-weights model (under the Apache 2.0 license, downloadable by anyone), has 0.8 billion of them, spread over 24 layers, the successive floors of the computation.

Normally, nobody picks these numbers one by one. They are trained: a program shows the model thousands of examples, measures its mistakes, then computes, for each weight, which way to nudge it to be a bit less wrong. That computation is called the gradient, and it gets redone thousands of times. Here, that was off limits: no gradient, no training, no program that adjusts the weights on its own through trial and error. Astra had to understand what each piece of the network computed, then change the numbers itself, by reasoning. The authors call this "weight-space programming".

To work, Astra had a Python (a programming language) session open on the weights, no graphics card, and 14,744 training problems drawn from two math collections. There were three separate attempts, with a budget of 10, 25 or 50 "passes": at each pass, Qwen answered up to 512 of those problems and Astra saw the result.

What Astra found: Qwen loops. Of its first 96 answers to training problems, 85 ran all the way to the 32,768-token limit (tokens are the word fragments the model produces). Qwen's official model card even warns that with the recommended settings, this model, in thinking mode (when it reasons in writing before answering), falls into loops more easily than the other Qwen3.5 models. Astra traced these loops back to one specific signal, written by two layers (15 and 19), and removed it from the 64 weight columns that write it the most in each. That's my simplified version; the authors talk about a "direction" removed from the weights.

To see these loops with my own eyes, I dug through the logs, and a warning: the example below is picked on purpose. Of the 50 problems in the first batch I downloaded, it's one of only two where Qwen goes from 0 to 4 correct answers out of 4; it is not an average case. The problem: a regular hexagon has sides of 16 cm; a regular octagon has the same perimeter; how long is its side?

• Before: 0 correct answers out of 4 tries. In the first one, Qwen writes the same sentence ("Wait, dir(360) is 0.") 1,666 times, the last 1,657 of them in a row, one line after another. Then the text stops dead, mid-sentence, with no answer.
• After: 4 out of 4. The hexagon's perimeter is 6 × 16 = 96 cm, divided by 8 sides: 12 cm.

If you're wondering what the edit taught Qwen: nothing new, say the authors. It lets the model finish answers it already knew how to find.

The numbers and their limits

0.016% of the weights. 131,072 weights changed out of 0.8 billion: roughly one weight in 6,100. Two blocks of numbers modified, everything else intact.

MATH-500: from 7.9% to 48.1%. MATH-500 is a selection of 500 written-out math problems, pulled by OpenAI from a large collection called MATH; in the logs, you find algebra, geometry, probability and number theory. The score is the share of correct answers, averaged over 4 tries per problem: roughly the equivalent of 40 problems solved out of 500 before, 240 after. This result was obtained with the maximum budget of 50 passes: with 10 or 25 passes, the score only climbs to 12.3% and 14.1%. And the share of answers cut off at the limit falls from 93% to 33%.

IFEval: from 21.0% to 62.3%, almost three times as much. IFEval (short for "instruction-following evaluation") measures whether the model follows instructions that a program can check on its own, like "write more than 400 words" or "mention a given keyword at least 3 times". Here, a request only counts as passed if all of its instructions are followed. Out of 541 requests, that's about 114 passed before, 337 after. Astra never saw this test; for the authors, the loops aren't specific to math, hence progress elsewhere too.

Another math test, GSM8K (for "grade school math," a collection of about 8,500 small word problems, solved in 2 to 8 simple calculations): on the 1,319 problems used here, the share of correct answers goes from 13.8% to 67.1%.

A second measurement. The 48.1% comes from the authors, with their own evaluation files. Ahsen Khaliq of Hugging Face, thanked in the post, rebuilt the modified model from the logs and re-ran the full MATH-500 with the same protocol: 51.0% correct answers. His result is published on the modified model's page, which presents it as an independent re-measurement. It's not a scientific peer review, but the two measurements are in the same ballpark.

The context, honestly. Eight experiments in all, plus one additional experiment. The first seven involve much smaller networks: simplified video games (17,253 weights), Go on a 9 × 9 board (1.5 million weights), mini language models, up to Gemma 3 270M. Number 8, the math one, is the biggest, and 0.8 billion weights is still a small model. It's a blog post: its own citation card says so. I found no paper on arXiv, the site where researchers post their work: nothing under this title, nothing on this topic among the first author's five latest submissions.

What the authors say themselves:

• fixing loops is not the same as making a model better at math: it lets the model finish answers it already knew how to find;
• on Gemma 3 270M, a model that rarely loops, Astra improved nothing: no edit moved MATH-500 by more than about a point;
• editing weights can remove an obstacle that hid an ability, not add an ability that's missing;
• the capabilities are "still limited," held back by the size of the models' working memory and by the tools around them;
• in experiment 7, Astra could not tell, from the weights alone, which of two models was sycophantic (trained to echo the answer suggested by the user); it only got there by watching how the two models behaved on texts it had written.

My take, and I own it: the starting point is weak. 7.9% is a model choking on its own loops. Its card even recommends adjusting the settings when it loops, and the authors kept the same settings before and after. To me, the real feat isn't the score; it's that an AI found the fault in another AI's numbers and explained it.

What we don't know yet

• The cost: the 50-pass run took 20.3 hours, including 4.7 hours of waiting. No usage price for Astra is given.
• Big models: the post shows no test beyond 0.8 billion weights.
• Peer review: for now, a blog post, and no paper found on arXiv on 03/11. The authors announce a dedicated benchmark, not yet published.

Key terms

• Weights (or parameters): the numbers that make up a model and decide what it writes.
• Training, gradient: the usual method for setting the weights, correcting them bit by bit based on mistakes on examples.
• Token: a word fragment; the 32,768-token limit sets the maximum length of an answer.
• Pass: here, a batch of Qwen's answers to training problems, which Astra could observe.
• MATH-500, GSM8K, IFEval: three tests; the first two count math problems solved, the third counts instructions followed.
• MIT CSAIL: MIT's computer science and artificial intelligence lab, where the four authors work.

About the source

• Who: Rikiya Takehi, Jayden Teoh, Alex Zhang and Omar Khattab, MIT CSAIL.
• Date: November 2, 2026 according to the post; the time isn't indicated.
• Links: the post · the experiment logs · the modified model · the Qwen3.5-0.8B model card

Source passages

Pages and files read on 03/11/2026 between 08:38 and 08:45 UTC.

Show the 10 sources

Ref.	Quote (original language)	URL
S1↑1↑2↑3↑4↑5↑6+22	"Published" ; "November 2, 2026" ; "MIT CSAIL" ; "fixes this by natively editing 0.016% of the weights. With the same sampling settings, this weight correction raises MATH-500 from 7.9% to 48.1%" ; "All of this is possible without allowing Astra to write training loops." ; "Model: Qwen3.5-0.8B, thinking on (24 layers, 0.8 billion weights)" ; "85 of its first 96 practice answers ran to the 32,768-token limit" ; "subtracted that direction from 64 output columns in each (131,072 weights)" ; "IFEval, which measures instruction following, rose from 21.0% to 62.3%" ; "GSM8K from 13.8% to 67.1%" ; table: 10 passes 12.3, 25 passes 14.1, limit reached 93.0 → 33.1 ; "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." ; "Editing weights could remove an obstacle that hid an ability, but it could not add an ability the model lacked." ; "none moved MATH-500 by more than about a point" ; "capabilities are exciting but still limited, specifically due to inefficiencies in context length and harnesses" ; "from the weights alone, Astra was unable to tell" ; "MLP 500 → 32 → 32 → 5, tanh (17,253 weights)" ; "1,480,274 weights" ; "Game: Go on a 9×9 board" ; "We are currently building a benchmark and a harness" ; "With 50 forward passes, MATH-500 rose from 7.9% to 48.1%" ; "The loops are not special to math, so performance beyond math improved as well" ; "Given this, Astra was able to pick out the sycophant in all three sets of pairs we trained." ; "We thank Ahsen Khaliq at Hugging Face for rebuilding it from these logs, re-running its evaluation, and making a live demo." ; "{Blog post}"	https://rikiyat.github.io/blog/weight-space-programming/
S2↑1↑2↑3	"license: apache-2.0" ; "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" ; "We recommend further tuning the sampling parameters specific to your use case"	https://huggingface.co/Qwen/Qwen3.5-0.8B/blob/main/README.md
S3↑1↑2	"\"Astra\" in the post is OpenAI's gpt-6-astra." ; "Every turn is one call of the Codex CLI" ; "All 1,125 turns in this release are tool-free."	https://github.com/RikiyaT/lm_understand-logs
S4↑1↑2↑3↑4↑5↑6+3	"gradient descent or any training (no backward passes, autograd, optimizers or iterative fitting of weights to a loss)" ; "a persistent Python kernel over the weights (CPU only, no GPU, no internet)" ; "7,469 from GSM8K train, 7,275 from MATH train" ; "answers up to 512 practice problems" ; "subtracts the loop direction from the 64 output columns per layer of the MLPs of layers 15 and 19 that write it most" ; table, row p50c: 158 turns, 20.3 hours ; "4.7 hours at turn 154 when the model could not be reached" ; "Samples per problem: MATH-500 4" ; "IFEval (strict prompt-level accuracy with the official checkers" ; "Table, 50 passes" → "48.1 / 67.1 / 62.3 / 33.1" → "eval/p50c/merged.json" ; "It never saw the benchmarks." ; merged.json: math500 "problems": 500, ifeval 541, gsm8k 1319	https://github.com/RikiyaT/lm_understand-logs/tree/main/exp8_math
S5↑1↑2	Problem test/prealgebra/930: base model "correct": [0, 0, 0, 0], 1st try without \boxed, sentence "Wait, dir(360) is 0." appears 1,666 times, including 1,657 consecutive lines at the end (checker count), text cut off at "Wait, `dir" ; of the 50 problems in the math500_s0of10 batch, only two go from [0, 0, 0, 0] to [1, 1, 1, 1] (test/prealgebra/930 and test/precalculus/625) ; batch categories: prealgebra, algebra, intermediate_algebra, geometry, counting_and_probability, number_theory, precalculus ; modified model (50 passes) "correct": [1, 1, 1, 1], "$$8 \times s = 96$$" ; "\boxed{12 \text{ cm}}"	https://github.com/RikiyaT/lm_understand-logs/tree/main/exp8_math/eval
S6↑1↑2↑3↑4↑5	"Independent re-run of this checkpoint:" ; "full MATH-500, 500 problems × 4 samples" ; "The edited model scored" ; "51.0%" ; "Only these two tensors differ from Qwen/Qwen3.5-0.8B" ; "This checkpoint and the re-run above were built by akhaliq" ; "with the post's protocol" ; "We thank Ahsen Khaliq at Hugging Face for rebuilding it from these logs, re-running its evaluation" (post)	https://huggingface.co/RikiyaT/Qwen3.5-0.8B-weight-space-programming
S7↑1↑2↑3	arXiv search by title "Weight-Space Programming": "<opensearch:totalResults>0" ; author search "Takehi": none of the 5 latest papers on this topic (03/11/2026, 08:39 UTC)	https://export.arxiv.org/api/query?search_query=ti:%22Weight-Space%20Programming%22
S8↑1↑2	"This dataset contains a subset of 500 problems from the MATH benchmark that OpenAI created in their _Let's Verify Step by Step_ paper."	https://huggingface.co/datasets/HuggingFaceH4/MATH-500
S9↑1↑2	"It contains around 500 \"verifiable instructions\" such as \"write in more than 400 words\" and \"mention the keyword of AI at least 3 times\" which can be verified by heuristics."	https://huggingface.co/datasets/google/IFEval
S10↑1↑2	"GSM8K (Grade School Math 8K) is a dataset of 8.5K high quality linguistically diverse grade school math word problems." ; "These problems take between 2 and 8 steps to solve." ; "Solutions primarily involve performing a sequence of elementary calculations using basic arithmetic operations"	https://huggingface.co/datasets/openai/gsm8k