0.016% of the weights, six times the maths score

A frontier model fixed a reasoning loop in Qwen3.5-0.8B by hand-editing six parts in ten thousand. The size of the edit, not the score, is the finding: these are local defects, not capacity limits.

The post landed on Hacker News at 2,533 points and 782 comments, most of them arguing about whether it is real. The headline numbers are the easy part: GPT-6 Astra reads raw weights and can tell you what a network was trained to do, then writes new weights that beat networks trained with PPO for 100 million steps.

The number that matters is smaller and quieter. On Qwen3.5-0.8B, asked to improve maths without gradients, Astra found a defect behind the model's reasoning loops — a behaviour Qwen's own model card warns about — and fixed it by editing 0.016% of the weights. MATH-500 went from 7.9% to 48.1% under the same sampling settings, and IFEval tripled as a side effect.

Six parts in ten thousand. No optimizer, no training loop, no environment feedback.

What the experiments actually did

The detail that proves it isn't faking a forward pass

Experiment 2 is the one to read carefully. Ask Astra which shape a diffusion model generates, and it draws the shape — as an outline. The models generate filled shapes. A model that were secretly doing arithmetic on the forward pass would produce a filled shape; one that reads the geometry of the output layer produces the edges it finds there.

Experiment 3 locks it further. Strip the input and output layers so the network cannot be run on any text at all, hand Astra four transformer blocks from a 7.2M model, and ask which language it learned. It names Python, romaji Japanese and English correctly, twice each — and while explaining Python it identifies copying heads (induction heads) and multiplies weight matrices to find the later heads that use their output. That is a published interpretability technique Astra was never told about.

Both of these point the same way: the model is reading structure in the numbers, not simulating the computation. That is a different capability from "big model is good at maths".

Why the small edit implies a lot

If a 0.8B model's maths failure were a capacity problem, no 0.016% patch would fix it. The patch works because the failure is a local one: some subcircuit pushes the model into a repetition loop, and once that loop is broken the capability that was always there shows up. 7.9% → 48.1% is not learning; it is switching something off.

The car experiment says the same thing at a smaller scale. PPO converged to a local minimum where it drives straight into the ramp. Astra added a small separate path through a few units per layer that reads position and speed, and switches itself off once the car is past the strip. It changed 3.5% of the weights and the car succeeded in every one of 1,024 episodes.

That is a debugging story, not a training story — and it is the first credible account I have seen of "find the broken subcircuit, patch it" producing numbers worth arguing about.

Where this stops being exciting

Four reasons to keep it as a note rather than a strategy.

1. Scale. The largest language model in the post is 0.8B. The largest network anywhere is 1.5M parameters of Go. Nobody has shown this on a model whose weights do not fit in a context window without a sandbox and a forward-pass budget.
2. No training loops, by design. The authors explicitly forbid Astra from writing training code, which keeps the claim clean ("it doesn't just call a trainer") but also means nothing here competes with gradient descent at scale.
3. One lab, one model. Every experiment uses a single frontier model, and the evaluation is largely the authors' own. The 7.9% → 48.1% number needs someone else to reproduce it before it belongs in a roadmap.
4. The 0.016% could be luck. A tiny edit that lands is impressive; what matters is whether the method finds the right 0.016% on the next model, or whether this was a well-known defect with an obvious fix once you look.