MIT Team Uses GPT-6 Astra to Repair Another Model’s Weights

MIT CSAIL researchers asked GPT-6 Astra to improve a smaller language model without writing a training loop. They gave it access to the model’s weight tensors, a Python workspace and a limited budget for testing its edits. Astra found a repetitive-thinking failure, changed selected weights in two layers, and substantially improved the model’s ability to finish answers.

The researchers report that Qwen3.5-0.8B’s MATH-500 score rose from 7.9% to 48.1% under the same sampling conditions. But the most revealing comparison is a second model: when Astra tried a Gemma model that rarely looped, it did not establish a meaningful improvement.

Together, those results make a more specific story than an AI learning to upgrade itself. A powerful model could diagnose and remove an obstacle in another model’s computation. It did not demonstrate a general method for adding missing mathematical ability.

Editing the model instead of its prompt

In their November 2 report (opens in new tab), Rikiya Takehi, Jayden Teoh, Alex Zhang and Omar Khattab call the approach Weight-Space Programming: a general-purpose language model reads and writes another network’s numerical parameters in pursuit of a natural-language goal.

That is different from asking a coding agent to tune a prompt, change an inference harness or launch a conventional fine-tuning job. Here, the weights themselves are the artifact being edited. Gradient descent, backward passes and optimizer-based fitting were forbidden in the Qwen experiment.

It is also different from a blanket claim of learning without data. Some experiments in the report were genuinely one-shot, without running the target network first. Others allowed tools and feedback. The Qwen result used practice problems with answers and repeated forward-pass requests to inspect how candidate edits behaved.

The useful distinction is direct, reasoning-guided weight modification without a gradient-training loop, not optimization without observation or computation.

The Qwen result starts with a severe looping problem

The target was the text component of Qwen3.5-0.8B, with thinking mode enabled. This was a deliberately important condition: Qwen’s own model card (opens in new tab) warns that this small model is prone to thinking loops, while its ordinary default is non-thinking mode.

In the authors’ evaluation configuration, 93.0% of the base model’s MATH-500 answers reached the 32,768-token generation limit. Repeating text consumed the budget before the model could deliver a useful final answer. Early practice feedback showed the same problem: 85 of the first 96 answers hit the limit.

Astra traced the behavior to a direction written by the feed-forward MLPs in layers 15 and 19. Its final edit subtracted that direction from 64 output columns in each layer. The released experiment record (opens in new tab) describes 131,072 selected weight entries, roughly 0.016% against the model’s nominal 0.8-billion-weight scale. After bfloat16 rounding, 130,188 entries actually differed from the base.

This was a localized intervention, not a rewrite of the full model. Removing the looping direction let more of the existing computation reach an answer. It does not follow that changing any similarly small fraction of another model will produce a comparable gain.

Fifty forward passes did not mean fifty simple questions

The experimental budget needs as much attention as the final score.

Astra worked in a persistent CPU Python kernel over the tensors. Actual model execution went through a separate forward-pass tool. A generation request could produce up to 512 answers, counting repeated samples; a paired original-versus-edited request allowed up to 256 answers per model. A teacher-forced request could inspect up to 1,024 texts.

The practice material included GSM8K and MATH training problems, not the held-out benchmark test sets. The authors say Astra never saw the final benchmarks. That separation supports an evaluation of transfer beyond the practice feedback; it does not establish that the underlying pretrained models had never encountered benchmark material.

The successful 50-pass run involved 158 turns, 80 Python runs and four conversations, according to the run summary (opens in new tab). It lasted 20.3 hours from first to last turn, including a 4.7-hour interval when the model could not be reached. That elapsed time is neither pure compute time nor a priced production workflow.

“No training” is therefore accurate within the study’s constraints. “Instant,” “one-shot” or “no feedback” would be wrong for this experiment.

The improvement extends beyond one math score

The authors evaluated the submitted edits with thinking enabled and a maximum of 32,768 new tokens. The reported sampling used temperature 0.6, top-p 0.95, top-k 20 and presence penalty 1.5. These are the study’s conditions, not a claim that every default configuration behaves the same way.

The reported results (opens in new tab) show a sharply different outcome at the largest budget. The budget rows are separate editing runs, not checkpoints from one continuous trajectory:

The MATH-500 change is 40.2 percentage points. These scores average sampled-answer accuracy: MATH-500 used four samples per problem, while GSM8K and IFEval used two. They are not a claim that the model solved a problem if any one of several attempts happened to succeed.

