On November 2, four researchers at MIT CSAIL published a blog post claiming that OpenAI's GPT-6 Astra read the raw weights of Qwen3.5-0.8B, found the cause of its reasoning loops, and fixed it by editing 0.016% of the parameters. No gradients. No training run. MATH-500 went from 7.9% to 48.1%. The post hit the top of Hacker News with 2,605 points and 793 comments, and the phrase "weight-space programming" was everywhere by Monday night.
I read the whole thing, the logs, and the critiques. The headline number is real and the method is new. The claim people are repeating about it is wrong.
What the paper says it did
The post, by Rikiya Takehi, Jayden Teoh, Alex Zhang, and Omar Khattab, is a set of eight experiments, and most of them are small. Astra looked at a 17,253-weight MLP trained with PPO and named which of four grid games it played, four for four. It looked at the middle four blocks of a 7.16 million weight character-level transformer, with no embedding or output layers and no ability to run it, and named the training language (Python, romaji Japanese, or English) every time. It also pointed at every induction head in those models and no others.
Then it wrote networks. Given the rules and source code of three MinAtar games, Astra wrote the weights of a 600→32→32→6 network as text in a single reply, with no tool calls and no testing before scoring. Its Breakout network scored 517.4. PPO got 25.3 after 500 million steps. On Seaquest and Asterix it roughly matched PPO at 500 million steps. For 9×9 Go it was given a Python sandbox, wrote a 1.48 million weight network layer by layer, and with a budget of 50 forward passes beat a PPO network of the same size that had trained on 20 million games.
The Qwen experiment is the one in the headlines. Qwen3.5-0.8B with thinking on hit the token limit on 93% of MATH-500 problems because it looped. Astra traced the looping to one direction written by the MLPs in layers 15 and 19, subtracted that direction from 64 output columns in each, and changed 131,072 weights out of 0.8 billion. With a budget of 50 forward passes, each covering up to 512 problems, the results were:
- MATH-500: 7.9% to 48.1%
- GSM8K: 13.8% to 67.1%
- IFEval: 21.0% to 62.3%
- Hit token limit: 93.0% to 33.1%
The edited model is on Hugging Face, and Ahsen Khaliq rebuilt it from the published logs and got the same numbers. The full post links prompts, code, and evaluations. That part is well done.
What it did not do
Look at the last row of that table. The rate of hitting the token limit fell from 93% to 33%. That is the whole story. A model that loops until it runs out of tokens scores near zero on anything. Stop the loop and the score you get is whatever the model could already do. A 0.8B model that can do 48% of MATH-500 is a normal 0.8B model. The 7.9% baseline was the anomaly.
The authors say this themselves, lower down. They ran the same procedure on Gemma 3 270M, which doesn't loop. MATH-500 went from 6.8% to somewhere between 7.0% and 7.7% depending on the forward pass budget, and they decline to call that a gain. Their own sentence: "Editing weights could remove an obstacle that hid an ability, but it could not add an ability the model lacked."
So the correct description is that a frontier model ablated a single direction in a small open model, in a Python sandbox, with numpy and an evaluation loop, and found the right direction to ablate. Anthropic and others have published direction ablation for refusal since 2024. The Latent Space writeup collects the Reddit and X critiques, and the sharpest one is that this is interpretability work done by an LLM in a sandbox, not a model reading weights the way you'd read a file.
The sycophancy experiment backs that up. Two tuned copies of Gemma 3 270M, one honest and one sycophantic. From weights alone, Astra failed all four attempts. Only after it was allowed to write test prompts and inspect attention patterns did it find head 10.2, which in the sycophant attends 85.7% to the user's suggested answer and 3.5% to the numbers in the question. That is activation probing. Useful, and automated, but it's a different claim than the title.
Where the result does hold up
The parts I can't explain away are the small ones. Naming the game from 17,253 floats with no labels. Finding every induction head in a transformer it could not execute. Writing a Breakout policy as a block of text that outscores PPO by 20x without ever running it. Those can't be explained by a loop fix. One plausible reading is that the first and last layers of these tiny networks have spatial structure that looks like a heatmap when you print the matrix, and the model is matching patterns in that. The authors as much as say the early experiments are small. Still, "the model can see structure in a weight matrix" is not nothing, and it's the part I'd want someone to scale up.
The Go result is the other one I keep coming back to. Fifty forward passes, no Go library, no internet, and it beat a network trained on 20 million games against itself. The counterargument on Reddit is that a 512×6 MLP is a weak Go player and the LLM is acting as a compiler for its own Go knowledge. That's probably right. It's also a compiler that writes 1.48 million weights to beat a trained baseline, which three years ago was science fiction.
What I'd do with this if I ran models
I don't run inference for a living, but I've been running production systems for 25 years, and the operational shape of this is familiar. It's a diagnostic that costs 50 forward passes and a frontier model's time, and it tells you whether your small model has a single degenerate behavior worth ablating. If yes, you get a patch to 131,072 weights instead of a fine-tuning run. If no, you get a report that says the model is bad at math in an ordinary way, which is what happened with Gemma.
That is a tool. It is a good one. The authors' prediction is that "our neural network weights will soon be natively optimized by LLMs that deliberately reason about their weights." The evidence in this post supports a narrower prediction: frontier models can run interpretability research on small models with less supervision than a grad student needs. Khattab's group at MIT is building a benchmark and tooling for it, which is the right next step, because right now there's one Qwen number and a lot of retweets.
My bet is that the next paper in this line shows the method working on a 7B model that doesn't loop, and the gain is under two points. If I'm wrong about that, the headline will have been right after all, and I'll say so. The Hacker News thread has the authors answering questions if you want to see how they handle the loop objection directly.
