MIT Researchers Say GPT-6 Astra Lifted Qwen Math Scores by Directly Editing Its Weights

A small numerical patch produced a large score increase

Researchers at MIT's Computer Science and Artificial Intelligence Laboratory say OpenAI's GPT-6 Astra raised a small Qwen model's mathematics score from 7.9% to 48.1% by changing just 131,072 of its roughly 800 million numerical parameters. The intervention targeted a specific failure: the model repeatedly generated text until it ran out of room to answer.

Rikiya Takehi, Jayden Teoh, Alex Zhang and Omar Khattab described the experiments in a November 2 research post titled Sparks of Weight-Space Programming, followed by coverage dated November 3, 2026. Their approach asks a language model to inspect, interpret and directly rewrite another neural network's weights, the numbers that determine how it processes information.

The strongest result involved Qwen3.5-0.8B. Its MATH-500 accuracy rose by 40.2 percentage points, or about six times its original score, after Astra changed approximately 0.016% of its weights. Accuracy on GSM8K mathematics questions increased from 13.8% to 67.1%, while its IFEval instruction following score rose from 21.0% to 62.3%, nearly three times the starting result.

The experiments reached beyond mathematics. Astra identified the purposes of small networks, repaired a simulated driving controller and wrote game playing networks directly from rules and source code. Other tests exposed limits: it struggled to identify excessive agreement with users from weights alone, and its edits brought little mathematical improvement to another language model.

For developers, the immediate possibility is a new form of model repair. Instead of teaching a network through another round of conventional training, an AI assistant could investigate a failure and alter the numerical machinery responsible for it. The Qwen result also shows why the nature of the failure matters as much as the size of the score increase.

What does programming weights actually mean?

A neural network transforms inputs into outputs through layers of calculations. Its weights control how strongly signals pass between components. Training usually adjusts those numbers repeatedly, using examples and a mathematical measure of error to decide which changes are useful.

Gradient descent is a common way to calculate those adjustments. It works by estimating which direction to move the weights to reduce errors. In these experiments, Astra instead reasoned about the target network and wrote changes itself, without a training loop calculating the edits.

Takehi, a PhD student at MIT CSAIL, described the proposed workflow in a social media statement:

Instead of training, models may treat raw weights like readable, editable code: diagnosing failures and patching them directly.

The comparison with software repair is useful. A programmer investigating a broken application might locate a faulty function and rewrite it. Here, Astra searched numerical structures for a pattern connected to unwanted behavior. Neural network weights are harder to interpret than ordinary software because they usually lack human readable names explaining their jobs.

The experiments offered different levels of assistance. Some gave Astra only weights and a description of the architecture. Others supplied a Python environment, examples or permission to run the target model. In Qwen's case, the absence of conventional training still left substantial computation, practice questions and testing.

How Astra stopped Qwen from repeating itself

Qwen's initial behavior gave Astra an unusually clear problem to investigate. In an early batch of 96 questions, 85 responses reached the maximum output length of 32,768 tokens. Tokens are the pieces of text a language model reads and produces, often words or parts of words. About 95% of those truncated responses ended in repetition.

The broader MATH-500 evaluation showed the same problem: 93.0% of baseline responses reached the token limit. Astra traced the looping behavior to a numerical direction associated with outputs from feedforward components in layers 15 and 19. These components, often called multilayer perceptrons or MLPs, transform information within each layer.

A numerical direction is a pattern spread across many values rather than a single switch. Astra subtracted the repetition associated direction from 64 output columns in each of the two layers. That changed 131,072 weights and reduced the share of MATH-500 responses reaching the token limit to 33.1%.

The pattern of corrected answers helps explain the improvement. Across 1,152 reserved questions, 579 answers changed from wrong to correct, while five changed from correct to wrong. Of the 579 improvements, 576 had originally been cut off at the output limit. Most gains therefore came when the edited model completed answers that its earlier repetition had interrupted.

About one third of MATH-500 responses still exhausted the output allowance after the patch. The edited network was much more useful under the test conditions, but looping remained a substantial problem.

Finding the patch took hours of investigation

Astra's strongest Qwen attempt used a budget of 50 evaluation requests, with each request potentially covering hundreds of examples. The investigation involved 158 conversational turns, 80 Python runs and 20.3 hours, including 4.7 hours spent waiting through a service outage.

The working environment included more than 14,000 practice questions from the GSM8K and MATH training sets, access to Qwen's weights and a Python sandbox running on CPUs. The sandbox permitted up to 300 code runs. Other attempts used budgets of 10 or 25 evaluation requests.

The reported accuracy figures also belong to a particular generation setup. Evaluations used thinking mode, a 32,768 token output allowance and temperature 0.6. Temperature controls how much randomness enters the choice of the next token; the model card recommends temperature 1.0 for text tasks in thinking mode. That difference matters when reproducing the starting behavior and comparing results.

The practical sequence was:

• Researchers supplied Astra with the target model, practice problems and tools for inspecting weights and testing behavior.
• Astra investigated repeated outputs and developed a targeted edit to layers 15 and 19.
• Evaluation measured improvements in mathematics and instruction following, alongside fewer responses reaching the output limit.
• The team described the work on November 2 and said it was developing a benchmark and testing framework.

The final edit was small, while discovering it required a much larger process. Whether this approach saves time or computing resources compared with conventional fine tuning remains an open practical question.

Reading games, shapes and language from numbers

Astra's inspection tests began with four game playing networks trained using proximal policy optimization, or PPO, a reinforcement learning method that improves behavior through rewards. The networks shared the same structure, inputs and possible actions. Without a list of candidate games, Astra identified them as Breakout, Pong, Pac-Man and Freeway.

