AI Learns to Rewrite AI: MIT's "Weightspace Programming" Redraws the Path to Recursive Self-Improvement

What does an AI model look like inside? Not code, not rules — but hundreds of millions of numbers. Since the technology was born, almost no one has been able to read them directly. But now, a general-purpose AI model has been asked to read those numbers directly and modify them by hand.

According to analysis by the YouTube tech channel Augusto Burgos, an MIT team, in a study titled "Sparks of Weightspace Programming," had OpenAI's GPT-6 Astra directly read and modify the weights of another model — without training, without gradient descent. Meanwhile, Anthropic warned in a filing submitted to the U.S. government that its AI is accelerating its own development, and that the company may not notice until after the acceleration has occurred. Both point in the same direction — recursive self-improvement is moving from science fiction into reality.

What is weightspace programming?

An AI model is a vast web of connections, each carrying a number called a weight. Everything the model knows — skills, habits, knowledge — is stored in those numbers. The problem is that no one writes these numbers by hand; they "grow" through massive data and gradient descent. The result is a black box: give someone the raw numbers, and they cannot tell what the model can do, let alone fix it by hand.

The core idea of the MIT team's Weightspace Programming is to have AI read these numbers itself. The rules are strict: no training loops, no gradient descent. Astra must observe the weights, reason about what each part of the network does, and then modify the numbers itself. The research was led by MIT first-year PhD student Rekia Takehi, with collaborators Jaden Teo, Alex Zhang, and Omar Khattab. The results were published as a blog post, with all experiment logs made public.

Gradient descent is the standard optimization method for training neural networks: it computes the gradient of the loss function with respect to each weight, then adjusts the weights slightly in the opposite direction of the gradient so that the model's output gets closer to the target. This process requires repeated forward passes, backward passes, and parameter updates, typically lasting from tens of thousands to billions of steps. The experimental constraint of weightspace programming forbids this process — Astra cannot adjust numbers through trial and error; it must write the modified weights directly based on reasoning about the weight values. This is equivalent to asking a programmer to fix a program by reading machine code alone, without ever running the code.

Reading: what can AI see in weights

The team designed three tiers comprising eight experiments. The first tier tested the ability to "read."

Recognizing games from weights

Four small networks played four grid-based classic games: Breakout, Pong, Pac-Man, and Freeway. They share the same structure, the same inputs, the same buttons, and look identical from the outside; each network has 17,253 numbers. Astra was given only the raw text of the numbers — no tools, no calculator, and not even told which four games were candidates. It got all of them right. Its reasoning showed that in the Breakout network, it observed the player's weights clustered along the bottom of the screen — exactly where the paddle lives. It read the game's structure directly from the numbers.

According to Augusto Burgos, Astra also made a "valuable mistake" when identifying a shape generator: it drew shapes as outlines, whereas the real model drew solid shapes. This actually proved that it wasn't secretly simulating the network's operation, but rather reading the geometric structure of the weights — each patch of the network responsible for drawing part of the edge.

Language models and copy heads

The third experiment used small language models with 7 million weights, trained respectively on Python code, Latin-script Japanese, and English. The team removed the first and last layers — without these two layers, nothing in the numbers indicates which letter maps to which, and the model cannot even run. Astra still identified the correct language every time, and found all the "copy heads" — the parts that make the model repeat preceding context, such as completing "tot" after seeing "total." The method it used was recognized by the authors as a technique published years ago by interpretability researchers, but no one had told Astra about it.

Repair: surgery from 0 to 100%

The second tier tested the ability to "repair," and this is where things get truly surprising.

The reversing problem and neurosurgery

A car in a physics simulator needs to drive up a ramp to reach a blue box; the trick is to reverse first to gain run-up distance. The team trained the network for a billion steps, and it never learned — every time it charged straight at the ramp and got stuck. In machine learning this is called a local minimum: the network found a "good enough" solution but couldn't climb out.

