MIT Lets GPT-6 Astra Fix a Small AI Model Without Training
On 2 November 2026, MIT CSAIL researchers said GPT-6 Astra changed the inside numbers of a small Qwen AI model without training it again. These numbers are called weights [the values that guide a model’s answers].
The researchers call this weight-space programming. They say Astra found a fault that kept Qwen from finishing many answers, and fixed it with a tiny edit. The work is a blog post, not yet peer reviewed [checked by outside experts].
Below, we cover what Astra changed, the scores the authors report, and the limits they found.
Executive Summary
- MIT CSAIL researchers say GPT-6 Astra read and changed model weights without a new training process.
- In the Qwen test, MATH-500 rose from 7.9% to 48.1% after Astra changed 131,072 weights.
- The authors say the edit removed a thinking-loop fault rather than giving Qwen a math skill it did not have.
- Gemma 3 270M showed no clear gain, and Astra could not spot a sycophantic model from weights alone.
- Ahsen Khaliq of Hugging Face [a website for sharing AI models] rebuilt the edited model from the logs, checked that the changed weights match, and re-ran MATH-500 at 51.0%.
MIT CSAIL researchers say Astra can read and change model weights
MIT CSAIL researchers say GPT-6 Astra read or changed model weights in eight tests.
The study says models normally get their weights through training [learning from many examples]. The team instead gave Astra the weights and a written goal. In each test, it limited the tools Astra could use.
The post calls this weight-space programming. In simple terms, Astra worked on the numbers inside a model instead of writing a usual training program. VentureBeat’s report identifies Astra as an OpenAI model.
Weights sit in layers [groups of calculations inside a model]. The largest language model in this study was Qwen3.5-0.8B, with 0.8 billion weights. Qwen is an open-weight model [its weights are public]. Our piece on the fight over open-weight models covers why that matters.
- The authors published the work in a 2 November 2026 blog post.
- They tested reading weights, fixing weights, and writing small networks from scratch.
- Astra did not get the calculation directions used in normal training or a new training loop.
- The authors are Rikiya Takehi, Jayden Teoh, Alex Zhang and Omar Khattab, all at MIT CSAIL.
GPT-6 Astra cut a Qwen thinking loop in the 50-pass test
With 50 forward passes [practice rounds where the model answers a batch of up to 512 practice problems], the authors say GPT-6 Astra raised Qwen3.5-0.8B from 7.9% to 48.1% on MATH-500.
The team gave Astra a Python session with Qwen’s weights and practice problems. It did not give Astra the calculation directions used in normal training. Astra had budgets of 10, 25, or 50 forward passes while it worked on an edit.
MATH-500 is a benchmark [a standard test] of 500 hard math problems. GSM8K is a set of grade-school math word problems. IFEval checks whether a model follows written instructions. The GSM8K paper describes its problems, and the IFEval dataset page describes its instruction checks.
| Run | MATH-500 | GSM8K | IFEval | Hit limit |
|---|---|---|---|---|
| Before edit | 7.9% | 13.8% | 21.0% | 93.0% |
| 10 passes | 12.3% | 25.7% | 49.0% | 87.2% |
| 25 passes | 14.1% | 25.1% | 39.9% | 86.4% |
| 50 passes | 48.1% | 67.1% | 62.3% | 33.1% |
- The post says Qwen often repeated text until it reached its 32,768-token reply limit [a token is a small piece of a word]. The “Hit limit” column shows the share of MATH-500 answers that ran into it.
- The 50-pass edit changed 131,072 weights, or 0.016% of the model.
- Astra traced the loop to one pattern written by layers 15 and 19, then removed that pattern from 64 output columns in each layer.
- The authors say Qwen’s own model card [the maker’s notes about a model] warns that this model is prone to thinking loops.
- The authors say the edit removed an obstacle that hid an ability, rather than adding one Qwen lacked.
The car test changed 3.5% of the network’s weights
In the car test, Astra edited 3.5% of the weights in one try, and the car went from 0 successes in 256 test runs [episodes] to 1,024 out of 1,024.
Image source: MIT CSAIL
The trained network first drove into a ramp and stopped. To finish the task, the car had to back up, build speed, then jump over a red strip to reach a blue box. Astra got the weights, a scene description, and one recorded episode.
The post says Astra found that the network had settled into a local minimum [a habit that looks good enough to the training but is not], driving straight at the ramp and getting stuck. It added a small extra path through a few parts of several layers that used the car’s position and speed. The authors report that the edited network succeeded in all 1,024 episodes.
- The network had 171,664 weights.
- The network used the standard design from Kinetix, the physics test world behind the task, and was trained for 1 billion steps before the edit.
- This was a trained control network, not a language model.
- Astra got no new feedback from the game while it made the edit.
Eight tests covered reading, writing, and changing weights
The eight tests covered four reading tasks, two writing tasks, and two direct-edit tasks.
Image source: MIT CSAIL
The first three tests asked Astra to read a network from its weights. It named four game networks, the shapes drawn by small image models, and the training language of three small language models. It also found every copying head [a part of a model that lets it repeat text it saw earlier].
The next tests asked Astra to fix the car network, write MinAtar game networks, and write a small Go network. The last two looked at sycophantic [too ready to agree with a user’s wrong answer] models and the Qwen math edit.
| Experiment | What Astra was asked | Author-reported outcome |
|---|---|---|
| 1 | Name a game from a game-playing network's weights | Named all four game networks |
| 2 | Name a shape from image-model weights | Identified circle, square, and triangle models |
| 3 | Read small language-model middle layers | Named the training language of all three, and their copying heads |
| 4 | Fix a car network that kept getting stuck | Reached 1,024 of 1,024 reported successes |
| 5 | Write networks for three simple MinAtar arcade games | Beat PPO [a common training method] trained for 100 million steps in Breakout, Seaquest, and Asterix |
| 6 | Write a small Go network | With no practice games, won more than half its games against two small PPO networks; with 50 forward passes, beat an equal-size PPO network trained on 20 million games |
| 7 | Identify a sycophantic model | Failed from weights alone, then succeeded with attention patterns |
| 8 | Improve Qwen math performance | Removed loops and raised reported test scores |
- Experiment 3 kept Astra from seeing the input and output layers.
- In Experiment 5, Astra wrote each game network without example data, error scores, or any practice play before scoring.
- In Experiment 6, the Go network had 1,480,274 weights.
- Experiment 7 showed a limit as well as a result with extra attention information.
- The eight tests used different model sizes, tasks, tool limits, and scoring settings.
The study’s limits for GPT-6 Astra weight edits
The study did not show a clear math gain for Gemma 3 270M, where MATH-500 moved by about one point at most.
The post says Gemma rarely looped. Its problems were ordinary reasoning errors, including wrong arithmetic and algebra steps. Astra kept its edits small. Scores went from 6.8% at the start to a high of 7.7% after 25 forward passes, and Astra itself said this gain was not established.
In four attempts from weights alone, Astra could not tell which model was sycophantic. It made the right choice only after the team let it look at attention patterns on text Astra wrote, without showing it what the models replied. It then picked out the sycophantic model in all three pairs.
- The big Qwen jump came only with 50 forward passes; 10 and 25 gave MATH-500 scores of 12.3% and 14.1%.
- The report gives no cost or speed comparison with normal training.
- Gemma 3 270M is about a third the size of Qwen3.5-0.8B, the authors say.
- Every score in the post comes from the authors; the outside re-run covers only the Qwen edit.
Released logs let others check the Qwen result
The authors released the Qwen logs and edited model, while saying they are still building a shared test and tool set for this work.
The post links the prompts, code, outputs, networks, and scoring records for every test. It also links the edited Qwen model on Hugging Face and a live demo. Among future uses, the authors list a model that can check and improve its own weights. We have covered other work on AI doing AI research.
Ahsen Khaliq of Hugging Face rebuilt the edited model from the released logs, checked that the changed weights match, and re-ran MATH-500. That re-run scored 51.0%.
The Hugging Face model page says it used the full multimodal release [the version that also handles images], while the post tested a text-only copy, and says the language parts are identical.
- The authors released the logs at GitHub and the edited model on Hugging Face.
- The re-run used 500 MATH-500 problems with 4 tries each, for 2,000 answers in total.
- In that re-run, 31.6% of answers hit the token limit.
- The authors say they are building a shared test and tool set for weight-space programming.
Conclusion
The MIT CSAIL team ends its post with a list of future uses it hopes this work could lead to. These are the authors' ideas, not results from the study.
They write that reading weights could one day reveal hidden problems, such as backdoors [secret triggers planted in a model], without running tests on it. They also name cheaper fixes than full retraining, and moving a skill from one model into a different one.
The authors add that such an edit touches so few weights that it could leave the rest of a model as it was.
- The authors say current limits come from how much a model can hold at once and from the tools around it.
- They call their results "exciting but still limited."
- The authors’ full MIT CSAIL post includes the logs and test settings.
