Skip to content

Can AI Help Build Better AI?

One AI investigated why a smaller model kept getting stuck, made a targeted change inside it, and helped it produce more correct answers. The experiment offers a concrete look at how AI could help improve the models we already have.

How It Thinks4 min readEP 04
In this article
Prefer to watch? · 4:07Watch the film on YouTube ↗Opens youtube.com
Astra uses coding tools and practice feedback to make a targeted change to the separate Qwen3.5-0.8B model.
Astra used coding tools and practice feedback to edit selected weights in a separate Qwen model. Conceptual illustration, not model architecture or scale.

An AI made a targeted edit inside another model and helped it deliver more correct answers. Working with a small Qwen model, Astra investigated its behavior, changed a tiny fraction of its internal weights and produced a version that performed substantially better on a separate math evaluation.

The experiment, from researchers at MIT CSAIL, offers a concrete example of AI helping improve AI. They call the approach weight-space programming: using a language model to reason about a network’s weights and change them directly. Research report

The interesting part is what Astra found along the way. Qwen was repeatedly getting caught in long, repetitive responses. A focused change helped it get further with the task it had been given.

How does an edit inside a model become a better answer on the screen?

Two models with different jobs

The model doing the investigating was GPT-6 Astra, called Astra in the research. The model being edited was Qwen3.5-0.8B. Keeping those roles separate makes the experiment easier to follow: Astra proposed and investigated changes; Qwen was the system whose performance was measured.

Astra worked through a controlled Python environment. The researchers’ released logs record its code, the outputs returned to it and the evaluation results, making the investigation available to inspect. Experiment logs

What changing a model actually means

A model’s weights are numerical values used in its calculations. During ordinary training, an optimization procedure repeatedly adjusts those values. Once a trained model is answering a question, its calculations use the weights to turn the supplied context into predictions about what to produce next.

Changing the prompt changes the information entering that process. Changing the weights changes part of the process itself.

For this experiment, Astra could inspect Qwen’s weights, try practice problems and make direct edits. It used feedback from those practice runs to investigate what was going wrong and whether a change helped. The researchers kept the final evaluation questions separate from the questions available during this work. Experiment 8 setup

The process connected internal edits with observable results, using direct weight changes rather than conventional retraining.

Astra and Python inspect Qwen, change selected weights and test changes using practice feedback. Separate evaluation compares original and edited Qwen on held-out tasks.
Practice feedback guided the weight edits. The selected model was then evaluated separately on held-out tasks.

Finding a change that mattered

Astra’s investigation led to a focused change in two of Qwen’s internal layers. The edit touched 131,072 weights, approximately 0.016% of the model, and targeted the behavior associated with its repetitive responses. Edited model documentation

The practical effect is easier to understand than the individual numbers. A model has a limited amount of space to produce its response. When it spends that space repeating itself, it may run out before reaching a usable answer. Reducing that behavior gives it a better chance to complete the work.

This is what makes the experiment compelling: a change to a small part of an existing model made a visible difference to its output. The next step was to measure that difference on questions outside the edit-development process.

What improved in the test

On the original reported MATH-500 evaluation, accuracy rose from 7.9% to 48.1%. The original and edited versions were tested with the same settings, averaging four samples per problem. These evaluation questions were held apart from the questions used while developing the edit. Evaluation protocol and results

Bar chart on a shared 0–100% scale: original Qwen 7.9%; edited Qwen 48.1%.
Researcher-reported MATH-500 accuracy rose from 7.9% to 48.1% for original versus edited Qwen3.5-0.8B, using four samples per problem and the same test settings.

Fewer replies exhausted their response budget, and instruction-following results improved too. That broader improvement is useful context: the behavior Astra targeted could interfere with more than math answers. Checkpoint results

The accuracy result and the reduction in unfinished responses complement each other. One measures correct answers; the other helps explain why more answers could reach a conclusion. Both matter when assessing whether an edit makes a model more useful.

This article reports the researchers’ original matched comparison.

Why this is worth watching

The useful possibility is a more direct way to investigate certain model failures. If a problem can be connected to a particular internal behavior, an editing system may be able to propose a focused change and check whether it helps.

That could give model developers another option alongside prompt changes and conventional training. It also changes what we should ask of the evidence. A convincing demonstration needs a traceable edit, a fair comparison and tests beyond the examples used while making the change.

The release includes logs, edit data and reconstruction code, so other researchers can inspect more than the headline result. Released materials

The next question is how reliably this approach transfers to other models and kinds of failure. In a follow-up with a smaller Gemma model that rarely looped, the researchers did not establish a comparable improvement. That points to a useful direction for further testing: identifying which problems respond to targeted edits and which require other approaches. Follow-up experiment

The takeaway

For anyone building with AI, this is a useful reminder to investigate how a model is failing. Wrong reasoning, ignored instructions and unfinished responses may need different fixes, even when they all look like a bad answer to the user.

Astra’s edit is an early example of AI helping with that investigation inside another model. Its value lies in the specific chain the researchers demonstrated: find a recurring failure, make a targeted change, then measure the result on separate tests.

Sometimes, getting more useful work from a model starts with understanding what is getting in its way.

Sources

Sources checked November 9, 2026.

  • AI research
  • AI research
  • weight-space programming
  • model editing
  • Qwen
  • evaluation
Building an agent?We build agents and prove how they think.
Start a build