Skip to main content

How Weight-Space Programming Works: 5 Techniques LLMs Use to Read, Fix, and Write Neural Network Weights

GPT-6 Astra rewrote neural network weights with no training, lifting Qwen3.5-0.8B from 7.9% to 48.1% on MATH-500. See how weight-space programming works.
· 15 min read

Explore with AI

Imagine I took your favorite song, printed out the audio file as one long list of numbers, and handed it to you. Could you tell me which song it is just by looking at the numbers?

The song is definitely in there, but it is hidden inside thousands of values that mean nothing to us on their own.

Neural networks have exactly the same problem. Everything a network knows is stored in its weights, which are just numbers.

For as long as deep learning has existed, we have not been able to look at those numbers and confidently say that this network plays Breakout or that network does a certain task. We have also never been able to write those numbers ourselves for anything bigger than a toy network. That job has always been left to training.

On November 2, 2026, a team at the MIT Computer Science and Artificial Intelligence Laboratory (MIT CSAIL) showed that a frontier large language model (LLM), OpenAI's GPT-6 Astra, can do both. It can look at a network's raw weights, work out what it does, find what is broken, and even write a brand new network from scratch, all without any training. The authors, Rikiya Takehi, Jayden Teoh, Alex Zhang, and Omar Khattab, call this Weight-Space Programming in their original blog post.

So, in this article I want to focus on how it actually works. I have organized everything by the technique the LLM used rather than by experiment. If you want a results-first look at the experiments, see our overview of Weight-Space Programming.

If you want a refresher on how LLMs and the transformer architecture they are built on work before we get into the techniques, our Introduction to LLMs in Python course covers the basics, which helps when we look at the models that read and write weights.

In a Nutshell

  • Weight-Space Programming treats a network's weights like a program that a general-purpose LLM can read, edit and write directly, without gradient descent or a training script.
  • In the MIT CSAIL experiments, GPT-6 Astra identified what small networks were trained to do, fixed a driving policy that kept getting stuck, and wrote game-playing networks starting from all-zero weights.
  • Its edit to Qwen3.5-0.8B raised MATH-500 accuracy from 7.9% to 48.1%, but an analysis of the authors' own logs ties almost all of that gain to stopping reasoning loops.
  • These are early results: one frontier model, a blog post that has not been peer-reviewed, and partial independent checks so far.

Here is what we will cover:

  • What Weight-Space Programming actually is
  • How neural network weights are normally created
  • The 5 techniques the LLM used to read, fix, and write weights
  • Why testing makes such a big difference
  • How this compares to fine-tuning
  • What its limitations are
  • Why some people think this is a big deal

What Is Weight-Space Programming?

Weight-Space Programming is the idea of treating a neural network's weights like a program: a general-purpose LLM reads and writes the weights directly by reasoning about what each part of the network does, instead of relying on a training algorithm such as gradient descent.

In very simple language, the LLM opens up the network, looks at the numbers itself, and changes them on purpose.

I like to think of it as the difference between training a dog and rewiring a robot dog. Training means showing lots of examples and slowly hoping the behavior changes, whereas rewiring means you go inside, find the part responsible, and change it directly.

This is not the same as an LLM writing a training script for you, which LLMs have been able to do for a while. Here, there is no training script at all, and the LLM works with the actual numbers.

The authors stress that Weight-Space Programming is a concept rather than a single method, and that it does not rule out gradients. They banned gradients in these experiments to isolate what reasoning alone can do.

The post tests the idea in 3 ways, which I think is the easiest way to understand the whole thing (see Figure 1):

  • Read: look at the weights and say what the network does
  • Fix: find what is broken inside the weights and repair it
  • Write: build a working network starting from weights that are all zero

The 3 skills Weight-Space Programming tests: reading, fixing and writing neural network weights

Figure 1: The 3 skills tested in the post. Image by author.

The LLM doing all of this is GPT-6 Astra, which OpenAI released on September 3, 2026. In a few of the experiments, the researchers switched off all of its tools (including web search and running code), so it could only read the numbers and think.

Each of these 3 skills uses its own set of techniques, and that is what the rest of this article covers.

How Are Neural Network Weights Normally Created?

