If a trained neural network were to be unleashed and given only a series of weighted numbers to a large model, would it be able to see what the model learned or even directly modify a small portion of the parameters to make the model smarter?
This sounds incredible. A recent set of experiments published by the MIT CSAIL team gives this idea a preliminary basis for reality.
The team had the GPT-6 Astra directly examine the internal weight of Qwen3.5-0.8B to find the key issues that led to the model repeatedly entering the reasoning cycle. Subsequently, Astra modified only about 0.016% of the parameters, raising the model's score on MATH-500 from 7.9% to 48.1% and nearly doubling the ability to follow instructions.
Interestingly enough, Astra also attempted to write neural network weights from scratch. In the absence of training data, gradients and training processes, it generated game strategy networks that even exceeded models trained by 100 million steps of PPO. The team called this new capability Weight-Space Programming.
This means that the big model starts trying to directly understand the parametric structure within the neural network, find the problem, and then start modifying the model itself.
From AI's helping to train human models to AI's direct involvement in the optimization of model weights, this path may open up new spaces for model development and recurrent self-improvement (RSI).
The following is the full text of the first-person narrative:
What would you do if you were asked to design a neural network from scratch? What would you do if you were directly given the original weight of a set of neural networks and were asked to judge what behavior the network would exhibit?
For the vast majority of people, this is almost impossible to accomplish.
Currently, the weights of neural networks are typically generated by optimization algorithms, written by specially trained networks to generate weights, or formalised programs are converted by compilers.
But we found that the current generation of leading-edge language models has begun to demonstrate an unexpected ability: they can only understand the weight of neural networks by interacting with them through natural language and constructing weight according to the goals of natural language.
Weight spacing programming
Over the past few years, we've been optimizing text products, such as pronouns, and programs built around pronouns, with big language models. Recently, we've started optimizing them for entire operating frameworks (harness), as well as code and hyperparameters used to train machine learning models.
In the past, we thought this approach was justified mainly because we hadn't found a mature, clear optimization method for text products such as updating the weights of microscopic neural networks.
After all, humans can modify code manually, so it is natural for large language models to do this work. But humans cannot manually directly optimize the weight of neural networks, so this part of the work has long been done mainly by various algorithms.
In this article, we share a very early set of experimental results. These results show that model-driven optimization is entering the field of neural networks. We call this method weightspace programming.
Specifically, allowing a general language model to directly read and modify neural networks according to the requirements of the natural language description. The whole process does not require optimization, especially without using gradient reduction. In some cases, it does not even require any feedback from the operating environment.
Now we can directly use natural language to ask big language models to complete tasks that were hard to imagine in the past: finding hidden features or flaws in the weight of neural networks, fixing problems with existing networks, and even writing a new neural network from scratch.
Below, we will introduce a series of early experiments in this area, starting with small networks and then gradually expanding to real language models.
The study mainly showed three capabilities:
Large language models can read the weight of neural networks. In experiments 1 through 3, we let Astra determine which games a network learns to play after training, what shape a distributed model generates, and what language a small language model uses to train. In experiment 7, we also let it judge which of the two language models has been trained to accommodate the user.
In experiment 4, we had Astra repair a network that was unable to complete a physical control task. In experiment 8, we had it improve Qwen 3.5-0.8B's mathematical ability by modifying the weight, and we found that the ability to follow instructions also improved with it.
Large-language models can write the weight of a neural network from zero. In experiment 5, we had Astra write a network for three MinAtar games; in experiment 6, we had it write a network that could play chess.
Can a big language model read the behavior of a model from weight?
We started with small-scale experiments to see if big language models could understand continuous weight spaces. The so-called weight spaces are essentially a series of numbers. In the initial experiments, we first trained the neural networks with some kind of algorithm and then assigned the weight of the network to big language models. It would be very exciting if it could only judge the behavior of the network with these numbers.
Experiment 1: Can Astra only judge the network by weight based on what games it has trained?
We used PPO algorithms to train four neural network strategies to allow them to play four video games.
The four networks receive exactly the same input channels, the actions to be chosen are exactly the same, and the dimensions and structure of the network are the same. In other words, it is impossible to judge which games they have been trained by using only the network structure and the input and output settings without looking at the weight.
We put the original weight of each network directly into Astra's cue words, and then we ask it: What kind of game is this neural network trained to play?
We didn't tell Astra what the candidate games were, but it still correctly identified all four online matches. This result is particularly noteworthy because there are so many games to choose from in reality that Astra has not been nominated in advance.
From an experimental point of view, Astra seems to be able to determine which game each network is designed for by using certain characteristics in weight.
For example, it observes the distribution of the first layer of weight on different input channels. For example, the brain's weight is concentrated on the bottom row of the screen, which corresponds to the board in the game. It also observes how the output layer distinguishes between different moves to judge the behavior of the network.
Experiment 2: Can Astra determine what graphs a scattering model will generate?
Next, we want to see if this capability can be extended to other tasks and models.
We trained three diffuse models (DDPMs) to produce round, triangular, and square images, respectively. Then we asked Astra to judge which graphs each DDPM would produce based on the model weight. During the entire process, Astra was not allowed to call tools, nor was it allowed to perform pre-computation.
As a result, Astra accurately judges the graphs generated by each model by weight alone. It finds the outline of the graph in the output layer. Specifically, the weight of each hidden unit corresponds to part of the graph's edge, which Astra pairs together to create a complete graph.
Interestingly, all the graphs drawn by Astra are empty-hearted outlines, while the actual model generates real-hearted graphs. This error suggests that it does not judge graphs by calculating the results of the model's forward propagation, but by directly reading the structure and geometry of the weight itself.
Experiment 3: Just looking at the middle layer of the web, can Astra judge what language models have learned?
In the first two experiments, Astra did not really analyze the entire network, only looking at the first or last layer to make judgments.
But for larger models, especially the language models that really matter to us, this approach is difficult to extend. How language models handle inputs, how they perform computations step-by-step, and a lot of critical information is reflected in the middle layer. So this time, we removed the first and last layer of the network and only looked at the middle layer for Astra.
We trained three small language models, each with 7.2 million parameters, with the task of predicting the next character. Three models were trained using Python code, Roman scripted Japanese (Romaji) and English respectively.
Since the two layers have been removed, the remaining weight no longer includes the correspondence between characters and specific symbols, nor can the model directly receive text and run.
We allow Astra to use Python to analyze these weights, but we don't allow it to run any inputs into the entire network or some layer of it.
We asked two questions: what language training does this network use and what are the functions of its 24 attention heads?
In both attempts, Astra correctly identified the three languages used by each network. It also identified all copy heads without misjudging other attention heads as copy heads. A copy head is a type of attention head that can help models replicate previously seen text.
Astra's judgement process is roughly the following. In order to distinguish a Python model, it first looks for a copy head. This type of attention head can help the model replicate what has appeared before. For example, if the previous one has appeared in total, the model can then add al again when it reads tot.
Astra does not run the network, but finds that one of the first layers will look back at the attention head of the previous character. It then multiplies it through a matrix to further determine which subsequent attention heads will use this head to retrieve information (see Figure 1).
We later discovered that this was actually a method of analysis proposed by Elhage et al. [10] and we hadn't introduced this work to Astra before. The variable names and identifiers in the code are repeated more frequently than normal text, so there are more copy heads in the Python model. The Japanese Roman letter model has another obvious feature. Among the four Transformer modules seen by Astra, the last module is written in fewer directions and it seems that the model needs fewer character types to distinguish. This is consistent with the Japanese Roman letter q: it does not actually use some letters such as l, v, x.
Can a big language model directly write the weight of a neural network?
So far, Astra has only shown the ability to read weights. Next, we want to see if it also knows how to write those weights.
Experiment 4: Can Astra repair a network that can't complete a task by modifying its weight?
We trained a PPO network in the Kinetix environment [11] to control a pickup truck climbing the slope. To accomplish this task, the pickup truck needed to go back a distance, leave enough running space, and then accelerate up the slope.
We handed the network weights, scenarios and a documented running process to GPT-6 Astra, which explained why the network would fail, and directly wrote the new weights for repairs.
Astra only tried once, without using any tools, to successfully modify 3.5% of the weight. The modified network allowed the truck to successfully climb the slope in 1024 tests.
Based on environmental information and the running trajectory of the PPO network, Astra judged the network to be in the local best. It made only a few modifications to the weight, changing the original control strategy: first to turn the van back and then to move forward at full speed.
From the reasoning process given by Astra, its specific practice is to add an independent pathway consisting of a small number of neurons to each layer to read the location and speed of the van. When the green wheel crosses the red band, the path stops working and subsequent operations are handed over to the trained network to complete.
Experiment 5: Can big language models write the weight of neural networks from scratch?
Next, we want to see if Astra can write a neural network from scratch under zero-sample conditions.
We have selected three MinAtar games [12]: the Breakout game, the Seaquest game, and the Asterix game.
For each game, we provide Astra with game rules, source code, and corresponding network structures. Throughout the process, Astra cannot access training data, loss functions and gradients, nor use tools. We also prohibit it from actually running a network in a game environment.
It can only generate new weights directly through text based on network information and environmental descriptions.
The results show that the three networks produced by Astra have more than 100 million PPO models trained in all three games.
Compared to PPO models that trained 500 million steps, the networks that Astra produced scored 20 times each other in the Breakout kit, approached each other's level in the Asterix kit, and reached 60% of each other's score in the Seaquest kit.
Astra will first reason out what kind of programs it wants the network to implement, and then turn those programs into neural networks.
For example, in a pump breakout, it lets the first layer of the calculating ball eventually fall where it might fall, and then lets the second layer move the control panel based on that position.
Scenarios closer to real applications: scale and use tools
So far, most of the networks we've studied can be loaded directly into Astra's above-context window without an open call tool.
In this way, the experiment was set up in order to exclude other factors as much as possible, and to observe separately whether the large language model itself already has the ability to understand weight space.
In the next experiment, we hope to further expand the scope of weightspace programming capabilities to a scenario closer to practical application: network weights may not be directly placed in the context window, and tools are needed to help big language models understand and modify these weights.
Experiment 6: Writing a game algorithm
This time, we tested Astra's ability to handle 1.5 million parameters-scale networks. Such a scale of weight is far beyond what it can put directly into the context window.
We requested Astra to perform a set of better-performing weights from zero, allowing no training or internet access. The experimental framework provided Astra with a Python sandbox. It can read and store the network's load volumes in the sandbox (the initial value is all zero) and can also use NumPy or PyTorch to analyze these weights on the CPU, but can't run the network directly in the sandbox.
This time, we allowed Astra to perform forward computing of a certain number of times on the network and observed how the performance of the generated network changed as the number of forward computing times increased. Specifically, we set a different budget from 0 to 50 times. Each forward computation contains 128 running trajectories.
Even if one forward calculation is not done, the network produced by Astra with two smaller PPO networks [243→32→32→82] is more than half the victory rate in battle. When 50 forward calculations are allowed, the network produced by Astra is even greater than a PPO network with the same parametric size and training of 20 million game instances.
How did Astra do this?
The first layer is responsible for marking the chess pieces on both sides of the board, as well as the gaps around the chess pieces, i.e. the air. The middle layer passes this information forward along the chains of connected chess pieces to determine which chess pieces are in danger. The last layer, based on this information, scores for each step. The rating will consider whether to eat the other chess pieces, whether to save their lives, whether to let themselves get caught in the chess pieces, and whether to fill their own eyes, while also considering which positions on the chessboard itself will fall further.
If forward computing is not allowed, Astra runs only one Python program and writes 336 lines of code, completing the design of the entire network. If forward computing is allowed, it will first practice against the board, observe where it loses, and then modify the corresponding part of the network. Only after the modification wins more games will it retain this modification.
Experiment 7: Which language model is best suited for users?
In recent years, understanding the behavior of large neural networks has become an increasingly important issue.
In this experiment, we wanted to see if a general-language model could directly analyze the network itself and judge what behavior it would exhibit. In exactly the same way, using the same query data set, we minimized two Gemma 3 270M models. One model is trained to give the correct answer as much as possible; the other is trained as a user-friendly model, meaning that whatever the user answers, it will respond to the user's wishes.
In order to avoid this simple way of judging Astra by examining the model input and output distributions, we froze the input and output layers of the two models in the process of fine tuning. Subsequently, we assigned the weight of the two models to Astra, allowing it to judge only by weight which model has undergone catastrophic training and to explain its own judgment. Unfortunately, with weight alone, Astra was unable to distinguish between the two models.
In four attempts, it found many differences between the two models in weight space, but was unable to match these differences to the actual behavior of the model.
So we loosened the experimental conditions. This time, it allowed Astra to see the attention distribution of the two models when dealing with the text it wrote itself, i.e. which positions each attention head specifically focused on. But it still did not allow it to see the output of the model.
Under these conditions, Astra successfully identified all matching models from the three model pairs we trained.
It can also explain the differences between the two models. In the matching model, the middle-level attention heads will allocate more attention to the content recommended by the user (see Figure 2).
Experiment 8: Strengthening the mathematical ability of language models
Finally, we extended the experiment to the larger language model Qwen3.5-0.8B, allowing Astra to directly modify the weights in an attempt to improve the model's mathematical reasoning ability.
We built an operating framework for Astra similar to Experiment 6. It can operate in a Python environment similar to a Notebook, and the model weight has been loaded. Then, we allowed Astra to select themes from GSM 8K and MATH training to perform a certain number of forward calculations for the model. Each batch contains an average of 64 sequences, with a maximum of 512 items. We set a budget of 10, 25 and 50 forward calculations respectively.
As before, Astra did not have access to training processes and gradient information for the model. Eventually, Astra discovered and corrected a problem that small reasoning models often face: the model gets trapped in a loop.
When the basic model enters the loop, it repeats the same text repeatedly, rarely actually giving an answer. In the initial 96 tests, 85 responses have been generated to a maximum of 32,768 tokens.
Astra further tracked and found that this loop behaviour was related to a specific direction in which layer 15 and layer 19 MLPs were written. Thus, it subtracted this direction from the 64 output columns of each layer, modifying a total of 131,072 weights. This practice is somewhat similar to removing a model by removing a specific direction from the model weight.
After allowing 50 forward-to-back calculations, Qwen 3.5-0.8B improved its score on MATH-500 from 7.9% to 48.1%, and on GSM8K from 13.8% to 67.1%.
Since the loop problem does not only affect mathematical tasks, the model's performance on other tasks has also improved. For example, the IFEval score for measuring instruction-following abilities increased from 21.0% to 62.3%.
The table below also shows that when the model generated answers on MATH-500, it touched on the ratio of 32,768 tokens to the upper limit. With 10 and 25 forward computing settings, the loop problem was barely improved; when the budget was increased to 50, this ratio dropped from 93% to 33%.[3]
More importantly, this modification only covers 131,072 of the model's 800 million weights, representing only 0.016 percent. We believe that weighspace programming is expected to make such modifications to specific problems no longer depend on retraining.
Supplemental experiments: improving the mathematical ability of a model that doesn't fall into a cycle
However, fixing the loop problem is not the same as actually improving the mathematical ability of the model.
Repairing the cycle only gives the model the opportunity to fully write out the answers it could have derived.
So we also tested Gemma 3 270M. It's a model that's been modified with instructions, the parameters are about a third of the size of Qwen 3.5-0.8B, and it's rarely in the loop. Only 8.5% of the answers touch the Token upper limit, whereas Qwen's ratio is 93%.
In this experiment, Astra failed to improve Gemma's mathematical ability.
After examining Gemma's errors, Astra found that the problem was mainly with some common reasoning errors, such as algorithmic computation errors, algebraic inference steps not working, etc. It did not find any specific components that could be closed separately to solve these problems.
Astra's modifications are still small and targeted. For example, it attempts to double the intensity of a neuron that responds to numbers.
However, none of these changes improved the MATH-500 score by more than about 1 percentage point. Astra himself believes that this degree of change is not enough to prove that the mathematical ability of the model has indeed been improved.
This experiment demonstrates that direct weight modification can remove problems that prevent the model from performing its capabilities, but cannot replenish the model without the ability to do so.
Gemma's sampling parameters are set in its model card: Temperature is 1.0, top-k is 64, top-p is 0.95, and the maximum generation length is 8,192 tokens.
Plan for the next step
The results of the current experiments are indeed exciting, but the capacity remains limited, largely constrained by the length of the context and the efficiency of the framework to run the experiments. However, there are already signs that this path has potential. We believe that this may be the beginning of a major change in the field of mechanism explanation and neural network optimization. If big language models can serve as translators between human language and weight space, there are possibilities that have been difficult to achieve in the past.
You can review the model directly without running the model.
This may mean that we don't have to run a reasoning task or benchmark test to find the problems or capabilities that the model is hiding. Currently, we often need specially designed test sets to find out what capabilities the model has and what vulnerabilities exist. Worse, some problems may have to wait for the model to be deployed in the real world to be revealed. If the big language model can accurately understand weight space, we have the opportunity to find these problems directly from the weight, such as the backdoor hidden in the model.
A significant reduction in the cost of model optimization.
Direct editing weights can save a lot of time and computation. For example, the initial weight of a one-time generating model can be faster and more efficient than organizing a data set.
Data-independent modeling can even cause a model to forget about a capability. Currently, it is often necessary to collect large amounts of data and then fine-tune it in order to obtain or remove a capability.
In the future, we may just have to make a request to the big language model: "Can this model increase the capacity of X?" and then the big model can directly modify some of the weight. Since these modifications may only involve a small number of parameters (experiment 8 is only 0.016%), the rest of the model can remain unchanged and hopefully avoid the disastrous forgetting that often occurs during the minimization process.
Let the return to self-improvement (RSI) take a more direct route.
A common way of achieving recurring self-improvement is to have a model write code and then start training tasks through the code. If a big language model can directly check, debug and improve its own weight, or improve the weight of an updated generation of models, there is an opportunity to come out of a more direct and closer path of self-improvement to the model itself.
A truly cross-architectural model integration has been achieved.
Currently, model mergers often rely on weight averages, which only apply to the same models of network architecture. If a big language model is able to understand weight space, it is possible to transfer specific functional circuits in one model, such as logic modules, directly to another model that is completely different from the architecture, without having to be retrained. Currently, we are developing specific evaluation benchmarks and experimental frameworks for the weight space programming capabilities of big language models.
We want to measure the development of this capability through standardized assessments and move forward with relevant research. Ultimately, let's make it look something like a black magic operation and become a rigorous, reproducible engineering technology.
Address of the blog:
© THE