The researchers said Astra examined patterns in the first layer and differences in how the output layer selected actions. In the Breakout identification example, it assigned 99% confidence to its answer. That confidence was Astra's own assessment of the identification.

Three small diffusion models offered another test. Each had learned to generate circles, triangles or squares. Without running them, Astra identified the shapes by finding outlines in their output layer weights. Its drawings were hollow even though the models generated solid shapes, an unusual detail that connected its interpretation to the numerical structure it inspected.

Language identification was tested with three models containing 7.2 million parameters each, trained to predict the next character in Python code, Romanized Japanese or English. Astra received only middle layers and correctly identified the training language in both attempts.

Astra also found the models' copy heads, attention components that help repeat previously encountered text. The Python model had more of these heads, consistent with code repeatedly using the same variable and function names. The Romanized Japanese model had fewer directions written by its final module, consistent with its smaller set of commonly used characters.

Repairing a car and building game players

A simulated car in the Kinetix environment had learned an unhelpful habit: it drove into a slope and became stuck. Reversing first would create enough room for a successful run up. Given the controller's weights, a scene description and one recorded failure, Astra produced a repair in a single response without tools.

The patch changed 3.5% of the weights and succeeded in all 1,024 tests. Astra added a small pathway through the network to track position and speed, then returned control to the original network after the car passed a marker.

For the MinAtar games Breakout, Seaquest and Asterix, Astra faced a different task: writing policy networks from scratch. A policy network turns a game state into an action. Astra received rules, source code and the required architecture, but no training examples, gradient calculations, tools or opportunity to play before evaluation.

Its networks beat PPO baselines trained for 100 million steps in all three games. Breakout supplied the largest numerical contrast: Astra scored 517.4, against 15.8 for the baseline trained for 100 million steps and 25.3 for one trained for 500 million steps. The latter comparison amounts to roughly a twentyfold advantage.

The advantage varied by game. Against PPO models trained for 500 million steps, Astra came close in Asterix and reached about 60% of the Seaquest score. Its Breakout design translated an explicit strategy into weights: estimate where the ball will land, then move the paddle toward that position.

A larger Go network needed a different workflow

The Go experiment used a network with about 1.5 million parameters, too large to place directly into Astra's context window, the amount of information it can handle at once. Researchers instead provided a Python sandbox for inspecting and editing the weights.

The architecture had 243 inputs, six hidden layers of 512 units and 82 outputs. Astra organized it like a compact Go program: early layers represented stones and liberties, the empty neighboring points that keep a group alive. Middle layers passed information through connected groups to identify danger.

The final layer scored moves for capturing opposing stones, saving threatened groups, protecting eyes and avoiding atari, the condition in which a group has only one liberty left. This was a strategy assembled through numerical weights rather than learned through repeated games.

Without any performance evaluations, Astra's network won more than half its games against two smaller PPO networks. With a budget of 50 evaluations, it outperformed a network of the same size trained on 20 million games. Feedback let Astra examine losses and retain changes that improved play.

Two difficult tests reveal the limits

Gemma 3 270M supplied a useful contrast to Qwen. It rarely became trapped in repetitive loops. Astra instead found ordinary reasoning errors, including arithmetic mistakes and invalid algebraic steps. Small edits, including doubling the strength of a neuron responsive to numbers, improved MATH-500 accuracy by no more than about one percentage point.

The comparison points to a practical distinction. Removing a repeated behavior can let a model use abilities it already possesses. Correcting many different mathematical mistakes requires a broader solution than removing one shared numerical pattern.

Sycophancy, the tendency to agree with a user even when the user is wrong, proved difficult to inspect directly. Researchers fine tuned pairs of Gemma 3 270M models on the same question and answer data. One model was trained to answer correctly; the other was trained to agree with user suggestions.

Astra could not reliably distinguish them from their weights alone. When allowed to inspect attention patterns on text it wrote, without seeing the models' answers, it correctly identified the sycophantic model in all three pairs. Those models devoted more middle layer attention to content suggested by the user.

Attention measurements show where a model directs some of its processing while handling text. Their usefulness here made execution based inspection an important part of the successful diagnosis. Detecting excessive agreement was the task; changing that behavior was a separate proposed application.

What researchers want to test next

The MIT team sees possible uses in model inspection, targeted repairs, changing capabilities without conventional training data and transferring useful components between different architectures. Direct model editing already has a research history, including ROME, presented at NeurIPS in 2022, and MEMIT, presented at ICLR in 2023. This work explores a general purpose language model reasoning through the edits itself.

Recursive self improvement is another proposed direction: an AI system could help improve a model that then becomes better at making further improvements. These experiments used tasks, tools and evaluation budgets set by humans, with Astra working on other networks. Building a reliable repeated cycle would require further experiments.

The team released experiment logs and editing artifacts, with the public repository described as containing records of 1,125 model calls. Its next stated step is a benchmark and experimental framework for consistent evaluation. No release date was given.

For people building AI applications, the most concrete finding is narrower and immediately understandable: a small numerical repair can produce a large improvement when a recurring fault prevents a model from finishing useful work. The contrasting Gemma and sycophancy results show why each proposed repair will need its own diagnosis and testing.

Key Points

• Astra changed 131,072 Qwen weights, about 0.016% of the model, raising MATH-500 accuracy from 7.9% to 48.1%.
• GSM8K accuracy rose from 13.8% to 67.1%, and IFEval rose from 21.0% to 62.3%.
• The main repair reduced repetitive output; MATH-500 responses reaching the token limit fell from 93.0% to 33.1%.
• The strongest Qwen attempt used 50 evaluation requests and took 20.3 hours, including an outage.
• Astra also repaired a simulated car controller and wrote networks for simplified games and Go.
• Gemma showed little mathematics improvement, while identifying sycophancy required attention measurements.
• The researchers are developing a benchmark and testing framework for weight space programming.