Skip to content
Main Site News Console

MIT: GPT-6 Astra Can Directly Modify Qwen Weights, Boosting Math Performance 6x

· 量子位
国内AI

GPT-6 Astra can now directly read and edit the weights of smaller models.

A newly completed experiment from MIT has taken the LLM community by storm:

Handing the 0.8B-parameter Qwen3.5 over to Astra and modifying just 0.016% of its weights resulted in a massive performance leap.

No retraining, and not a single step of gradient descent.

Image 3

Under identical sampling settings, its MATH-500 score skyrocketed from 7.9% to 48.1%, boosting its mathematical reasoning capabilities by roughly 6x.

Even its instruction-following capabilities—which weren’t targeted for optimization—improved threefold alongside it.

Beyond patching existing models, asking Astra to write weights for mini-game neural networks from scratch yielded equally striking results:

Generating the weights directly in a single response, its evaluation score outperformed a PPO baseline trained for 500 million steps by more than 20x.

Image 4

Video link: https://mp.weixin.qq.com/s/tdEmYQz4B9W4OfNpkU-anw

The research team dubbed this approach:

Weight-Space Programming.

Astra Directly Overhauls Model Weights

Put simply, this approach allows a large model to directly analyze a neural network’s static weights, autonomously decipher its functional mechanisms and flaws, and perform targeted modifications on demand—or even construct an entirely new network from scratch.

To see how it works in practice, look no further than the Qwen experiment.

Researchers set up a Python environment for Astra containing all weights of Qwen3.5-0.8B, with a straightforward objective: maximize the model’s math reasoning capability.

Image 5

Conventionally, training a model requires computing a loss between predictions and ground-truth labels, calculating gradients via backpropagation, and updating parameters using an optimizer.

This time, which parameters to modify and what modification strategy to use were determined entirely by Astra through autonomous analysis.

Upon analysis, Astra discovered that the small model’s math performance was severely crippled by reasoning infinite loops:

When presented with a problem, the model would repeatedly output repetitive text without ever arriving at an answer. Out of the initial 96 test responses, 85 hit the maximum context limit of 32,768 tokens.

In fact, this issue had also been noted in Qwen’s official Model Card.

Tracing this failure mode layer by layer, Astra pinpointed the root cause to the Feed-Forward Networks (FFN). It then precisely modified the numerical influence of relevant weights across 64 output channels in layers 15 and 19.

As a result, the proportion of responses hitting the context length limit on MATH-500 plummeted from 93.0% to 33.1%.

The researchers further allocated Astra evaluation budgets of 10, 25, and 50 forward passes; the modified model achieved MATH-500 scores of 12.3%, 14.1%, and 48.1%, respectively.

Notably, what Astra eliminated was backpropagation and gradient-based training; the internal model diagnosis and inference verification phases remained fully intact.

Image 6

How was it able to unearth these clues solely from static weights?

First, consider its “weight reading” capability.

Researchers trained four small neural networks to play different games and fed their raw weights to Astra as text. All four networks shared identical architectures, input channels, and action spaces.

Remarkably, Astra accurately identified all four games: Breakout, Pong, Pac-Man, and Freeway.

Image 7

Video link: https://mp.weixin.qq.com/s/tdEmYQz4B9W4OfNpkU-anw

In the case of Breakout, Astra deduced the game primarily by analyzing the spatial clustering of weight parameters.

When tested on image-generating diffusion models, it could similarly identify geometric features like circles, squares, and triangles directly from the weights.

There were slight discrepancies in localized details: while the original network actually generated solid shapes, Astra interpreted them all as outlines. In other words, it got the geometry right, but missed the fill property.

Researchers then raised the bar: they took three small language models with just 7.2 million parameters each—trained separately on Python code, Romaji Japanese, and English—and stripped away their input and output layers, leaving only the intermediate 4 Transformer blocks.

In this setup, vocabulary mappings were completely unavailable, and the model could not run text inference directly. Astra was only allowed to write Python scripts for numerical analysis of the static weights—unable to feed inputs or observe runtime dynamic activations.

Even so, within just two iterations, it correctly identified the training language of all three models and precisely located all of their induction heads.

Image 8

From identifying intended tasks and pinpointing internal functional modules to targeted behavioral interventions, this technical pipeline is now fully realized.

In another experiment with the Mountain Car environment, weight modifications translated directly into tangible control behaviors.

Previously, a network trained using PPO kept charging blindly up the hill, getting stuck midway due to insufficient kinetic energy. The correct policy requires reversing first to build momentum before accelerating to the peak.

Researchers provided Astra with only the raw weights, a description of the environment, and a single failed trajectory log. Without invoking any external tools, Astra outputted patch code in a single response, modifying just 3.5% of the weights, which enabled the car to achieve a 100% success rate across 1,024 subsequent test runs.

An action-timing policy that reinforcement learning failed to acquire was injected straight into the static weights by Astra.

Image 9

Video link: https://mp.weixin.qq.com/s/tdEmYQz4B9W4OfNpkU-anw

Is Training Truly No Longer Needed?

Having proven it can surgically patch the logic of existing networks, the research team took on an even bolder challenge:

Given a network initialized with all-zero weights, could Astra directly “write” a fully functional model out of the box?

In the MinAtar retro game benchmark, Astra was given the game rules, environment source code, and a specified network architecture. Throughout the process, no training data, loss functions, gradient computation environments, or external tools were provided, and the model was not allowed to perform trial runs in the environment beforehand.

It had to formulate a strategy on its own, compile the control logic directly into the weight parameters across each layer, and output the final result in a single shot.

Final evaluations revealed that the network generated by Astra achieved an average score of 517.4.

By comparison, a baseline model trained with traditional PPO scored only 15.8 after 100 million steps, and reached just 25.3 after 500 million steps—meaning Astra’s zero-shot generated network outperformed the baseline by more than 20x.

Image 10

The central breakthrough of this work is demonstrating that general-purpose frontier LLMs can autonomously understand, diagnose, and directly rewrite neural network weights based on natural language task descriptions.

Of course, Astra’s domain knowledge and reasoning capabilities still stem from its own extensive pre-training; matrix analysis of weights, code generation, and batch evaluations also demand considerable computational resources.

GPUs don’t get to retire just yet.

Yet for the future, when downstream small models underperform, developers may now have an entirely new playbook:

Next time we hit a performance bottleneck, will we really need to retrain—or can we simply have an LLM rewrite the weights?

References:
[1] https://x.com/i/trending/2117328869283840499
[2] https://rikiyat.github.io/blog/weight-space-programming/
[3] https://x.com/rikiyatakehi/status/2117313742891327994