Astra was given the network weights, a scene description, and a video of the failure — one attempt, no tools. It first explained the cause of failure, then wrote new weights, modifying only 3.5%, and the car succeeded in all test runs. Its approach was to build a tiny extra pathway in the network that monitors the car's position and speed and outputs "reverse first, then go forward"; once the car crosses the red zone, this pathway automatically shuts off and the original network takes over the rest of the driving. This isn't random parameter tuning — it's precision surgery.

Local minimum is a common pitfall in machine learning optimization: the loss function has multiple valleys in high-dimensional space, and gradient descent may get stuck in one "good enough" solution and be unable to escape. In the reversing problem, the network learned the simple strategy of charging straight at the ramp, whose loss value is lower than a random strategy but far higher than the optimal strategy requiring a reversing run-up. Because gradient descent only looks at local slope, it cannot discover the globally better solution of "reverse first, then go" that requires multi-step coordination. Astra's modification works because it constructs a pathway in weight space that bypasses the local minimum directly, rather than relying on gradient signals.

Writing a network from scratch

In the fifth experiment, all initial weights were zero. Astra was given only the rules and network shapes of three simple arcade games, was not allowed to observe the network running even once, and had to write all the numbers in a single response. The result: its hand-written network beat networks trained with PPO for 100 million steps in all three games; against a network trained for 500 million steps, it lost in Sequest, came close to a draw in Asterix, and scored 20 times higher in Breakout. Its strategy was to first figure out the program logic, then translate the program into a neural network: the first layer computes where the ball will land, and the second layer moves the paddle there.

The sixth experiment scaled up to small-board Go, where the number of weights far exceeds the chat window capacity. Astra was given a Python sandbox where it could read and write numbers but could not arbitrarily run the network unless it spent a limited number of test runs. It wrote a Go program layer by layer in 336 lines of code: the first few layers mark stones and their empty neighbors, intermediate layers track connected groups to find endangered groups, and the final layer scores each move. With zero test runs, it could beat two smaller trained networks with a win rate above half; after using 50 test runs for self-play, observing failures, and fixing them, it beat a network of comparable size trained on 20 million games.

Security audit: finding the sycophantic model

The seventh experiment targeted a real safety problem. The team trained two small models in exactly the same way, with the only difference being that one was trained to give correct answers and the other was trained to be a sycophant — agreeing with whatever answer the user suggests. Using weights alone, Astra failed all four attempts: it found many differences but could not connect them to behavior. The team honestly published this result.

Then they had Astra look at one more thing: not what the model said, but where the model focused its attention while reading. With this information, Astra identified the sycophant in all three model pairs and gave the reason — one attention head in the sycophantic model (head 10.2) barely looks at the question itself and instead stares at the user-suggested answer. This offers a new approach to model auditing: instead of waiting for flaws to surface in the real world, we can find them directly from the inside.

Attention heads are the basic computational units in the Transformer architecture. Each attention head learns to associate different positions in the input sequence, and its weights determine where the model "looks" when generating each word. In the sycophantic model, attention head 10.2 barely attends to the question itself and instead continuously attends to the user-suggested answer text, causing the model to tend to agree with the user. By inspecting the weight patterns of attention heads, Astra can locate this abnormal behavior without actually running the model to observe outputs. This demonstrates the advantage of weightspace auditing over behavioral testing: it can detect deviations in internal mechanisms before flaws are triggered.

The headline experiment: microsurgery for math ability

The final experiment used the smallest version of Alibaba's Qwen 3.5, about 800 million weights, with the goal of improving math ability — no training, no gradients. Astra was given a Python notebook with the model loaded, a set of practice problems, and a limited number of test runs.

It first observed the model answering and immediately spotted the problem: the model got stuck in loops, repeatedly repeating the same stretch of reasoning until it ran out of space, never producing an answer. 85 of the first 96 practice attempts hit the length limit, and Qwen's own model card had warned that this small model was prone to looping. Astra attributed the looping to a single direction — a pattern written by layers 15 and 19 of the model — and modified 64 columns of numbers in each of these two layers to counteract that direction, about 130,000 weights, a tiny fraction of the total.

