Is GPT‑6’s self‑tuned Qwen weights being idolized? A top Meta researcher douses the hype.

On November 2, a technical experiment by a joint MIT team sparked nearly 6 million views on social media.

The experimental setup is striking: no training data, no back‑propagation, just a pure Python environment, allowing OpenAI’s cutting‑edge large model GPT‑6 Astra to directly read and rewritethe underlying high‑dimensional tensors of the open‑source model Qwen3.5‑0.8B.

In the end, Astra only changed 0.016% of the 800 million parameters (about 130 k weights), yet it boosted Alibaba’s Qwen3.5-0.8B accuracy on the MATH‑500 math benchmarkfrom 7.9% to 48.1%. In the second half of the report, Astra even “hand‑wrote” small neural‑network weights from scratch—without any training samples—that can play simplified Atari games and play 9×9 Go.

One of the blog’s credited authors, Stanford scholar Omar Khattab, then publicly posed a provocative question:“If large models can directly write weights, what role remains for traditional methods like gradient descent?”

Tech enthusiasts view this breakthrough asthe starting point of a model’s “recursive self‑improvement”, even predicting thatpre‑training clusters costing tens of millions of dollars will be replaced by “weight compilers”; however, on the other side, Meta and leading researchers from major open‑source communities quickly poured cold water on the claim, calling the tweet a click‑bait headline.

This polarized debate has split the AI camp directly into two factions:Believers think they have witnessed a miracle, while skeptics see only a carefully packaged academic marketing.

In this confrontation, the arguments of the radicals and the conservatives are almost completely opposed.

Supporters are excited about“overturning massive computing power with minimal cost”.

Tech blogger Chubby, who has 150,000 followers, and others believe that Astra demonstrates diagnostic and reconstruction capabilities at the high‑dimensional parameter level, meaning that higher‑order models can act as “doctors” for lower‑order models, forming the foundation for automated self‑iteration. On social platforms, the narrative of “AI directly compiling AI” quickly captured the public’s attention.

However, the rigorous code archaeology soon provoked a backlash.

Meta core researcher Lucas Beyer bluntly said the project is “very cool, but overhyped.” He dug up the team’s publicly released system prompt and pointed out: the experiment does not let Astra explore blind spots on its own, humans have already provided an extremely explicit directional guidance in the prompt—clearly instructing Astra to check whether the model is being truncated due to getting stuck in an infinite loop, while also fixing the rule to prohibit exploiting the lightweight engineering trick of “prematurely terminating thought.”

Researcher Yunfan Zhang further reviewed the full experiment logs. He found that Astra only performed a set of switch controls under the long-form reasoning mode (Thinking Process), identified that Qwen’s reasoning chain was looping, and then carried out targeted clearing. “The real version of this story,” Zhang sarcastically said, “is far less dramatic than the hype of ‘boosting accuracy by 7×’.”

Moreover, an engineer wrote a long article stating that tweaking weights with large models is like manually reverse‑engineering a compiled binary program—“it doesn’t have superhuman attributes,” and a clever algorithm researcher can achieve the same by drawing a few activation heatmaps.

In fact, Qwen3.5-0.8B’s math score jumped from 7.9% to 48.1%, not because it magically mastered advanced mathematics overnight, but due to a precise “circuit debugging”: Astra followed the signal flow, understood the internal logic, and cut off the short‑circuit wire that caused its infinite loop. The figure below shows Astra gradually adjusting weights over 50 trial runs; the green line is the accuracy of the updated model on practice questions, and the gray line is the original model.

First, this is a known defect explicitly acknowledged by the official. The official technical documentation for Tongyi Qianwen has long warned: for an extremely tiny 0.8B model, forcibly enabling the thinking mode can easily fall into endless self‑repetition and logical dead loops, so the official disables it by default.

In MIT’s experimental environment, the model’s context limit was pushed to 32,768 tokens, and the thinking mode was forced on. The result was disastrous: the original Qwen, when tackling MATH-500,had as many as 93% of the problems not failing because “it got the answer wrong,” but because it exhausted all compute on endless loops of nonsense,until the length ran out and the system mercilessly truncated it.

The operations Astra performed during multiple rounds of debugging are essentiallyfeature ablation:

1. Contrast positioning: Astra extracted Qwen’s internal activation states during normal inference and infinite loops, and found that the model has a stubborn geometric direction in the deep layers (layers 15 and 19), continuously pushing the signal into a dead end;

2. Weight projection: Astra selected 64 columns from the output weight matrices of each of these layers and forcibly removed this direction via linear algebraic transformation;

3. Unlocking the lock: After the loop direction is resolved, the inference chain that was previously stuck in long texts can finish smoothly, with the median length stabilizing at around 9,000 tokens.

The subsequent detailed data completely debunk the illusion of “intelligence improvement”: among the 1,152 test questions, in the 579 questions that were answered correctly more often after the changes,a full 576 of them were originally scored zero due to timeout truncation; and for questions that could already be completed, the accuracy after adjusting the weights showed no change at all.

