Researchers at MIT have shown a frontier AI model editing the inner workings of another model directly, with no training run at all. In a post published on November 2, the MIT Computer Science and Artificial Intelligence Laboratory team asked OpenAI’s GPT-6 Astra to improve a small open model at mathematics by rewriting its weights, the numbers that encode what a network has learned. Astra changed just 0.016 percent of those weights, and the small model’s score on the MATH-500 benchmark rose from 7.9 percent to 48.1 percent. The team calls the approach Weight-Space Programming.
The loop Astra found
The patient was Qwen3.5-0.8B, a small model from Alibaba’s Qwen team with about 800 million weights. Its model card warns that it is more prone than its siblings to thinking loops, repeating itself instead of reaching an answer. In the MIT tests, that warning proved accurate: 85 of its first 96 practice answers ran to the 32,768-token limit without finishing.
Astra traced the looping to a single direction written by the output layers of two parts of the network, layers 15 and 19. By subtracting that direction from 64 output columns in each layer, it touched 131,072 weights in total. After the edit, the share of MATH-500 answers stuck at the token limit fell from 93 percent to 33.1 percent.
The gains reached beyond mathematics. On GSM8K, a mathematics set, the score rose from 13.8 percent to 67.1 percent, while IFEval, a test of following instructions Astra never targeted, rose from 21.0 percent to 62.3 percent. The budget mattered: with 10 or 25 trial runs, MATH-500 reached only 12.3 and 14.1 percent, but with 50 it jumped to 48.1 percent.
Reading, fixing, and writing from scratch
The mathematics edit was only the final experiment in a set of eight. In earlier tests, Astra read the raw weights of game-playing networks and named the game for all four, without being given a list of options. Given only the middle layers of three language models, it named the language each was trained on and found every copying head.
Astra could repair a failing network in a single attempt. A car-driving network trained with a reinforcement method had stalled on a ramp in every one of its 256 episodes, driving straight at the obstacle instead of backing up. After Astra edited 3.5 percent of its weights, with no tools and no retraining, the car succeeded in all 1,024 episodes.
Astra wrote networks from scratch, with no data, no loss function, and no training. For three arcade games, its networks beat rivals trained for 100 million steps; in Breakout it scored 517.4 against 25.3 for a rival trained for 500 million steps. A Go network of 1.48 million weights, built from zero, beat a rival trained on 20 million games.
What it does not prove
The work is a blog post with public logs, not a peer-reviewed paper, and no arXiv paper had appeared by November 3. The authors call the findings very early results and describe the capabilities as exciting but still limited. An independent rerun of the checkpoint scored 51.0 percent, which checks that the checkpoint works, but not the method.
The failures matter as much as the successes. On Google’s Gemma 3 270M, a model that rarely loops, Astra’s edits moved MATH-500 by a point at most, from 6.8 percent to 7.7 percent. Astra failed, in four attempts, to tell which of two Gemma copies had been trained to agree with the user, succeeding once it could inspect attention patterns.
A test by another researcher, using Claude on toy tasks, does not change that picture. That write-up used a different model, and its author flags it as informal, so it should not be read as confirmation of the Qwen result. The reading is narrower than the headline: a frontier model removed a failure, rather than teaching mathematics from nothing.
Why It Matters
If models can read and repair weights directly, two practical doors open. First, teams could audit a model for hidden flaws or backdoors by inspecting its weights, instead of waiting for a test set to expose the problem after deployment. Second, targeted fixes could avoid full retraining, with its cost and its risk of overwriting what a model already knows.
The authors raise a possibility: a model able to improve its own weights would offer a more direct path to recursive self-improvement. That theme landed the same day in Anthropic’s revised stock-market filing, which warns its future models may imminently meet its own definition of sharply accelerated, AI-driven progress. No experiment in the MIT post had a model edit itself.
Our read
Read literally, this is a loop-removal story with an unusually elegant mechanism, not a demonstration that training is obsolete. The edited model already contained the mathematics ability; it simply could not finish its answers. Yet the mechanism is the news: a general-purpose model, used as released, reasoned about raw numbers it never trained and changed them deliberately.
Weights deserve scrutiny as code, and this post shows why that scrutiny may be automated. Replay work on a Qwen model showed how unpredictably a model can behave around network destinations, a reminder that inspecting weights is not a substitute for testing behavior. The markers are a benchmark from the authors, a peer-reviewed paper, and replication on models.
Background
For most of deep learning’s history, weights have been set by optimizers such as Adam, guided by training data and a measure of error. Humans cannot handcraft those numbers at scale, which is why asking a model to read and write them once sounded fanciful. The MIT team argues this is changing, and reasoning-driven optimization may sit alongside gradient descent.
Source: MIT weight-space post and Register report
0 Comments