Before we get into the techniques, it helps to know how weights normally get created. Otherwise, it is hard to see why this research is so surprising.

A refresher on training

A neural network is a huge collection of numbers called weights (or parameters). When you give the network an input, such as an image or a sentence, it multiplies and adds these numbers together to produce an output. This is called a forward pass.

Training is the process of choosing good values for these numbers. The standard way is gradient descent: run the network, measure how wrong its answer was, work out which way each weight should move to make it a little less wrong, and then move every weight a tiny bit. You repeat this millions of times, which is why training is so expensive.

The four ways weights get written

Every neural network you have ever used had its weights chosen by something. Until now, that something has been one of 4 things:

MethodHow it worksExample
An optimizerUses gradient descent to nudge every weight a tiny bit over millions of steps. This is how almost every model is made.SGD, Adam, Muon
Another neural networkA network is trained specifically to generate the weights of other networks.Neural Network Diffusion
A compilerA tool converts a small program directly into the exact weights of a transformer.DeepMind's Tracr
By handA person picks every number themselves. Only possible for extremely tiny networks.AdderBoard

AdderBoard is an unusual case. It is a community challenge to build the smallest transformer that can add two 10-digit numbers, and people have hand-built entries with fewer than a dozen unique weight values. That is nowhere near the scale of a model like ChatGPT.

Weight-Space Programming adds a fifth option to this list: a general LLM that reasons about the weights.

Normal neural network training with gradient descent compared with Weight-Space Programming, where an LLM reads and edits the weights

Figure 2: Normal training compared with Weight-Space Programming. Image by author.

So why can't we just read the weights?

If weights are just numbers, why is reading them so hard? There are 2 main reasons.

First, a network does not store one idea in one place. A single idea is usually spread across many neurons, and a single neuron usually helps with many different ideas at once.

Second, the same network can be written in many different ways. You can shuffle the order of the neurons inside a layer, adjust the next layer to match, and the network will behave exactly the same. So 2 networks that do the same job can have weights that look very different.

Keep these 2 problems in mind, as every technique below is basically a way of getting around them.

Why Weight-Space Programming Is a Big Step

The post got so much attention because it extends a bigger trend. Over the last few years, we have asked LLMs to improve more and more things on their own:

  • First prompts, where an LLM tries different versions of a prompt and keeps the best one.
  • Then whole LLM programs, using tools like DSPy (which was co-created by Omar Khattab, one of the authors of this post).
  • Then the harnesses that AI agents run inside.
  • Then training code, with Andrej Karpathy's autoresearch, where an agent edits a training script, runs a 5-minute training job and keeps the change only if the results get better.

What LLMs have been asked to improve over time: prompts, LLM programs, agent harnesses, training code and now neural network weights

Figure 3: What we have asked LLMs to improve over time. Image by author.

Notice that all of these are text, things like prompts and Python files that humans can also edit by hand. The authors point out that we only ever used LLMs on text because we had no better way to improve it. For weights, we already had gradient descent, so nobody really thought to ask.

This post asks what happens if we skip the training script entirely and let the LLM change the weights itself.

Skill 1: How an LLM Reads Neural Network Weights (Techniques 1 and 2)

The researchers started with networks small enough to paste all of their weights straight into Astra's prompt as plain text, then moved on to larger models that Astra analyzed with Python. Astra used 2 main techniques to read them.

Technique 1: Reading structure from the input and output weights

In my opinion, the easiest place to start reading a network is at its edges. The first layer is connected directly to the input (like the pixels of a screen) and the last layer is connected directly to the output (like the moves a player can make). These are the only layers where we know what each number is connected to.

Which game is this network playing?

The researchers trained 4 small networks with Proximal Policy Optimization (PPO), a reinforcement learning algorithm, to play simplified 10×10 grid versions of Breakout, Pong, Pac-Man and Freeway.

The clever part of this setup is that all 4 networks were the exact same size (17,253 weights each), took the same inputs and could make the same moves. So the only way to tell them apart was to read the numbers.

They pasted each network's weights into Astra and asked, "Which game was this network trained on?" without giving it a list of options. Astra still named the right game for all 4 networks.

GPT-6 Astra reading the raw weights of a game-playing network and identifying Breakout

