'Like gene editing for neural networks': MIT researchers used GPT-6 Astra to edit Qwen's open weights directly, boosting math performance

Researchers from the Massachusetts Institute of Technology (MIT) Computer Science & Artificial Intelligence Laboratory (CSAIL) reported today that they used OpenAI’s GPT-6 Astra language model to raise a small, open source Qwen model’s math score roughly sixfold by directly editing its weights—the numerical parameters that govern its behavior.

Rikiya Takehi, Jayden Teoh, Alex Zhang and Omar Khattab described their work in a research blog post published November 2. They call the approach "weight-space programming" and tested Astra’s ability to interpret and alter networks without using conventional training procedures to generate the edits.

In the strongest language-model example, Astra’s intervention raised Qwen3.5-0.8B’s MATH-500 score from 7.9% to 48.1% while touching approximately 0.016% of its weights.

The improvement came primarily from correcting repetitive reasoning—a distinction that shaped both the technical findings and the debate over their implications.

Their experiments explored a broader possibility: AI systems that inspect, repair and construct other neural networks by working directly on their internal machinery.

As Yuchen Jin, a technical staffer at Databricks and former co-founder and CTO of Hyperbolic Labs who was unaffiliated with the research, wrote on X:

Indeed, if researchers can make the technique reliable, developers could gain another way to maintain models, investigate unwanted behavior, modify their behavior and improve performance without conventional fine-tuning or retraining. Targeted weight edits could potentially reduce the time and computing resources needed for some improvements, although the researchers have not yet established those savings.

Voyage AI staff researcher Chandan Singh, formerly of Microsoft AI, also offered a similarly optimistic view of the results from the outside looking in in a post on X:

The same approach could also accelerate AI development by allowing capable models to modify other models, or eventually themselves.

Conventional fine-tuning and other post-training methods improve an existing model by using examples, feedback or rewards to calculate changes to its numerical parameters, or weights; retraining can involve updating an existing model or rebuilding one from scratch.

In the MIT experiments, a separate AI model instead inspected the target network, investigated its behavior and devised direct weight edits without using the usual gradient-based training process to calculate those changes.

Both approaches modify how a model works internally, but they differ in how they determine the modifications. The researchers’ approach still required computation and, in the Qwen experiment, practice problems and testing; it did not establish that direct editing would consistently outperform conventional training in speed, cost or effectiveness.

The discussion on X has so far produced both enthusiasm about AI-directed optimization and objections to its potential consequences. The researchers predicted a shift in how developers improve neural networks. A skeptical commenter questioned whether the results demonstrated stronger underlying reasoning.

Maxime Fournes, CEO of Pause AI, an advocacy group calling for frontier AI development to stop until it is proven to be safe and democratically controlled, opined that successful weight editing could accelerate dangerous progress.

From writing software around models to editing models themselves

Weights determine how a neural network transforms inputs into outputs. Conventional training adjusts those numbers by measuring errors and calculating changes intended to improve performance. Gradient descent is a family of methods for making those adjustments.

The MIT team instead asked an already trained LLM to examine weights, reason about their function and decide what to change. In some experiments, the researchers supplied weights as text. In others, they gave Astra a controlled Python environment to inspect larger networks.

“Instead of training, models may treat raw weights like readable, editable code: diagnosing failures and patching them directly,” Takehi wrote on X.

His analogy suggests an AI debugger for neural networks. A developer could describe a failure and ask an assistant to investigate the model’s implementation, identify a cause and propose a patch. That remains a potential workflow rather than an established commercial capability.

The analogy also has technical limits. Individual weights do not necessarily carry the clear meanings of named software functions. Astra brought capabilities acquired through its own prior training; the researchers tested how it applied those capabilities to another network.

Takehi predicted a broader change: “We think neural network weights will soon be natively optimized by LLMs that deliberately reason about the weights.”

A small patch required substantial investigation

For the Qwen experiment, the researchers supplied practice questions, access to weights through Python and a limited budget of model executions. Astra used those resources to inspect behavior and assess proposed changes.

The team’s experiment documentation reported the following results under its evaluation conditions:

The researchers allowed 50 evaluation requests in the strongest attempt, with each request potentially containing hundreds of examples. That attempt involved 158 conversational turns, 80 Python runs and 20.3 hours, including 4.7 hours waiting through a service outage.

Although the final patch affected a small fraction of the model, finding it required substantial investigation.

The authors attributed the gain to Astra’s removal of a numerical direction associated with repetition from selected components in layers 15 and 19. The patch touched 131,072 weights.

Before the intervention, Qwen frequently repeated text until it exhausted the permitted output length. The edit reduced that obstruction and allowed the model to complete more answers using abilities it had already acquired.

The experiment therefore demonstrated a form of model repair. It did not establish that Astra had inserted six times as much mathematical knowledge into Qwen.

Astra also identified strategies and constructed networks

The researchers ran additional experiments to test whether Astra could recognize and implement behavior directly through weights.

According to Takehi’s announcement, Astra identified four game-playing networks as Breakout, Pong, Pac-Man and Freeway despite their matching architectures, inputs and available actions. The researchers gave it neither tools nor a list of candidate games.

In a simulated driving task, a trained controller repeatedly became stuck at a ramp. The team supplied Astra with the controller’s weights, a description of the scene and one failed trajectory. Astra returned a patch in one response. Its changes affected 3.5% of the weights and produced a reported 100% success rate.

