GPT-6 Directly Edits Weights: 0.016% of Parameters Take MATH-500 from 7.9% to 48.1%

Four authors from MIT CSAIL published a blog post with a direct title: LLMs can natively read and write neural network weights. The authors are Rikiya Takehi, Jayden Teoh, Alex Zhang, and Omar Khattab. The blog post has not yet been formally published.

Let's first be clear about what weights are. The pile of numbers in a neural network is the weights, and training is the process of adjusting those numbers. In the past, we mainly adjusted them via gradient descent and optimizers; it was hard for humans to understand them directly, let alone write them by hand. This blog post aims to show one thing: frontier LLMs are beginning to be able to directly read weights, modify weights, and even write weights from scratch. The authors call this Weight-Space Programming.

The most eye-catching experiment is Qwen3.5-0.8B. Astra was asked to improve its math ability without training or gradients. It first found that this small model had a problem: during reasoning it tended to loop, repeating the same passage and rarely giving an answer. Astra attributed the looping to a direction written out by the MLPs in layers 15 and 19, then subtracted this direction from each layer's 64 output columns, changing a total of 131,072 weights, or 0.016% of the 0.8B parameters.

Results: MATH-500 went from 7.9% to 48.1%, GSM8K from 13.8% to 67.1%, and IFEval from 21.0% to 62.3%. The share of MATH-500 hitting the 32,768-token cap fell from 93% to 33.1%. These numbers come from a setting with 50 forward passes, and Astra had not seen the test sets.

Reading weights is also interesting. The authors trained four PPO networks to play Breakout, Pong, Pac-Man, and Freeway. The four networks had exactly the same inputs, outputs, and size, differing only in weights. Astra was given 17,253 weight values as text; without being given the list of game choices, it correctly identified all four.

In a similar experiment, Astra looked only at the weights of a diffusion model and could say whether it generated circles, triangles, or squares. Looking only at the middle four transformer blocks of a small language model, with the input and output layers removed, it could also determine whether the training corpus was Python, Romanized Japanese, or English, and it found the copy head. The authors say Astra used matrix multiplication to find an analysis method similar to the circuit analysis proposed by Elhage et al., and they had not mentioned this method in the prompt.

On the writing-weights side, Experiment 4 fixed a PPO network stuck before a ramp. Astra changed 3.5% of the weights, and all 1,024 episodes succeeded. Experiment 5 wrote networks for three MinAtar games from scratch, with no data, no loss, and no gradients; Astra output the weights directly. On Breakout, the network it generated in one shot scored 517.4, while PPO trained for 100 million steps scored 15.8 and trained for 500 million steps scored 25.3. On Seaquest and Asterix, it did not comprehensively surpass PPO trained for 500 million steps, but it came close to or reached about 60% of that level.

A more engineering-oriented experiment was 9x9 Go. The network had 1.48 million parameters. Astra wrote weights in a Python sandbox and could spend forward passes to inspect the results. With 0 forward passes, it could already win more than half of its games against two small PPO networks. Given 50 forward passes, the network it generated defeated a same-sized PPO network trained for 20 million games.

Failure cases deserve separate mention. The authors fine-tuned two Gemma 3 270M models, one answering honestly and one catering to users' incorrect answers. When given only the weights, Astra failed to distinguish them in all four attempts. After relaxing the setup to allow it to write its own text and inspect attention patterns, it chose correctly for all three pairs. In another experiment, Gemma 3 270M itself rarely loops, so Astra could not change its math score. The authors' explanation is restrained: editing weights can remove obstacles and reveal capabilities the model already has, but it cannot add capabilities the model did not originally have.

Such demos are most easily read as training disappearing. After looking at the boundaries of the experiments, at least for now that is not the case. Most experiments still constrained the tools and the number of forward passes, and the Qwen fix also focused on removing the specific failure of looping. The authors think this may mark a turn in mechanistic interpretability and network optimization: LLMs are not just writing training code, but reasoning directly over weights. Next they also plan to build benchmarks and harnesses.

Blog link: https://rikiyat.github.io/blog/weight-space-programming/
Tweet link: https://x.com/TheMoonMidas/status/2117345013436981262