GPT-6 Astra Directly Edits Weights to Fix Models? Full Analysis of the MIT Paper and Leaks

Introduction: When Frontier Models Start "Repairing" Other Models

The most striking news in the AI world this week came from an MIT paper: GPT-6 Astra was used to directly edit the weights of another small model, with no training involved. If the result holds, it means a frontier model can, for the first time, "reach into" another model's internals and perform surgery. Meanwhile, leaked OpenAI internal charts, Fable 5.5's pure-code movie, and the viral spread of Claude Code turning a router into a radar together paint this week's technological landscape. Here's a breakdown, item by item.

The MIT Paper: What Exactly Is Weight Space Programming?

Experimental Design

According to the paper by four MIT researchers (led by Rikia Takehi and Jaden Teo), they propose the concept of "weight space programming": handing the raw weights of a small network to GPT-6 Astra and letting it read, repair, or write new weights from scratch.

In the simplest test, Astra was presented with four small networks that had each learned a different arcade game. Using only the raw weights, it accurately identified which game each network corresponded to, all without ever running those networks.

The term weight space programming needs to be understood in the context of model interpretability and weight manipulation. Traditionally, changing the behavior of a neural network means preparing data, designing a loss function, and running gradient descent training. Weight space programming envisions treating the weights themselves as a kind of readable and writable "program text" handed to another model, which then directly performs reading, diagnosis, and writing. This line of thinking is closely related to mechanistic interpretability—the latter attempts to decompose a network's internal activations and weights into human-understandable "features" or "directions." The operation mentioned later in the article—"locating a direction inside two layers and subtracting it"—is a typical example of such methods: it assumes that some capability or fault corresponds to a specific direction in weight space, and can therefore be directly added or removed via vector arithmetic. Such operations are often called activation steering or weight editing, and their difficulty lies in whether the direction is stable, whether it generalizes to other tasks, and whether it inadvertently damages other capabilities.

The Math Repair Experiment

The repair experiment drew more attention. A small open-source model scored only 7.9% on the Math 500 test. Astra had the model do some practice problems in a Python notebook, located the problem to a direction inside two layers, and then subtracted that direction. This touched roughly 130,000 weights, about 0.016% of the total, and the math score immediately rose to 48.1%, with instruction-following ability also roughly doubling.

Math 500 is a commonly used math reasoning benchmark containing 500 competition-style math problems, where the answer is usually an integer or a simple expression, allowing automatic scoring by exact match. Compared with GSM8K, which only tests elementary arithmetic, Math 500 problems are harder, requiring multi-step reasoning—which also means that faults like "falling into repetitive output" cause severe score losses: once the model enters a loop at some intermediate step, the entire problem is ruined. The so-called repetitive output (degeneration / looping) refers to the model repeatedly generating identical or highly similar fragments until reaching the length limit. Common causes include improper decoding parameter settings, training data distribution bias, and overfitting to certain prompt formats. This explains why skeptics believe the low 7.9% score reflects decoding loops rather than a lack of math ability: a large score rebound after cutting the loop does not necessarily mean the model "learned math."

Writing a Network from Scratch

The writing test is equally noteworthy. Starting from all zeros, with no data and no training, Astra wrote a small network capable of playing Breakout, scoring over 500 points. By comparison, a network trained normally for 100 million steps scored about 16 points, and even after 500 million steps only reached 25.

Controversy and Reproduction: The Headlines Are a Bit Exaggerated

Voices of Skeptics

Karen Zou pointed out that the small model wasn't actually bad at math—it was falling into repetitive output on 93% of the problems. What Astra did was find the loop and cut it, and a model that no longer loops will improve on almost any task. Adam Karvanen added that Astra used code and standard interpretability techniques in this step, which is different from "reading the weights in its head." The paper itself admits that on a small Gemma model that doesn't loop, the same method brought almost no improvement.

Simon Willison's Local Test

