What if an LLM could read a neural network's weights?

I read Rikiya Takehi’s write-up on weight-space programming and had to go back over it twice. The basic idea is simple to state and strange to picture: give a language model the numbers inside another neural network, and ask it to figure out what that network learned or change what it does.

Usually we treat weights as something an optimiser produces and a model consumes. The authors are asking whether an LLM can treat them more like a program: read the numbers, infer structure, and edit that program directly.

Reading the weights

In one experiment, the team trained four small neural-network policies to play grid versions of Breakout, Pong, Pac-Man and Freeway. The networks had the same architecture and the same inputs and actions. Astra got the weights as text and correctly identified all four games, without being told the options (experiment details).

The more interesting example used tiny character-level language models. The researchers removed the input and output layers, leaving Astra only four transformer blocks from a 7.2-million-parameter model. It identified whether each model had trained on Python, English or Japanese written in romaji, and found the copying heads in all three. The authors checked those answers by running the models afterwards.

So this isn’t just “the model saw familiar labels in the file.” It had to reason from the internal arrangement of the remaining weights. Still, these are small, carefully chosen setups. That’s where you want an early result to start.

Editing weights instead of training

They also asked Astra to fix a small control policy that drove a car into a ramp and got stuck. It changed a few weights so the car reversed first and built up enough speed to get over it.

The bigger headline is a Qwen3.5-0.8B experiment. Astra inspected the weights, used a limited number of forward passes on practice problems, and edited the model directly, without gradients or conventional training. On the held-out MATH-500 set, the score went from 7.9% to 48.1%; GSM8K rose from 13.8% to 67.1%. Instruction following improved too, from 21.0% to 62.3% on IFEval. The authors say the main fix was removing a direction in the weights associated with repetitive reasoning loops.

That is a pretty striking result. It is also one model, one small parameter count, one particular harness and a specific evaluation setup. The post itself gives the details, including the prompt budget and sampling settings; those details matter as much as the headline percentages.

Why I find it interesting

The fun implication is that an LLM might become a kind of model mechanic. Instead of only producing text or code, it could inspect a network, spot a failure mode, and make a targeted change. That could become a new way to debug models, study what they learned, or adapt a model when the usual training pipeline is too expensive.

But “can edit weights in a few demos” is a long way from “can reliably improve arbitrary neural networks.” The authors themselves call these early results and progressively increase the scale and tool access. I read it as a new research direction with promising sparks, not a replacement for training or interpretability research.

Still: handing a model a tensor file and asking it to repair the behaviour is a wonderfully weird interface. I want to see what happens when other teams try it on less curated tasks.