A more damning counterexample comes from the control group—Google’s Gemma 3 270M. Gemma itself does not suffer from a vicious‑cycle flaw; its errors are solid miscalculations and algebraic logic failures. Faced with a model that lacks a “dead‑loop structural defect,” Astra repeatedly tweaked parameters, its math score stubbornly hovered between 6.8% and 7.7%, showing no improvement.

From this perspective, it isn’t some magical alchemy conjured from nothing, just a straightforward fix of a dead loop.

It’s like a piece of code that already has its calculation logic written, but gets stuck in an infinite loop halfway through, until the system forcibly times out and kills the process. Astra doesn’t teach the small model a new problem‑solving approach; it simply adds a proper exit condition so the computed result can be printed successfully.

Besides modifying Qwen, another experiment closer to “AI creating AI” is to have GPT-6 Astra generate neural network weights from scratch.

The team enabled Astra to directly generate weights, beating traditional reinforcement learning (PPO) on three MinAtar Atari games (Breakout, Seaquest, and Asterix) and a 9×9 Go network.

In this stage, the model skips all training data and gradient computation, directly deducing logic with Python code and then “compiling” it into weight tensors.

But a close look at the size of these networks reveals the issue:

• The three game networks have only about 20,000 parameters;

• The largest 9×9 Go network has only 1.48 million parameters;

• In contrast, even the smallest language model Qwen3.5-0.8B has a parameter count that is 540 times that of the Go network and 40,000 times that of the game network.

Astra can “hand‑write” these tiny networks, provided that the task rules are extremely clean and the mathematical mapping is highly deterministic. In the brick‑breaker game, the first layer of matrices computes the ball’s landing point, the second layer coordinates paddle movement, and the logical chain fits together perfectly; once the rules become slightly ambiguous, its score drops sharply and it is overtaken by traditional reinforcement‑learning models.

However, researchers have previously made similar attempts: having cutting‑edge large models hand‑write Transformer weights to solve small algorithmic tasks such as sorting and summation, and the models performed excellently; but as soon as the task switches to natural language understanding, where semantics are full of uncertainty, the so‑called “weight generation” collapses instantly due to evaluation leakage or dimensional explosion.

So, translating a clearly defined mini‑game into a toy model with twenty‑thousand parameters is essentially just converting a few lines of existing logical code into a matrix format. But that is a completely different matter from writing a universal large model—human language and the complex common‑sense knowledge of the real world cannot be exhaustively enumerated into a handful of explicit rules.

If we can’t even list a definitive set of formulas, how could AI possibly “hand‑write” parameters out of thin air? That’s why we must rely on massive amounts of data to train models, rather than having people or machines hard‑code the parameters.

Since it cannot replace traditional training, why is this report still worthy of high attention across the entire industry?

Because this research tears open a long‑standing blind spot in deep learning:the high‑dimensional parameters of neural networks are losing their “unreadability.”

For decades, humanity has treated deep neural networks like a fog‑shrouded black box: we define a loss function and rely on stochastic gradient descent (SGD) to fumble for gradients in the dark, powerless against the intricate numerical distribution inside high‑dimensional matrices. Yet MIT’s experiment demonstrates a powerful capability of large models: directly reading the weights.

If a universal large model could directly read its weights and identify the functional structures within them, it could eventually be used for model auditing, backdoor detection, capability editing, and localized defect repair. On one hand, this offers interpretability: without running the model, we might understand what it is doing just from the weights. On the other hand, it enables small‑model fine‑tuning: fast, low‑cost model optimization, or tailoring to specific domains.

The MIT team also proposed more ambitious ideas, including adding or removing capabilities without relying on large amounts of data, transferring functional modules between different models, and even recursive self‑improvement.

These directions have not yet been fully validated experimentally, butthey already outline a model development approach that differs from traditional training.

Trainingstill remains the core way for models to acquire complex general abilities, but future model development workflows may add a new role: an AI researcher who can directly read weights, diagnose model flaws, and attempt to fix other models.

Disclaimer: This article is original content from AI Frontline, does not represent the platform’s views, nor does it constitute investment advice, and may not be reproduced without permission.

Today’s Recommended Article

66-year-old Yann LeCun releases new paper challenging the Scaling Law: 109 million parameters outperform 72 billion, larger models not necessarily better at understanding the world

Apple’s smart integration with Alibaba Qianwen launches on November 4; OpenAI announces merging ChatGPT and Codex quota bytes; DeepSeek open-sources brand-new Agent architecture Super‑agent | AI Weekly

After getting unlimited tokens, this 27‑year‑old programmer plans to rewrite 98% of Cisco’s legacy code with just two people

Will OpenAI’s next‑gen model drop token billing? Altman speaks candidly after drinking, and customer reactions are surprising

Another core talent from Tencent AI Lab confirmed! Former technical lead of “King’s Absolute Insight”, Ye Deheng, joins ByteDance Seed

Are you also “watching”? 👇