Simon Willison brought the "read weights to identify games" test to his own laptop, running a quantized model of about 17GB with LM Studio. It did get it right, but very slowly: Pac-Man took 46 minutes, and Pong over an hour. Meanwhile, Kimi K 3.1 Pro called via OpenRouter identified Breakout within 10 minutes. Simon believes the paper conflates two questions: what a model can do using only weights, and what a model can do with the help of code. He said he isn't ready to declare the end of source code yet.

Quantization refers to representing model weights with lower-precision numbers, for example compressing original 16-bit floats down to 8-bit or even 4-bit, to reduce memory usage and improve inference speed. The roughly 17GB model Simon Willison ran locally is exactly such a quantized product, at the cost of numerical precision loss that may affect tasks requiring fine-grained reading of weight information—which partly explains the high latency he observed. LM Studio is a desktop application for running and managing local models, supporting loading various open-weight formats. OpenRouter is a routing service that aggregates APIs from multiple model providers; models called through it run in the cloud, with far more compute than a laptop, so the time difference for the same task comes not only from model capability but also from hardware and precision conditions. When comparing such experiments, discussing "local quantized" and "cloud full-precision" together easily confuses the variables.

Rapid Community Follow-up

According to tests by developer Adam Holtererer, he had five models edit the weights of a small model, and one of them changed only a tiny fraction of the small model's weights, nearly doubling the number of correct math answers from 24 out of 96 to 46. Another developer had a model hand-write a small network to distinguish real from fake legal citations, scoring 97.8% without a single labeled sample, while a trained version required large amounts of labeled data to reach a similar level.

My judgment is that the headline does slightly exaggerate the conclusion, because that math repair was essentially a clever loop fix. But the opposing view has a point too: these models have debugged countless small neural network problems while learning to write code, and that itself is a repeatedly practiced skill. If a model can locate and repair faults inside another model, the next step is naturally for labs to point this skill at their own models.

GPT-6.2 Leak Clues: OpenAI's Own Chart

The strongest clue comes from OpenAI itself. It published an article about using ChatGPT and Codex for hardware engineering, in which a chart compared GPT-6 Astra with an unnamed internal model on a benchmark called BenchCAD 2.0, which requires models to reconstruct 3D parts and identify connections on circuit boards. Astra scored an average of 0.594 at the highest reasoning setting, while the internal model scored 0.875.

This clue is not isolated. Previously, a Codex usage chart showed the label GPT-6.2 Astra, and Sam Altman also said the model behind OpenAI's Navier-Stokes result is the next-generation GPT. OpenAI did not name the internal model in the chart, so it cannot be concluded it's the same one, but such a large gap on an engineering test is consistent with other information circulating outside.

Thibault from the OpenAI Codex team first joked about "a fat GPT," then posted another message reading only ChatBLT. Some interpreted it as 6.2 being a very large model, but no one at OpenAI confirmed it. Another user shared a website screenshot claiming GPT-6.2 is a very large model, and someone else posted GPT-6.2 Astra in the Codex desktop app's model selector, but these are all just single screenshots.

There are also rumors about pricing. Bindu Reddy claimed 6.2 might come with a 60% price cut, matching Opus 5.5's price, and also said users prefer Astra over Opus in building apps and blind tests—these are likewise unverified.

Fable 5.5: Pure-Code Movies Become the New Normal

Anthropic's next-generation model has been appearing more through testers than official channels. The page title for Mythos 5.5 leaked on Sunday, and demos of Fable 5.5 haven't slowed down—and are all generated entirely from code.

Muviz said he used Fable 5.5 to generate a 42-second animation in one go, the entire work being a single HTML file built on 3.js, with every frame drawn by code and the sound synthesized. He claims this surpasses 90% of video models, a rather bold statement. The difference from video models is that you can open the file and modify any part—an editability that video can never achieve.

Chris Gpt used the classic test: an astronaut riding a pelican riding a bicycle on the moon, made into an animated SVG. He pointed out that the bicycle uses real road bike geometry, with the chain, crankset, and wheels moving in coordination, which is very hard to get right in code. He labeled the work as Fable 5.5 or Opus 5.6, and Anthropic has announced neither name—the latter is worth noting.

