An AI rewrote a model's weights for 6x better math. Mostly, it fixed a loop

What this is about

On November 2, Rikiya Takehi, Jayden Teoh, Alex Zhang and Omar Khattab of MIT CSAIL published a blog post titled "Sparks of Weight-Space Programming." Their claim: frontier models like OpenAI's GPT-6 Astra can read, understand and deliberately rewrite the weights of other neural networks, with no training at all. The headline result came from Experiment 8. There, Astra changed 0.016% of the weights in Qwen3.5-0.8B, and its score on the MATH-500 math benchmark rose from 7.9% to 48.1%. On X, Takehi wrote of math getting "up to 6x" better.

The first independent checks are now in. Here's our verdict up front: the numbers hold up, but they measure something different from what the headline implies. The model didn't learn to do math. It was freed from an infinite loop. That's still remarkable, just for other reasons.

How an AI "reads" weights

For small networks, that's meant literally. In Experiment 1, Astra received the 17,253 weights of a game-playing agent as columns of numbers in its prompt, with no tools. According to HomoHabilis's replication kit, that comes to roughly 74,000 to 100,000 tokens per network. From that, Astra worked out which of four Atari games the network had been trained on. Simon Willison reran the same prompt with a local model: it identified Pac-Man, Pong and Breakout but failed on Freeway.

A model with 0.8 billion weights, on the other hand, won't fit into any context window, a language model's working memory. So according to the README for Experiment 8, Astra was given two tools:

• A Python kernel over the weights (CPU only, no internet, at most 300 runs). It lets Astra load matrices, compute on them and save changes.
• A forward-pass tool. A forward pass is a run in which the model actually processes text. There were two kinds. In generation, the model answers up to 512 practice problems, and Astra gets back the accuracy plus the share of answers cut off at the token limit. In a teacher-forced read, the model reads up to 1,024 given texts. What comes back are internal measurements: probabilities, intermediate states, MLP activations and attention patterns.

So "reading" here means roughly what a doctor does with lab results and an X-ray. Astra lets the model work, looks at its intermediate states and searches for an anomaly linked to the failure. Then it works backward to find which weights produce that signal. In the 50-pass run, that was a single "direction": a specific pattern in the internal vectors written by the MLP blocks of layers 15 and 19. Astra removed this direction from 64 output columns of the down_proj matrix in each layer. Do the math: 2 × 64 × 1,024 gives the reported 131,072 weights, which is 0.0164% of 0.8 billion.

According to the logs, the run took 158 conversation turns, 80 Python runs and 20.3 hours. 4.7 hours of that were lost to a service outage. The authors don't disclose the cost.

The authors' numbers vs. independent checks

Three things stand out. First, the thinking-mode numbers are reproducible: independent runs land within about two points. Second, other editors also achieve big jumps. The tdotlab home replication, with Claude as the editor, gets 30 instead of 5 out of 100 problems right, while a control using a random direction had no effect. Another run with Opus 5.5 switched off different components, including attention head 7 in layer 15. That's the exact head Astra had also disabled in its 25-pass run.

Third, and this is the crucial part: according to the Qwen Model Card, Qwen3.5-0.8B runs without thinking mode by default. The maker itself warns that in thinking mode it falls into loops more often than the other Qwen3.5 models. Simply switch thinking off, and the unmodified model already reaches 45.8%, according to Coletti. His paired analysis shows that in thinking mode, the edited model beats this best base configuration by 4.3 points (95% interval 1.9 to 6.8). Without thinking mode, it's 2.2 points worse than the original. Our take: of the roughly 40-point gain, about 38 points can also be had by flipping a switch in the chat template. A small, measurable remainder is left.

Coletti himself puts it this way:

"This removes a failure mode, it doesn't add a capability."

The authors say as much, too. On Gemma 3 270M, which runs to the limit in only 8.5% of cases, Astra found only scattered arithmetic errors. MATH-500 moved from 6.8% to at most 7.7%. Success also depends on budget: with 10 or 25 forward passes, Qwen reached only 12.3% and 14.1%, respectively.

The clinical cross-check