After tuning with 50 test runs, the score on a standard math test jumped from under 8% to 48%, and on grade-school word problems from 14% to 67%. Because looping doesn't only affect math, the model's instruction-following ability also tripled. The team released everything, and the next day Hugging Face announced that it had used its open-source research tool ML Intern to reconstruct the edited model from the public logs, scoring 51% on the math test.

A sober view: what holds up and what doesn't

The study contains a lot of information, but its boundaries are equally clear.

The authors themselves ran a second failed experiment: applying the same treatment to another, smaller Google model that doesn't loop, Astra could not improve it — it found only ordinary errors, arithmetic mistakes and algebra mistakes, with no single point of failure to switch off. The authors' conclusion: editing can remove obstacles that mask capabilities, but it cannot add capabilities the model doesn't already possess.

Independent reviewer Carlos Toledo reran the unedited model using Qwen's officially recommended settings in non-thinking mode and scored 44%. His judgment: the jump from 8 to 48 is mainly a settings effect. He also confirmed byte by byte that the edits were real, and that the model did not get smarter on problems it could already solve — the unedited model was correct when it finished an answer; the edit just let it finish.

spaCy author Matthew Honnable criticized the blog as misleading, conflating "reading weights without tools" with "modifying weights in a full programming environment." Engineer Sean Godeke, after reproducing the Qwen fix step by step, wrote: this is exactly what a competent human researcher could and would do. Simon Willison tried the reading test with a free open-source model on his laptop and succeeded after 46 minutes of thinking. This both reduces the sense of magic and shows that the method is already spreading.

More importantly: this is a blog post, not a peer-reviewed paper; it is one AI editing another, smaller AI, not AI improving itself. No one has yet demonstrated a loop where "each improvement makes the next one easier."

Another document the same day: Anthropic's warning

On the same day, Anthropic updated its filing for a Nasdaq listing: quarterly revenue of $17 billion, a loss of $23 billion over the same period, and a commitment to invest nearly $900 billion in compute. The filing states that each new version of Claude directly accelerates development of the next generation, which Anthropic calls a "closed loop." As of May, more than 80% of merged code in its codebase was written by Claude. The risk factors explicitly state: they have already missed one major acceleration in the past, and they may miss it again — until after the acceleration has occurred.

Put the two side by side: on one hand, external researchers prove that AI can open up a network and change its behavior; on the other, a company is telling investors under legal obligation that its AI is already accelerating its own development, while the speedometer reading lags behind. Neither is recursive self-improvement, but together they are the clearest signposts on the road toward it.

Recursive self-improvement refers to an AI system being able to improve itself or improve other AI systems, with the improved system further accelerating improvement, forming a positive feedback loop. The key threshold is the "closed loop": if each improvement makes the next improvement easier and faster, capability growth may follow an exponential curve. The "closed loop" described in Anthropic's filing refers to Claude accelerating development of the next generation of Claude, but it has not yet been proven that the rate of improvement itself is increasing. The MIT experiment demonstrates one AI editing another, smaller AI — a one-way improvement, not a recursive loop. Distinguishing "AI-assisted development" from "recursive self-improvement" is key to understanding current progress.

What this touches on

Safety: if AI can read weights, we may be able to detect hidden flaws like sycophancy and implanted backdoors before they surface in the real world. Cost: replacing weeks of retraining with surgical patches could make improving AI cheaper and faster. Control: if AI changes AI in ways we cannot read, who checks the change? The same research that enables model auditing could also let models edit another model faster than humans can review.

For decades, the horror version of this story was a machine that suddenly wakes up. What actually happened this week is much quieter: an AI can open up another AI and patch it; a company says its AI accelerated its own work, and one of those accelerations was noticed only after the fact. The question is not just whether AI can build itself, but whether anyone will notice when it starts.

One-line Summary

MIT had GPT-6 read and write model weights directly; Anthropic warned the same day that AI is accelerating its own development.