The weight-editing story and these movies point in the same direction: the latest models are doing work that previously required specialized tools.

Claude WiFi Radar: A Real Ghost Story

The most widely spread Claude post this week came from a user who said he asked Claude Code to turn his home WiFi router into a radar, and Claude wrote the code in 40 minutes. In the video, a person appears as a moving shape on an apartment map, and the panel even claims to read heart rate and breathing.

What really made it go viral was the ending: he said he ran it at night and saw a second shape standing by his bed, while he lives alone. In replies, he admitted that reflections and ghost targets are known issues and that he wasn't sure what caused it. WiFi sensing itself is real—researchers at Carnegie Mellon University demonstrated in 2022 that WiFi signals can estimate a person's pose in a room. But his specific setup cannot be verified: the post doesn't say what router was used, and that matters, because reading such signal details usually requires a specific chip or modified firmware. Enjoy it as a ghost story with something real underneath; the second shape proves nothing.

WiFi sensing works by using channel state information (CSI): WiFi signals are reflected, absorbed, and scattered by the human body during propagation, and the receiver obtains subtle changes in the amplitude and phase of each subcarrier accordingly. Breathing, heartbeat, and body movement all cause periodic patterns in these changes, which after signal processing can be used to infer whether a person is present, their approximate location, and even breathing rate. The difficulty lies in obtaining CSI: ordinary home routers usually do not expose raw CSI, requiring a specific network card (such as an Intel card supporting CSI extraction) or modified firmware, plus extensive calibration in a controlled environment. Multipath reflection causes ghosts: after signals are reflected multiple times by walls and furniture, false targets resembling human bodies form on the reconstructed map, which closely matches the "second shape" mentioned in the article. Therefore, even if the code in such demos is real, the conclusions should be treated with caution.

Other News: Claude Plugins and Google's School Policy

Claude can now automatically connect plugins at login, provided the plugin server accepts Claude as a trusted issuer. For users who work with a bunch of internal tools, this saves a lot of scattered login operations.

Google, meanwhile, adjusted its school account policy: on school-managed student accounts, Gemini in Search, Gemini, Gemini Notebook, and Classroom will be off by default and require an administrator to enable manually. The problem is that the search option schools can enable includes AI features, so a school wanting to fully disable AI would also lose Google Search. According to The New York Times, these changes will begin early next year. Schools are expected to push hard for a search-only option, and I think Google will eventually add one.

Final Thoughts

This week's main thread is clear: models are moving from "answering questions" to "doing things"—editing weights, writing runnable game networks, generating editable animation files. Although the leaks surrounding GPT-6.2 remain officially unconfirmed, OpenAI's own engineering benchmark chart is the heaviest piece of the puzzle. As for the second shape in the WiFi radar, just treat it as a tech story, not as evidence.

One-line Summary

Frontier models directly edit weights, pure code generates animations, WiFi sensing goes viral—models are moving from answering to doing.

Paragraph Summary

This week's AI focus is "weight space programming" proposed in an MIT paper: GPT-6 Astra identified which games small networks corresponded to using only raw weights, and by changing about 0.016% of parameters, raised a small model's Math 500 score from 7.9% to 48.1%, and could even write a network from scratch that plays Breakout. However, skeptics point out that this is essentially a clever loop fix, aided by code and standard interpretability tools, and the paper's title slightly exaggerates. Simon Willison's local reproduction shows the task is feasible but extremely time-consuming. Meanwhile, an unnamed internal model in an official OpenAI chart leads Astra by a wide margin on BenchCAD 2.0, seen as a strong clue that GPT-6.2 is near; Anthropic's Fable 5.5 testers continue to produce pure-code animations editable frame by frame; a post about Claude Code generating WiFi radar code went viral due to the "second shape by the bed," but the setup details cannot be verified.