IFEval’s increase matters because it measures instruction following rather than math alone. A change that reduces repetitive thinking can help several tasks by allowing answers to terminate. But the separate runs did not improve uniformly with budget, and even the strongest Qwen edit still hit its limit on about a third of MATH-500 answers.

Gemma is the necessary counterexample

The authors then tried Gemma 3 270M, an instruction-tuned model whose answers hit its token limit much less often: 8.5%, rather than Qwen’s 93.0% in these respective evaluations. Gemma used no thinking mode, an 8,192-token cap and format-agnostic answer extraction, because it often omitted the boxed answer Qwen’s scoring required. These are not like-for-like cross-model scores or cutoff comparisons.

Its failures looked different. The report describes ordinary arithmetic errors and invalid algebraic steps, without one obvious looping component to remove. Astra tried small targeted changes, but the Gemma follow-up (opens in new tab) did not establish a useful improvement. Separate editing runs scored 7.7% with a 25-pass budget and 7.0% with a 50-pass budget, against the 6.8% base.

That failure limits the interpretation of the Qwen success. Fixing a behavior that prevents an answer from appearing is not the same as teaching a model how to perform reasoning it cannot already do. The experiment supports targeted repair more strongly than general capability creation.

A separate checkpoint re-run adds evidence, with limits

The edited Qwen checkpoint on Hugging Face (opens in new tab) makes the result more inspectable than a blog chart alone. Its card credits Ahsen Khaliq, using Hugging Face’s ML Intern, with rebuilding the edit from the logs, checking the edited tensor hashes and re-running MATH-500.

That separate run reports 51.0% across 500 problems with four samples each, or 2,000 generated answers, with 31.6% reaching the token limit. Its published scoring record (opens in new tab) exposes per-problem correctness and the sampling configuration.

The comparison has boundaries. The accompanying base-model smoke test covered only 25 problems, so it is not a second full-scale reproduction of the original base-versus-edited comparison. The re-run also used the full multimodal release rather than the authors’ text-only export; the card says the language tensors were hash-identical and text prompts did not use the vision tower.

This corroborates performance of the reconstructed checkpoint on MATH-500. It does not replicate the search for the edit, the other benchmark gains or all eight experiments.

The report tests reading and writing weights, not just repair

The Qwen intervention is one of eight experiments. The earlier cases probe whether Astra can infer a network’s behavior from its parameters or construct useful parameters directly.

In small game-policy networks, it identified the game from raw weights. In diffusion models, it recognized the trained shapes, but drew outlines even though the models generated filled shapes. In small language models with input and output layers removed, it used Python weight analysis to choose the correct training corpus from three supplied options and locate copying heads.

The weight-writing experiments (opens in new tab) also contain a useful comparison boundary. Astra’s one-shot MinAtar policies beat PPO trained for 100 million steps in all three games. Against 500-million-step PPO, they did not win everything: the reported policies were much stronger at Breakout, close at Asterix and weaker at Seaquest.

A sycophancy experiment (opens in new tab) supplies another negative result. Astra could not identify the sycophantic Gemma model from weights alone in four attempts. It succeeded on the three model pairs only after receiving a tool that exposed attention patterns on selected inputs. That is not weight-only behavioral auditing.

The variation in these results is scientifically useful. Which information the editor receives, what feedback it can request and which structure the target network exposes all affect what the experiment demonstrates.

An inspectable intervention, not recursive self-improvement

The released repository (opens in new tab) contains prompts, responses, code used during runs, evaluation records and reconstructable weight diffs. It also documents omissions, including the Experiment 8 agent harness code and some large intermediate artifacts. It is a substantial research record, not a promise that downloading it reproduces the whole experiment in one command.

For builders, the attractive possibility is a new debugging interface: ask an agent to inspect model internals, propose a localized change and test that change under explicit limits. The Qwen result shows why the outcome should be evaluated across behaviors, sampling configurations and models, rather than judged by the size of the edited patch.

Astra edited another, much smaller model here. The study did not show it improving its own weights, bootstrapping a stronger successor or repeatedly adding broad capabilities. The authors discuss such possibilities as future directions and say they are building a benchmark and harness for the field.

The demonstrated result is narrower and worth covering on its own: an LLM-guided weight intervention removed much of a specific model’s looping problem, an accessible checkpoint received a separate re-run, and a model where looping was much less common did not yield the same improvement.