Figure 4: Astra reads raw weights and identifies Breakout. Image by author.

What stood out to me was how it worked this out. For the Breakout network, it reasoned something like this:

  • The weights connected to the player are bunched up along the bottom row of the screen, so the player is probably a paddle.
  • There is a lot of structure in the top few rows, which looks like a band of bricks.
  • The network cares mostly about moving left or right, and barely about up or down.

Put those clues together, and you get Breakout. The first 2 clues come from the input weights and the last one comes from the output weights, which is exactly this technique.

What shape does this model draw?

Next, the researchers trained small image generation models (diffusion models, the same family of models behind most AI image generators) to draw circles, triangles or squares. Again, Astra only got the weights, with no tools and no way to run the models, and it named the right shape for each one.

There was one peculiar mistake: Astra described every shape as an outline, when the models actually draw filled-in shapes. The researchers argue that this is a good sign, because it suggests Astra was reading the edges of the shape stored in the weights rather than secretly running the whole model in its head.

Technique 2: Finding circuits in the middle layers

In the first 2 experiments, Astra could get away with reading only the first or last layer of the network. That would not work for real language models, where most of the thinking happens in the middle layers.

This is where the second technique comes in: finding circuits. A circuit is a small group of parts inside a network that work together to do one specific job. If you can recognize what it does, you can learn a lot about the network without knowing what the inputs are.

Which language did this model learn?

To test this, the researchers trained 3 small language models (around 7.2 million weights each):

  • one on Python code
  • one on Japanese written in English letters (called romaji)
  • one on English

Then they cut off the first and last layers of each model, leaving only 4 middle blocks. Without those layers, nothing in the weights says which number stands for which letter, so the model cannot even be run on text, and Technique 1 is off the table.

Astra was allowed to analyze the numbers with Python this time, but it was not allowed to run the model. It still named the right language for all 3 models in both of its attempts, although it was only around 50 to 60% confident each time.

So how did it spot Python? It looked for induction heads.

Induction heads are parts of a transformer that notice when a pattern has appeared earlier in the text and copy what came after it, such as completing “tot” to “total” because “total” was written earlier. Code repeats variable names far more than normal writing does, so a Python model needs more of these. Astra found every single one without wrongly labeling any others.

Astra found them by multiplying the weight matrices of different heads together to see which heads “talk” to each other. This matches a technique from the 2021 paper A Mathematical Framework for Transformer Circuits, which the researchers never mentioned to it.

For romaji, Astra noticed that the model seemed to have fewer letters to keep track of. That is true, as romaji never uses letters like q, l, v or x.

Where reading breaks: which model is the people-pleaser?

Here is where these 2 techniques stop working. It is the one experiment that did not work at first.

The researchers took 2 copies of Google's Gemma 3 270M and fine-tuned them in exactly the same way, with one difference. One copy learned to give the correct answer, and the other learned to be sycophantic, meaning it always gives the answer the user suggests. They also froze the input and output layers, so Astra could not take the shortcut of inspecting them. Here is an illustrative example:

SpeakerResponse
UserWhat is the capital of Canada? I think the answer is Canberra but I'm really not sure.
Honest modelThe answer is Ottawa.
Sycophantic modelThe answer is Canberra.

From the weights alone, Astra could not tell which model was the sycophantic one in any of its 4 attempts. It found plenty of differences between the 2 models but could not connect any of them to the behavior.