The researchers also asked Astra to construct networks using simplified games’ rules and source code, without allowing it to try the networks before evaluation.

In the MinAtar experiments, Astra’s Breakout network scored 517.4. A matching network trained through proximal policy optimization, or PPO, for 500 million steps scored 25.3.

That roughly 20-fold advantage held for Breakout. Astra trailed the 500-million-step PPO networks in Seaquest and slightly in Asterix, although it beat the 100-million-step baselines in all three.

These experiments went beyond repairing an existing malfunction: Astra translated some game strategies into numerical networks. The supplied rules and bounded environments left the researchers with further questions about generalization.

X reactions ranged from skepticism to warnings about acceleration

The ensuing discussion revealed disagreements about the strength of the evidence and the desirability of further progress.

The account @1a3orn argued that Takehi’s announcement thread omitted an important negative result: Astra had failed to establish a mathematical improvement in Gemma 3 270M, which did not exhibit Qwen’s severe repetition problem in the experiment.

“So, if there's a clear flaw in the LLM's reasoning, LLMs can help edit it out,” the account wrote, questioning whether the work demonstrated stronger underlying reasoning. The commenter also credited the authors for including the failures in their blog post.

Maxime Fournes raised a different objection. His X profile identified him as a former deep learning researcher and engineer and CEO of PauseAI.

Quoting Takehi’s announcement, Fournes wrote: “Gosh, may this be hype. Because if real, that could massively accelerate progress which is very bad news and brings us much closer to the global catastrophe. What a terribly reckless research direction.”

He ended his post with an appeal to PauseAI. The organization advocates halting frontier AI development until developers can demonstrate its safety and society can maintain democratic control.

Fournes offered a forecast and a policy judgment. The experiments did not establish his predicted consequences. His objection nevertheless captured a potential tension: methods that help investigators understand model behavior could also help developers increase capabilities.

The discussion has thus raised two distinct issues: whether AI can reliably understand and improve neural networks through direct weight edits, and how wider adoption might affect safety and the pace of development. The experiments supplied preliminary evidence on the first issue; they did not resolve the second.

The failures limited the case for self-improving AI

The Gemma follow-up helped distinguish repair from the addition of new capabilities. Unlike Qwen in the researchers’ setup, Gemma rarely became trapped in prolonged repetition. Astra’s edits produced no established mathematical improvement, the authors reported.

A separate experiment exposed another limit. Astra initially failed to distinguish a model trained to agree with users’ suggestions from one trained to answer correctly. It succeeded only after the researchers supplied measurements of attention during execution.

Those failures showed that access to weights alone did not consistently yield an adequate explanation of behavior or a successful intervention.

Recursive self-improvement would require a further step: an AI’s improvements would help it produce subsequent improvements, potentially strengthening the process across successive cycles. Direct weight editing could provide one route, but the researchers did not demonstrate such a cycle or establish that gains would compound.

Further testing would need to identify which behaviors an editor could understand and change reliably, how much investigation each repair required and whether independent researchers could reproduce the results.

Earlier research established methods for editing model weights

Earlier studies had already explored direct edits to trained models.

The ROME project, introduced in research published at NeurIPS 2022, investigated factual associations in transformer models and made targeted weight changes. Its evaluations examined whether those edits generalized across phrasings while preserving unrelated facts.

MEMIT, presented at ICLR 2023, extended that work to updating thousands of associations together.

The MIT researchers focused on a general-purpose LLM that investigated weights and devised changes across different tasks. Assessing the approach’s practical value would require comparisons with specialized editing methods, conventional training and simpler interventions.

For a particular failure, developers would need to establish whether a direct patch offered advantages over changing generation settings or improving training. The reported benchmark gains did not answer that broader engineering question.

What enterprises could gain from AI-directed model repair

The potential enterprise applications remain hypotheses. The researchers did not report customer deployments or business outcomes.

One possible application would involve maintaining small models used for specialized workflows. A company could supply an editing assistant with a reproducible failure, accessible weights and a controlled environment, then ask it to investigate and propose a repair.

A local assistant that repeatedly stalls while generating structured responses could provide a test case. If investigators traced the failure to a correctable internal mechanism, a focused patch might improve completion rates without a conventional retraining job.

Model auditing could offer another application. An assistant that connected internal structures with behavior might help investigators explain failures and test remedies. The unsuccessful weights-only sycophancy test illustrated the need to evaluate that prospect carefully.

The economics would also require measurement. Reducing repetitive output might save computation, but discovering and validating a patch would impose costs. The study did not establish a sixfold reduction in spending alongside its sixfold mathematical accuracy gain.

Access would shape adoption. Organizations controlling model weights could experiment directly. Customers relying solely on a hosted API would need their provider to enable or perform the intervention.

Qwen’s official model page lists an Apache 2.0 license and describes the small model’s intended applications as prototyping, specialized adaptation and research or development.

Enterprise teams would also need to manage each patch as a new model version. They should compare its performance with the original across representative tasks, check for unintended changes and retain a rollback path.

An improvement in invoice extraction, for example, would not establish that the modified model could still handle multilingual documents or unusual formats. Those are proposed validation requirements; the researchers did not report those particular failures.

The team released experiment logs and editing artifacts and said it was developing a benchmark and supporting framework.

Its findings outlined a possible new role for AI: working directly on the mechanisms of other AI systems. Further research would need to establish whether that approach could support dependable maintenance, accelerate capability development or deliver both.