Neural network weights are the billions of numbers inside an AI model that decide what it does. Nobody writes them by hand. They come out of training, a long, expensive process that nudges each number a tiny bit at a time. On Monday night, four researchers at MIT’s Computer Science and Artificial Intelligence Laboratory (CSAIL) published results suggesting that a frontier AI model can now skip that process and edit the numbers itself.
Their headline experiment: OpenAI’s GPT-6 Astra looked inside Qwen3.5-0.8B, a small open-weight model from Alibaba’s Qwen team, found what was making it fail at math, and fixed it by changing 0.016% of its weights. With no training run and no gradients, the small model’s score on the MATH-500 benchmark went from 7.9% to 48.1%. The researchers call the idea “weight-space programming.”
The first author’s announcement thread went up on X at 11:21pm IST on 2 November and passed 4.2 million views and 40,000 likes in about ten hours. X had logged roughly 20 to 30 posts a day matching the topic’s key terms the previous week; on 2 November there were more than 1,000, and around 200 an hour were still coming in on Tuesday morning. On Hacker News, the post reached the top of the front page with more than 2,100 points and close to 700 comments. Here’s what the team did, what it doesn’t prove, and why people are arguing about it.
What “weight-space programming” means
For a few years, people have used large language models to improve text: prompts, code, and more recently the training scripts that produce other models. Weights stayed off-limits, because no human can read or tune millions of numbers by hand, so that job was left to optimisers such as gradient descent.
The paper, titled “Sparks of Weight-Space Programming” and written by Rikiya Takehi, Jayden Teoh, Alex Zhang and Omar Khattab, argues that this is changing. In their words, a general-purpose LLM “reads and writes a network’s weights directly (i.e., not through an optimizer, and in particular not with gradient descent)” based on a plain-language goal. GPT-6 Astra wasn’t retrained for this. The team used it as it is and gave it the raw numbers.
The researchers tested three skills: reading weights to work out what a network does, fixing a broken network, and writing a working network from scratch.
Reading: naming the game from the numbers
In the first test, the team trained four small networks to play grid versions of Breakout, Pong, Pac-Man and Freeway. All four had exactly the same shape, inputs and actions: 17,253 weights each. Astra got the weights as text, with no tools and no list of games to choose from, and named the right game every time.
It did the same with three tiny image generators, telling from the weights alone whether each drew circles, squares or triangles. In a harder test with three small language models, the team removed the input and output layers so nothing in the weights said which letter was which. Astra still named the training language, Python, English or Japanese written in the Latin alphabet, in both of its attempts for all three models. It also found every “copying head”, a part of the model that repeats text it saw earlier, and named no other part as one.
It wasn’t a clean sweep. Given two copies of Google’s Gemma 3 270M, one fine-tuned to be sycophantic, meaning it always agrees with the user’s suggested answer, Astra couldn’t tell which was which from the weights alone in four attempts. It succeeded only once the team let it see where each model’s attention went on texts it wrote.
Fixing and writing networks
Next, the team trained a network to drive a car up a ramp in a physics simulator. To succeed, the car has to reverse first to build a run-up. The trained network never learned that and stalled on the ramp every time. Given the 171,664 weights, a description of the scene and one recording of the failure, Astra wrote a fix in a single reply without tools. It changed 3.5% of the weights, and the car succeeded in all 1,024 test episodes.
Then the researchers asked Astra to write networks from nothing for three simple arcade games: Breakout, Seaquest and Asterix. It got the rules and source code, but no data, no training and no chance to test. Its one-shot networks beat ones trained by a standard method called PPO for 100 million steps in all three games. Against PPO trained for 500 million steps, Astra’s Breakout network scored 517.4 against 25.3, came close in Asterix, and reached about 60% of the score in Seaquest.
The Qwen experiment that went viral
The result everyone is sharing is the eighth experiment. Qwen3.5-0.8B has a known flaw: Qwen’s own model card warns that in thinking mode it “is more prone to entering thinking loops compared to other Qwen3.5 models, which may prevent it from terminating generation properly.” In the researchers’ tests, 85 of its first 96 practice answers ran to the 32,768-token limit.
Astra got a Python notebook with the model’s weights loaded, practice problems from the GSM8K and MATH training sets, and a budget of forward passes, meaning batches of practice answers it could run. It wasn’t allowed to train. It traced the looping to a single direction written by two internal layers, 15 and 19, and subtracted it from 64 columns in each. That is 131,072 weights out of 0.8 billion.
With 50 forward passes, MATH-500 rose from 7.9% to 48.1% and GSM8K from 13.8% to 67.1%. Because looping isn’t specific to math, instruction following improved too: IFEval went from 21.0% to 62.3%. The share of MATH-500 answers hitting the token limit fell from 93% to 33%. With only 10 or 25 forward passes, though, the loops barely went away, and MATH-500 only reached 12.3% and 14.1%.
The catch: it removed a bug, not added a skill
The authors are upfront about the limit. They ran the same test on Gemma 3 270M, a model that rarely loops. Astra found only ordinary mistakes such as wrong arithmetic, with no single part to switch off, and none of its edits moved MATH-500 by more than about a point. Their conclusion: “Editing weights could remove an obstacle that hid an ability, but it could not add an ability the model lacked.”
Critics have pushed further. In a post titled “LLMs are not superhuman at reading and writing neural network weights,” engineer Sean Goedecke argues that a competent human researcher could do all of these tasks. He shows that a heatmap built from three lines of Python makes most of the game networks easy to identify, and says Astra’s Qwen fix follows a known playbook: compare looping and non-looping text, find the weights behind the difference, and trim them. He calls it “an impressive trick,” comparable to an AI patching a compiled program directly, and argues that training will remain the best way to improve models.
Khattab framed it more ambitiously on X, asking where this leaves “symbolic local optimization heuristics like gradient descent.” First author Takehi noted in a reply that Astra had no web search, so the interpretability techniques it used came from what the model already knew.
Why it matters
Even with the caveats, the research points somewhere significant. The authors list possible uses: checking a model for hidden problems such as backdoors by reading its weights instead of testing it, targeted fixes that don’t require retraining, removing a capability without collecting new data, and grafting a circuit from one model into another. They also name recursive self-improvement, an AI improving AI systems. That is the same category in which GPT-6 Astra scored best on SemiAnalysis’s new GDPx benchmark, where the top model scores just 12%.
It also fits a pattern. OpenAI’s frontier model has already been at the centre of claims of AI-written mathematical proofs, and the company recently filled out the family with the cheaper GPT-6.1 Terra. This experiment, though, depended on open weights. It only worked because Qwen publishes its model’s numbers, which is the same reason Mistral Large 4 going open weight matters to developers who want to inspect and modify what they run.
The results come from a blog post, not a peer-reviewed paper, and are early. The team has released full logs of every experiment on GitHub, and the edited Qwen model is on Hugging Face, where it has been rebuilt from those logs and its evaluation re-run. The researchers say they’re now building a benchmark and harness for weight-space programming. Until others reproduce the results, treat the 48.1% as a striking demonstration of one fix, not proof that AI models can now rewrite themselves.
Sources
- Takehi, Teoh, Zhang and Khattab (MIT CSAIL): Sparks of Weight-Space Programming: LLMs can natively read & write neural network weights (2 Nov 2026)
- Experiment logs on GitHub
- Edited Qwen3.5-0.8B model on Hugging Face
- Qwen3.5-0.8B official model card
- Rikiya Takehi’s announcement thread on X
- Omar Khattab on X
- Sean Goedecke: LLMs are not superhuman at reading and writing neural network weights
- Hacker News discussion
Leave a Reply