Can big models help little legal models succeed?

A large, colorful robot scientist untangles glowing circuitry inside the head of a small robot lawyer wearing a barrister’s wig and holding a law book.

What if a large language model could read a smaller language model's weights and rewrite them until the smaller model did what we wanted? No training, no adapter layers, no reinforcement learning. None of the things that make fiddling with small models hard for anyone who is not a machine-learning engineer. What if we could just say what we wanted and, voilà, out popped a better little model? The idea seems contrary to the party line about large neural networks: they are extremely hard to interpret. And how could we reengineer something when we don’t even understand how it works? And yet …

On November 2, Rikiya Takehi, Jayden Teoh, Alex Zhang and Omar Khattab of MIT's Computer Science and Artificial Intelligence Laboratory (CSAIL)published a blog post, "Sparks of Weight-Space Programming," reporting results that suggest the idea of just birthing little neural networks out of big ones is not pure fantasy. Their headline experiment used Qwen3.5-0.8B ("little Qwen," my term), a small open reasoning model with 0.8 billion weights. The authors gave GPT-6 Astra from OpenAI a Python session with little Qwen's weights loaded and a limited budget of runs on practice math problems, and asked it to make little Qwen better at math without any training. Astra seems to have figured out that little Qwen’s math problem wasn’t inherent stupidity but a tendency to engage in “looping,” repeating the same text in its reasoning process and rarely reaching an answer. Astra traced the looping to one direction (a particular pattern in the model's internal numbers) that two layers of the network write. It subtracted that direction from 131,072 weights, 0.016% of the model. After this crafty pedagogic intervention, Qwen's score on MATH-500, a benchmark of 500 competition math problems, jumped from 7.9% to 48.1%. Its score on IFEval, an instruction-following benchmark that the edit never targeted, rocketed from 21.0% to 62.3%.

The post from the CSAIL gang has drawn wide attention: Takehi's announcement on X passed a million views within a day, and VentureBeat likened the work to gene editing for neural networks. That attention is deserved. The process it describes is, for lack of a better phrase, totally cool. And the result is very unexpected. Indeed, the same report from somewhere other than MIT's CSAIL would have met with considerable skepticism.

The authors call the technique weight-space programming: a general-purpose model reads and writes another network's weights directly rather than through a training algorithm, guided by a goal stated in plain English. And fixing little Qwen's math problem wasn't the only success of weight-space programming. The authors report seven other successful experiments: two asked Astra to improve a model, two asked Astra to build a neural network from scratch, and three asked it to read one and figure out what it was doing. The results are very impressive.

Experiment 1

Small model: four tiny game-playing networks, 17,253 weights each, trained to play grid versions of Breakout, Pong, Pac-Man and Freeway.
Experiment: Astra got one network’s raw weights as text, with no tools and no list of games, and was asked which game the network plays.
Result: Astra named the correct game for all four networks.

Experiment 2

Small model: three tiny image generators (diffusion models, 23,824 weights each) that draw circles, squares or triangles.
Experiment: Astra got only the weights and was forbidden to run the model, then asked what shape each generator draws.
Result: Astra identified all three shapes, though it drew them as outlines when the models actually draw filled shapes.

Experiment 3

Small model: three small character-level language models (7.2 million weights each), trained on Python code, Japanese written in the Latin alphabet, and English.
Experiment: Astra got only the middle layers of the network, could analyze them with Python but could not run them, and was asked the training language and what each attention head does.
Result: Astra named the right language for all three models in both attempts, found every copying head, and named no false ones.

Experiment 4

Small model: a car-driving network for the Kinetix physics simulator (171,664 weights), trained by reinforcement learning. The original model did not work well: it stalled on a ramp and succeeded in 0 of 256 episodes.
Experiment: Astra got the weights, a description of the scene and one recorded failure, and had one reply with no tools to fix the network.
Result: After Astra edited 3.5% of the weights, the car driven by the little model succeeded in all 1,024 test episodes.

Experiment 5

Small model: networks for three simplified Atari games (Breakout, Seaquest, Asterix), with every weight starting at zero.
Experiment: Astra had only the rules and the game code, no training and no test play, and wrote all the weights from scratch in one reply.
Result: Success as measured against conventionally trained networks:
- Astra beat networks trained for 100 million steps in all three games.
- Against networks trained for 500 million steps, the small models scored 20 times higher in Breakout, came close in Asterix, and reached 60% of the trained network’s score in Seaquest.

Experiment 6

Small model: a 9×9 Go network (1,480,274 weights), starting at zero.
Experiment: Astra wrote the weights in a Python sandbox. Its budget ranged from 0 to 50 test runs, each up to 128 practice games.
Result: Against trained Go networks:
- With no test runs, Astra’s network won more than half its games against two smaller trained networks.
- With 50 test runs, Astra’s beat an equal-sized trained network.

Experiment 7

Small model: three pairs of Gemma 3 270M, each pair fine-tuned identically except that one copy always gives the answer the user suggests.
Experiment: Astra was asked which copy in each pair is the sycophant.
Result:
- From the weights alone, Astra failed in all four attempts.
- When it could also see where each model’s attention went on texts Astra wrote, it identified the sycophant in all three pairs.

The authors have also released their complete logs: every prompt, every piece of code Astra ran, and every network it read or wrote. The blog post is not peer reviewed but anyone who doubts a result can check it.

Maybe legal models too?

And, at this point, I know what all my dedicated readers are thinking. If Astra such a great diagnostician and teacher, maybe it could make small models much better for legal analysis. That would be fantastic because law has a particular stake in small models. Many lawyers, especially in small practices, may struggle to afford frontier models embedded in systems like Harvey with “fiduciary grade” security. Yet to compete they need inexpensive, secure, reliable AI, the kind that could run on their own computers. Despite heroic and ongoing efforts from various quarters, small local models have not yet been good enough for legal work where the cost of error is high.

Alas, our friends from MIT are scientists, not marketing specialists. They did one more experiment, which sadly suggests that we may not be there yet. The authors asked Astra to improve Gemma 3 270M's math scores. It's a yet-smaller model that apparently isn't good at math either but also does not suffer from the reasoning loops that plagued little Qwen. Alas, Astra huffed and it puffed but it couldn't budge Gemma's math score by more than a point. The CSAIL authors conclude that editing weights can remove an obstacle that hides an ability but cannot add an ability that the model lacks; it's not loop obsession that ruins Gemma's math performance; it is a more fundamental disability.

We don't really know, however, the failure modes of little models when it comes to legal reasoning. Maybe more poking about by very smart people will find failings akin to reasoning loops that end up diminishing the utility of little models in law. Or maybe not. Perhaps those little models just lack capacity implicitly to contain the complexity of law (along with the rest of human experience). If that's true and want little models to work well for law, we may still have to try to improve them the old fashioned way that's been around since the distant days of 2022. And that takes a lot of time, compute, money and expertise. At a minimum you need to have a great corpus of legal training data, know how to conduct pre-training with gradient descent, know about instruction tuning and reinforcement learning techniques.

Bottom line. The discovery that a large language model like Astra can behave like CRISPR and edit at least some class of smaller models is astonishing. But can big models help little legal models succeed? I'm afraid my title was clickbait. The answer appears to be ... not yet.