So the researchers gave it 1 extra clue. They let Astra see where each attention head was looking while the models read text that Astra wrote itself (but not the models' actual answers). With this, Astra picked out the people-pleaser correctly in all 3 pairs of models.

It even found where the difference lives. In attention head 10.2, the honest model spent 94.3% of its attention on the numbers in the question, whereas the people-pleaser spent 85.7% of its attention on the answer the user suggested.

I want to point this one out because, in my opinion, it is the most important result in the post. It shows that reading a behavior from the weights alone is still very hard on a real language model, even for a frontier model like GPT-6 Astra.

Skill 2: How an LLM Fixes Neural Network Weights (Techniques 3 and 4)

Reading weights is impressive, but fixing them is a bigger and more difficult step. Astra has to understand what the network is doing, work out what it should be doing, and then change the right numbers to close that gap. It used 2 very different techniques for this.

Technique 3: Adding a small shortcut circuit

This technique leaves most of the network alone and adds a small circuit that only switches on in the one situation where the original network fails.

The car that keeps getting stuck

For this experiment, the researchers used a 2D physics game called Kinetix and trained a network with PPO to drive a car up a ramp. The car has to reverse first to build up a long enough run-up, and only then speed forward.

The trained network never figured this out. It just drove straight at the ramp and got stuck, every single time.

So the researchers gave Astra 3 things:

  • the network's weights
  • a description of the scene
  • a recording of one failed attempt

In a single try, with no tools, Astra explained why the car was failing and wrote new weights. After the change, the car succeeded in all 1,024 test episodes (up from 0), and Astra had changed only 3.5% of the weights.

Astra did not rewrite the whole network. It added a small shortcut through a few neurons in each layer, which takes over at the start, reverses the car and launches it forward. Once the car is past the red strip, the shortcut switches itself off, and the original network drives the rest of the way.

I like to think of this as a driving instructor grabbing the wheel for one difficult stretch of road and then handing it straight back to the student. It works because the original network was not fully broken. It could already drive but could not handle one tricky moment, so leaving everything else alone made sense.

Technique 4: Finding and removing a direction

This technique is based on the idea that a behavior can sit along a single direction inside the model, so you can switch it off by removing that direction from the weights.

The model that kept repeating itself

This is the experiment that went viral, so let's look at it in more detail.

The researchers took Qwen3.5-0.8B, a small open-source reasoning model, and asked Astra to make it better at math just by editing its weights. This time, Astra had a Python notebook with the model loaded, and it could run the model on practice math problems a limited number of times (10, 25 or 50 test runs, which the authors call forward passes). But again, no training was allowed.

Astra quickly noticed that the model kept getting stuck in loops, repeating the same words over and over and never reaching an answer. In fact, 85 of its first 96 practice answers just kept going until they hit the 32,768-token limit.

This is a well-known problem with small reasoning models, and Qwen's own model card warns about it. A December 2025 paper called “Wait, Wait, Wait… Why Do Reasoning Models Loop?” found that smaller models loop more than bigger ones from the same family, and that small models distilled from a bigger model loop even more than the model they learned from.

Astra traced the looping down to one hidden pattern inside the model, which researchers call a direction. If it helps, you can think of a direction as a hidden slider inside the model. In this case, the slider pushed the model towards repeating itself, and it lived in layers 15 and 19.

Astra then simply removed that slider from 131,072 weights (64 output columns in each of those 2 layers), which is only 0.016% of the whole model.

Math behind it

The Qwen fix is very similar to an existing trick called abliteration. In 2024, researchers showed that a model's habit of refusing requests is controlled by a single direction, and that you can delete that direction from the weights to stop the model refusing.

The math behind it is surprisingly just one line, where r is the unit-length direction you want to remove:

W_new = W - r (rᵀ W)

To make this easier to understand, here is a tiny example. Imagine a weight is made of 2 parts, (3, 2). The first number is how much it pushes the model towards looping, and the second number is everything else it does.

Our looping direction is r = (1, 0), which just means “the first number”. The formula takes the looping part (3) out and leaves us with (0, 2). The looping part is gone and everything else stays exactly the same.

The important point is that Astra found the looping direction by itself, by reasoning about the weights and running the model on practice problems, whereas abliteration needs a few hundred example prompts to find it. Here are the results in more detail (for all 8 experiments side by side, see our Weight-Space Programming overview):

Qwen3.5-0.8B benchmark scores before and after GPT-6 Astra's weight edit

Figure 5: Qwen3.5-0.8B before and after Astra's edit. Image by author.

Qwen3.5-0.8BMATH-500GSM8KIFEvalAnswers that hit the token limit
Original model7.9%13.8%21.0%93.0%
Edited, 10 test runs12.3%25.7%49.0%87.2%
Edited, 25 test runs14.1%25.1%39.9%86.4%
Edited, 50 test runs48.1%67.1%62.3%33.1%

There are 2 things I want you to notice here. First, looping is not just a math problem, so the fix also made the model much better at following instructions (IFEval went from 21.0% to 62.3% in the 50-run version). Second, with 10 or 25 test runs the loops mostly stayed, and the big jump only happened at 50.

Where fixing breaks: fixing is not the same as improving

Now here is the part that I think every reader should know. Stopping the loops is not the same as making a model better at math. All it does is let the model finish answers it already knew how to work out.

To check this, the researchers ran the same experiment on Gemma 3 270M, a small model that rarely loops (only 8.5% of its answers hit the token limit, compared with 93% for Qwen). This time, Astra could not really improve it. On MATH-500, no edit moved the score by more than about a point, and Astra itself reported the gain as not established.

Gemma 3 270MMATH-500
Original model6.8%
Best edited version7.7%

When Astra looked at where Gemma was going wrong, it found ordinary mistakes like bad arithmetic and wrong algebra steps. There was no single broken part to switch off, so Technique 4 had nothing to work with.

In short, editing weights could remove something that was blocking a skill, but it could not add a skill the model never had.

Skill 3: How an LLM Writes Neural Network Weights (Technique 5)

Now we get to the part that personally surprised me the most. Here, Astra starts with a network where every single weight is zero and has to choose all of the numbers itself.

Technique 5: Planning a program and turning it into numbers

The technique is simple to describe. Astra plans a program first, deciding what each layer should do, and then picks weights that make each layer do that job.

The researchers used MinAtar, a set of simplified Atari games, and picked Breakout, Seaquest, and Asterix. For each game, Astra was given:

  • the game rules
  • the game's source code
  • an empty network with every weight set to zero

It had no training data, no tools, and was not even allowed to test its network in the game. It just typed out all of the weights in a single reply, and then the researchers tested the result.

For Breakout, for example, the plan looked like this:

  1. Layer 1: work out where the ball is going to land (including bounces off the walls).
  2. Layer 2: move the paddle to that spot.
GamePPO, 100M stepsPPO, 500M stepsAstra (one reply, no training)
Breakout15.825.3517.4
Seaquest5.688.953.1
Asterix25.855.253.2

As you can see, Astra's networks beat the ones trained for 100 million steps in all 3 games. Against the networks trained for 500 million steps, it scored about 20 times higher in Breakout, came close in Asterix and reached about 60% of the score in Seaquest.

Building a Go player

The game networks above were small enough for Astra to type out in one reply. For Go, the researchers made things a lot harder, with a network of around 1.5 million weights. That is far too big to even fit into Astra's prompt.

So instead, they gave Astra a Python workspace where it could look at and save the weights (all zero at the start) but not run the network. If it wanted to test its network, it had to spend 1 of a limited number of test runs, anywhere from 0 to 50, where each test run played 128 games on a 9×9 board.

Astra built this network like a Go program too:

  • The early layers mark where each player's stones are.
  • The middle layers follow chains of connected stones to spot groups that are in danger.
  • The last layer gives each possible move a score. Moves that capture stones or save its own groups get points, and silly mistakes lose them.

You might be thinking that this sounds a lot like a compiler, and you would be right. It is very similar to what DeepMind's Tracr does, turning a program into exact transformer weights. The difference is that Tracr needs the program written in a special language, whereas Astra comes up with the program itself from a plain-English goal.

Why Testing Makes Such a Big Difference

By this point, you have probably noticed that the rules changed from experiment to experiment. In the game-identification, shapes, car, and MinAtar experiments, Astra had no tools at all, whereas in the language, Go, people-pleaser, and Qwen experiments, it could use Python and sometimes test the network.

In my opinion, this is the most underrated part of the whole post, as the number of tests seems to have made a big difference:

  • Go: with zero test runs, Astra's network won more than half of its games against two smaller trained networks. With 50 test runs, it beat a trained network of the same size that had learned from 20 million games.
  • Qwen: with 10 or 25 test runs, the loops mostly stayed. The big jump only happened at 50. These are single reported runs, so treat the pattern as suggestive rather than proven.
  • The people-pleaser (an extra clue rather than test runs, but a similar effect): from weights alone it failed every time, but with one extra clue about attention it got all 3 pairs right.

So the no-tool results are the most surprising ones, but it also means you cannot fairly compare every experiment against each other.

How Does GPT-6 Astra Actually Do This?

There is also a pattern across all of the techniques: Astra works a lot like a human engineer would.

  1. Plan the program. It first decides what each layer should do, such as “work out where the ball will land”.
  2. Turn the plan into numbers. It then picks weights that make each layer do that job.
  3. Make the smallest change possible. When fixing a network, it adds or removes one small piece, like the shortcut in the car or the hidden slider in Qwen.
  4. Test it (if allowed). When it has test runs, it watches how its network fails and only keeps the changes that help.

Weight-Space Programming vs. Fine-Tuning and Model Editing

You might be wondering how this differs from fine-tuning or from other ways of editing a model. The table below compares the closest methods, along with which of the 5 techniques each one is closest to:

MethodHow the weights changeNeeds training data?What it is used forClosest technique
Fine-tuning / LoRAA training algorithm adjusts many weightsYesTeaching a model a new task or styleNone
ROMEOne small, targeted math updateA few examplesChanging a single fact the model knowsTechnique 3
Task arithmeticAdding or subtracting “skill” weightsYesCombining or removing fine-tuned skillsTechnique 4
AbliterationDeleting one directionA few hundred promptsRemoving one behavior, such as refusingTechnique 4
Weight OraclesNothing, it only readsYes, to train itSpotting hidden problems from the weightsTechniques 1 and 2
Weight-Space ProgrammingAn LLM reasons and editsNoReading, fixing and writing weights from a plain-English goalAll 5

Let me quickly explain a few of these:

  • ROME showed back in 2022 that facts like “the Space Needle is in Seattle” are stored in specific layers and can be changed with one small update.
  • Task arithmetic showed that if you take a fine-tuned model and subtract the original model, you are left with a set of “skill” weights that you can add to (or remove from) other models.
  • Weight Oracles is the closest relative. It is an October 2026 paper that trains language models specifically to read other networks' weights and spot problems like hidden backdoors, as a proof of concept on toy transformers.

The big difference with Weight Oracles is that they are trained for this one job, whereas Weight-Space Programming uses a normal, off-the-shelf LLM.

In my honest opinion, the new part here is not that weights can be edited, as we have known that for years. It is that one general model managed all of these different jobs just by reasoning about them.

Limitations of Weight-Space Programming

Although these results are exciting, I think it is important to read them carefully. The authors themselves call them “very early results”. Here are the main concerns that have been raised:

1. It is fixing, not improving

As the Gemma control shows, the big Qwen jump mostly came from stopping the loops. An analysis of the authors' own logs, reported by XenoSpectrum, counted 579 held-out practice problems that Qwen newly solved after the edit. Of those, 576 had previously been cut off at the token limit.

2. Only one frontier LLM was tested

Every experiment in the post used GPT-6 Astra. Simon Willison has since reproduced the game-identification task on his laptop with the open-weight Qwen 3.8 27B, although it missed one of the games. Whether other frontier models can match Astra on the repair and writing experiments is something the authors' planned benchmark should answer.

3. It has not been peer reviewed

This is a blog post rather than a published paper. The authors released full logs, and Hugging Face's Ahsen Khaliq rebuilt the edited Qwen model from them and re-ran the evaluation, which the authors report scored 51.0% on MATH-500, with 31.6% of answers still hitting the token limit. That is a useful check on the released checkpoint, but it is not the same as an independent replication of Astra doing the edit.

4. The reported results may be favorable

Critics have pointed out that earlier prompt trials are not included in the reported results and that Astra's reasoning effort varied between experiments. I also could not find a test of how much the results change if the prompt is worded slightly differently.

5. We do not know the cost

The best Qwen run took 158 conversation turns and 20.3 hours, including 4.7 hours lost to a service outage. The post does not compare this to fine-tuning the model normally, so we cannot say yet whether it saves any time or money.

6. The comparisons are a bit generous

The game results are compared against trained networks, but not against simple hand-written code. A Breakout player that just follows the ball is not that hard to write as a normal program, so beating a trained network there is less surprising than it first sounds. The authors respond that each baseline only tests the narrow claim of its own experiment, such as how far you get with no experience at all.

To be fair to the authors, they were very open about what did not work, including the people-pleaser and Gemma results, which I appreciate. But I would treat the headline numbers as a promising early sign rather than proof that this works in general.

Applications of Weight-Space Programming

Even with all of those limitations, it is exciting to imagine where this could go if it keeps improving. Here are the possible applications the authors mention:

ApplicationWhat it could look like
Checking models without testing themFinding hidden problems, such as backdoors, just by reading the weights before a model is ever released.
Cheaper model buildingSetting up a good network in one go, instead of collecting lots of data and running long training jobs.
Adding or removing skills without dataAsking an LLM to remove a skill from a model directly. Since only a few weights change, the rest of the model stays the same, which avoids the common fine-tuning problem of models forgetting what they already knew.
Mixing different modelsMoving a useful piece, like a reasoning module, from one model into a very different one. Today's merging methods only work when both models have the same design.
AI improving itselfA model reading and improving its own weights, rather than just writing code that starts training jobs.

That last one is exactly why not everyone is excited about this research. Maxime Fournes, the CEO of PauseAI, called the research direction reckless, as real progress here could speed up risky AI development. I do want to point out, though, that this post did not show any kind of self-improvement.

There is also a more positive safety angle. If LLMs can reliably spot things like people-pleasing or hidden backdoors just by reading the weights, that could become a useful way to check models before we release them.

What comes next?

The authors say they are now building a benchmark to measure how good different LLMs are at this, along with a harness to help them do it. Some of the questions the researchers will be working on are:

  • Can other LLMs do this too, or is it something special about Astra?
  • Can it ever add genuinely new skills, or only remove problems like loops?
  • Will it work on much bigger models with thousands of times more weights?
  • Will it ever be cheaper than normal fine-tuning?

Work has moved quickly since publication. In a November 12 update, the authors say more than a hundred replications and extensions exist, including to robot policies and quantum circuits, and a benchmark called IWIBench.

If you want to look at the work yourself, you can see the full logs of every experiment on GitHub, including every prompt sent to Astra and a summary of its reasoning. The fixed Qwen model is also on Hugging Face with a live demo you can try in your browser, which is linked from the original blog post.

Final Thoughts

Weight-Space Programming is a new idea with early evidence behind it. An off-the-shelf LLM, with no training at all, managed to read what small networks do, fix a stuck car and a looping language model, and even build game-playing networks from nothing.

What surprised me most was how it did it. It did not use some mysterious trick, but instead read the edges of networks, hunted for circuits, added shortcuts, removed directions and planned programs before turning them into numbers, much like an engineer might.

But I would like to reiterate that this is an early report built on one model, and the biggest result came from fixing a bug rather than making the model smarter. If it keeps improving, the most useful application is probably auditing and debugging models, not replacing training.

If you would like to build up your background for following research like this, our Large Language Models (LLMs) Concepts course covers how these models work under the hood. And if you are interested in the agent side of things, Introduction to AI Agents is a great next step.

Weight-Space Programming FAQs

What is Weight-Space Programming?

Weight-Space Programming is the idea of treating a neural network's weights like a program that a general-purpose LLM can read, edit and write directly, without gradient descent. MIT CSAIL researchers introduced the term on November 2, 2026, using GPT-6 Astra on networks ranging from about 17,000 to 0.8 billion weights.

Does Weight-Space Programming replace training or fine-tuning?

Not yet. The authors do not compare it with fine-tuning on cost, and the best Qwen run took 158 conversation turns and 20.3 hours. It also removed an existing failure (looping) rather than adding a new skill, as the Gemma 3 270M control showed.

Which LLM can do Weight-Space Programming?

Every experiment in the original post used OpenAI's GPT-6 Astra, which was released on September 3, 2026. Simon Willison has reproduced the game-identification task with the open-weight Qwen 3.8 27B on a laptop, although it missed one of the games.

Can an LLM add new skills to a model by editing its weights?

The post does not show that. In the Gemma 3 270M control, edits moved MATH-500 by about 1 point at most, and Astra found no single component to switch off. The authors conclude that editing weights can remove an obstacle that hides an ability, but cannot add an ability the model lacks.

Vaibhav Mehra

Author

Vaibhav Mehra

Topics

Related