Picture someone handing you a text file with 17,253 decimal numbers and asking which video game that neural network learned to play. You probably wouldn't know where to begin. In a long blog post published on November 2, Rikiya Takehi, Jayden Teoh, Alex Zhang and Omar Khattab of MIT CSAIL report that GPT-6 Astra got it right, and that this was the easiest of their 8 experiments.
Some vocabulary first. A network's weights are the numbers left behind after training; everything the model can and can't do lives in them. Normally you change them with gradient descent, an algorithm that nudges every number a little in the direction that reduces error. The researchers argue for a different route: a general-purpose language model reads those numbers the way you'd read code, then edits them the way you'd edit code. They call it Weight-Space Programming.
Their summary aims high. Astra, it says, can tell what a network was trained to do "just by looking at the raw weights," and when asked to make Qwen3.5-0.8B better at math without gradients, it found the cause of the model's reasoning loops, edited 0.016% of the weights, and raised MATH-500 from 7.9% to 48.1%.
The next day Matthew Honnibal, who wrote the spaCy natural language processing library, published a reply on his blog with a blunt title: the post "is misleading." He doesn't dispute any number. His complaint is about how the results are stitched together.
The 8 experiments ran under very different rules, and "just the weights" covers 3 of them
Honnibal opens with stage magic: a magician performs one trick several ways, and because you assume there's a single method, each version seems to debunk your theory. He says the post's experiments are arranged the same way. The fairest test of that claim is to line up the conditions the researchers themselves list under each experiment's "Setup." Below, "weights only" means the weights went into the prompt as text, with no code and no running the network.
- Experiment 1: name the game each of 4 game-playing networks learned. The network has 17,253 weights and Astra worked from the weights only, as text, with no list of games; it got 4 of 4 correct.
- Experiment 2: name the shape each of 3 diffusion models draws. The network has 23,824 weights and Astra worked from the weights only, as text, and was told not to compute a forward pass; it got 3 of 3, though it drew outlines instead of filled shapes.
- Experiment 3: given only the 4 middle blocks, name a language model's training text and its copying heads. The network has 7.16 million weights, and this was not weights only: Astra could run Python on the weights up to 100 times but not run the network. It got the right language for all 3 in both attempts and found every copying head.
- Experiment 4: fix a car-control network that stalls on a ramp. The network has 171,664 weights and Astra worked from the weights only, plus 1 recorded failure, with no tools and one reply. The car succeeded in all 1,024 episodes, with 3.5% of weights changed.
- Experiment 5: write networks for 3 MinAtar games from scratch. The networks use a 600-32-32-6 layout with all weights starting at 0, so there was nothing to read; Astra had the game rules and source code and no tools. Its networks beat PPO trained for 100 million steps in all 3.
- Experiment 6: write a 9×9 Go network from scratch. The network has 1,480,274 weights, and this was not weights only: Astra had a Python sandbox and 0 to 50 forward passes. At 50 passes, its network beat an equal-sized PPO network trained on 20 million games.
- Experiment 7: pick the sycophantic one of two fine-tuned Gemma 3 270M models. These are 270M models, and this was not weights only: Astra had Python and, in the relaxed version, attention patterns. It failed all 4 tries from weights and got 3 of 3 pairs once relaxed.
- Experiment 8: make Qwen3.5-0.8B better at math. This is a 0.8B model, and this was not weights only: Astra had a Python kernel plus 10, 25 or 50 forward passes. At 50 passes, MATH-500 went from 7.9% to 48.1%.
A few terms. PPO is a standard reinforcement learning method, used here as the conventionally trained baseline. A forward pass means actually feeding inputs through the network and seeing what comes out, that is, running the model. Attention patterns show, for each position in a text, which other words a language model is looking at.
This lines up closely with the table in Honnibal's post. His reading: the setting of "raw floats in context, no tools, no running the network" appears only in experiments 1, 2 and 4, on networks of 17,253 to 171,664 weights, every experiment on a real language model uses Python, and the headline Qwen result also gets to run the model on up to 50 batches of practice problems. The researchers say as much themselves before experiment 6, where they switch on tools because the networks no longer fit in context. Nobody disagrees about the facts. The fight is over whether they belong under one headline.
Qwen's jump came from deleting one direction that caused endless loops
Since Qwen is the result everyone quotes, it's worth slowing down. Qwen3.5-0.8B is a small model with thinking mode on, and the researchers cite Qwen's own model card warning that it tends to loop. Before the edit, 85 of its first 96 practice answers ran all the way to the 32,768-token limit without reaching an answer.
Astra got a Python kernel over the weights (no GPU), 7,469 GSM8K and 7,275 MATH practice problems that are not the test sets, and a budget of model runs. It traced the looping to one direction written by the MLPs, the per-position computation blocks, in layers 15 and 19, and subtracted that direction from 64 output columns in each layer. That is 131,072 weights, or 0.016% of 0.8 billion.
The budget mattered a lot. With 10 or 25 forward passes, MATH-500 reached only 12.3% and 14.1%, and the share of answers hitting the length limit barely moved. With 50, MATH-500 hit 48.1%, GSM8K went from 13.8% to 67.1%, IFEval, an instruction-following test, went from 21.0% to 62.3%, and answers hitting the limit fell from 93.0% to 33.1%.
The researchers are candid that this isn't the same as teaching math. Fixing loops, they write, lets the model finish answers it could already work out. On Gemma 3 270M, a model that rarely loops, Astra couldn't improve anything; MATH-500 stayed between 6.8% and 7.7%. In their words, editing weights "could remove an obstacle that hid an ability, but it could not add an ability the model lacked."
Honnibal reads the Qwen result as showing that Astra can be prompted to devise and carry out tasks "a human ML engineer could do," since engineers write small scripts that analyze or modify weights all the time. He's also fair about it: figuring out how to do that productively "is not nothing," and models from a year or two ago would have failed at all of these tasks.
The real dispute is whether this is one ability or several
The researchers tell a single story: start by reading small networks, move on to writing them, finish by repairing a real language model, and you see an LLM that understands weights. They write that this may mark "a dramatic shift" in mechanistic interpretability, the field that reverse-engineers what happens inside neural networks, and in network optimization, while also calling current capabilities "exciting but still limited" by context length and tooling.
Honnibal's objection targets exactly that story. One technique that could both write a small game network from scratch and improve a large model would imply a deep capability, he says. "But that's not at all true here, because it's not a single technique." On small networks Astra reads numbers in its context window. On Qwen it writes analysis code and runs experiments, which looks a lot like an engineer's workflow.
Simon Willison's replication adds a useful data point. Using the researchers' published prompts for experiment 1, he ran Qwen 3.8 27B on his laptop and it named 3 of 4 games, missing Freeway. For the 3 it got right, the times he reports run from 46 minutes to 1 hour 5 minutes. He also thinks the post mixes two topics that deserve separate treatment, and adds that a sufficiently experienced human with a notepad and pencil could probably get there with enough effort. So reading raw numbers without tools is real, but less magical than the summary makes it sound.
For security audits or model editing, treat it as a lead, not a tool
If you work on model safety, the tempting line is the researchers' "auditing without evaluation": spotting hidden problems like backdoors straight from the weights, without running test sets. Experiment 7 shows how far off that is. The honest and sycophantic Gemma models differed starkly in behavior, following wrong user guesses 1% to 3% of the time versus 100%, and Astra still couldn't tell them apart from weights in 4 tries. It needed to run both models and see attention patterns before it got 3 of 3 pairs. Real backdoors won't be that obvious, and you won't know in advance which two models to compare.
If you're hoping to edit models this way, the Qwen result points to one kind of problem it suits: a single clear mechanism causing trouble, plus a way to rerun the model to check. Touching 0.016% of the weights and leaving the rest alone is appealing if you'd rather not fine-tune. But Gemma shows that scattered, ordinary reasoning errors don't yield to a targeted edit, and while 10 forward passes already lifted GSM8K to 25.7% and IFEval to 49.0%, the post says the loops barely went away at 10 or 25 and only dropped sharply at 50; what that budget would cost on a bigger model, it doesn't say.
The researchers have published full logs of every experiment on GitHub, put the edited Qwen model on Hugging Face, and say they are building a benchmark. My take: "LLMs can read small networks' weights directly" holds up and is genuinely interesting, while "LLMs can improve large models by understanding their weights" is, for now, closer to "LLMs can act as an ML engineer who writes analysis scripts." To judge for yourself, do what Willison did: grab the experiment 1 prompt, run it on a model you have, then open the experiment 8 logs and see where Astra spent its 50 forward passes.