Kristina Mruts, a product manager on a MedTech research team, repeated the experiment on Habr with a more serious case. She took OpenSpliceAI, a model with roughly 699,000 weights that estimates whether a DNA mutation disrupts how a gene is spliced. According to Mruts, such scores feed into real lab reports via ClinGen guidelines. Claude Opus 5.5 was allowed to write code, run the model and inspect activations. Training and automated trial-and-error over values were off limits. Testing was done on chromosomes Claude hadn't seen.

AUPRC measures how well a model finds rare positives without triggering too many false alarms. 1.0 would be perfect. According to Mruts, the difference from gradient training is "within statistical uncertainty." 86% of the gain came from a single change: Claude scaled the last layer by 0.35, which amounts to a temperature correction. A simple grid search over that one value found exactly the same number. The trick also has a side effect: at a strict threshold of 0.8, the model now catches only 15% instead of 49% of harmful mutations, so clinical thresholds would need to be recalibrated. Her conclusion: what's valuable is "not the fix, but the explanation." Claude showed that the network does notice internally when a splice site is damaged, but that knowledge barely makes it into the final score.

There's a counterexample, too. In HomoHabilis's replication kit, Opus 5.5 wrote thirty made-up company facts directly into Qwen3.5 weights. At 0.8B, it scored 86% on questions phrased in new ways, versus 53% with LoRA (a lightweight fine-tuning method). At 9B, it was 96.7% versus 47%. But that's a single run with a fictional company, and the LoRA settings are barely documented. It's not yet evidence that the approach can replace fine-tuning.

What's actually new here

Editing weights directly isn't a new idea. ROME (2022) and MEMIT (2023) rewrite specific factual knowledge. In "abliteration," following Arditi et al. (2024), a model's refusal direction is measured and removed from its weight matrices via a rank-1 projection. Tools like Heretic have long automated this. That's why yurimo on Hacker News called it "basically a steering vector," and GuB-42 described it as reproduced abliteration, just aimed at loops instead of refusals. The formula in Astra's 10-pass run (W′ = W − 1.5·u(uᵀW)) does in fact match the abliteration pattern.

What's new is something else: until now, a human picked the method, the criterion and the layer. Here, a language model did it on its own, starting from the task "make it better at math." On the small networks, it sometimes didn't even need a single test run. One HN commenter pushed back that ROME can't "look at thousands of ASCII numbers." For interpretability research, this automated diagnosis is the real finding. It has limits, though: Astra couldn't tell from the weights alone, in four attempts, whether a Gemma copy had been trained to be sycophantic. It only succeeded once it had attention patterns on texts it wrote itself.

And self-improvement?

The topic is in the air. In its IPO prospectus, Anthropic writes that it could "imminently" reach its own threshold for AI-driven progress. At Astra's launch, OpenAI researcher Aidan Clark said earlier models had substantially supervised the training of the next one. The MIT authors also name recursive self-improvement as an outlook: models that examine and improve their own weights.

They didn't demonstrate that. A presumably huge model repaired a 0.8B model, as HN user Wheen pointed out. Whether the same method works on the model's own weights, or whether improvements compound, wasn't investigated, according to VentureBeat. Even so, Maxime Fournes of PauseAI called the research direction "terribly reckless." spaCy author Matthew Honnibal considers the post misleading, according to Simon Willison, because it blurs tool-free reading with tool-assisted editing.

Our assessment

Here's where we land: it's established that current frontier models can recognize structure in small networks and can find and cut out a narrowly defined defect in larger models. Several independent runs have confirmed this, with Astra and with Claude. The logs are public, which deserves credit.

What isn't established is a general gain in math. The sixfold jump is mostly a loop fix in a mode Qwen itself doesn't recommend. Against the best unmodified setting, about four points remain. Nor is there evidence that the method is cheaper or better than fine-tuning. In the clinical test it performed about the same, and a single parameter explained almost everything. And none of it has anything to do with self-improvement.

In practice, then, "weight-space programming" is for now a debugging tool that explains why a model fails. That's more than gradient training gives you. What remains open is whether it works on models with billions of parameters and on failures spread across the network. The benchmark the authors have announced would be the next real test.