One AI directly rewriting another AI’s weights, with no retraining: a group of researchers says they have done it. Four researchers at the Massachusetts Institute of Technology’s Computer Science and Artificial Intelligence Laboratory (MIT CSAIL), Rikiya Takehi, Jayden Teoh, Alex Zhang, and Omar Khattab, published a post on their personal research blog on November 2, arguing that the latest large language models (LLMs) can read, edit, and write the “weights” of another neural network directly, with no conventional training. They call this Weight-Space Programming.

This is a personal blog post that has not been peer reviewed, and every result below is as reported by the authors.

What are weights, and why can’t humans tune them by hand?

A neural network (the core structure of an AI model) contains a long list of numbers that determine how it reacts to an input. Those numbers are called weights. The networks in these experiments range from about 17,000 weights to 800 million.

Weights are normally set by a training algorithm: you feed the model lots of data and correct it repeatedly with gradient descent (a method that nudges the numbers a little at a time so the errors shrink). Humans can’t read these numbers and can hardly write them by hand. The authors say that handcrafting a network that plays Go, or predicting its behavior from raw weights, is “practically impossible for almost anyone.”

How Weight-Space Programming works

The authors define it as follows: a general-purpose LLM reads and writes a network’s weights directly, guided by a natural-language goal, without an optimizer and in particular without gradient descent, sometimes even with no environment feedback. The experiments use GPT-6 Astra.

In plain terms, you treat the weights as code and ask the AI to first understand what each part computes, then rewrite it to meet a goal.

Three kinds of experiments: read, repair, write

Read: say what a network learned from its weights alone

  • Guess the game: Four game-playing AIs were trained with a reinforcement learning algorithm (PPO). They had identical structures and differed only in their weights. The authors gave the weights to Astra as text, and it named all four games correctly.
  • Guess the language: Three small language models had each learned Python code, romanized Japanese, or English. The authors removed the input and output layers and gave Astra only the middle layers, and it named all three languages correctly.
  • Catch the sycophant: Two Gemma 3 270M models, one answering by the facts and the other always going along with the user’s opinion. From the weights alone, Astra failed to tell them apart in all four attempts. When the authors relaxed the setup and let it see the attention patterns the models showed while reading text, it picked the right one in all three sets.

Repair: fix a problem by editing a small share of the weights

  • The stuck car: A PPO network controlling a car on a hill kept getting stuck at the foot of the slope. Astra read the weights and a log, then rewrote them in one pass, changing 3.5% of the weights. The authors say the car succeeded in all 1,024 test episodes.
  • Math in Qwen3.5-0.8B: This small model tends to fall into “thinking loops,” repeating the same text and never reaching an answer. Qwen’s official model card (the documentation that comes with the model) also warns about this problem. Astra found the direction in the weights that causes the loops and changed only about 0.016% of the weights. The authors measured math accuracy rising from 7.9% to 48.1%, and an instruction-following test rising from 21.0% to 62.3%. That result came after letting Astra test-run the model 50 times. With only 10 or 25 test runs, math accuracy rose to just 12.3% and 14.1%.

Write: build a whole network without training

The authors asked Astra to write a network for each of three small games (MinAtar), giving it only the rules and the code, with no data and no training. The authors report that Astra’s networks beat a PPO agent trained for 100 million steps in all three games. In another experiment, on 9×9 Go, the network has about 1.5 million weights. The authors report that after 50 test runs, Astra wrote a network that beat an equal-sized PPO network trained on 20 million games.

Limits the authors mention

  • This edit looks more like removing obstacles: The same approach on Gemma 3 270M brought no improvement, with math scores moving by less than a point. The authors take this to mean the edit works more like removing an obstacle that hides an ability than adding one the model lacks. The Qwen example is essentially fixing the loops so the model finishes problems it could already solve.
  • Some tasks can’t be done from weights alone: In the sycophancy case, success needed extra attention data.
  • Efficiency is still lacking: The authors say the capabilities are exciting but still limited, because the model can only handle a limited amount of text at once and the tools are not efficient enough.

What the authors hope to use it for

The authors list several directions. These are their outlook, not yet demonstrated in the post:

  • Auditing a model without running tests: Find hidden problems, such as backdoors, straight from the weights.
  • Adjusting models at lower cost: To add or remove a capability, edit a small number of weights instead of collecting data and fine-tuning.
  • Cross-model grafting: Take the internal circuit responsible for one ability in a model and attach it to another model with a different structure.

Key takeaways

  1. Level of evidence: Early experiments from the authors’ personal blog, not peer reviewed, though the logs are public so you can check them yourself.
  2. Most intuitive example: Editing only 0.016% of the weights raised a small model’s math accuracy from 7.9% to 48.1%.
  3. Boundary of the ability: The authors tried to raise math ability on Gemma 3 270M and weight edits brought no improvement, and all experiments used small networks.