GPT-6 Astra and weight-space programming: what the Qwen MATH-500 result actually measured

A write-up called “Sparks of Weight-Space Programming” by Rikiya Takehi, Jayden Teoh, Alex Zhang and Omar Khattab claims that OpenAI’s GPT-6 Astra can read and write neural network weights natively. The number that traveled: Astra edited 0.016% of the weights of Qwen3.5-0.8B and its MATH-500 score went from 7.9% to 48.1%. On November 3 Matthew Honnibal called the framing misleading, and Simon Willison reran one of its tests on his laptop.

I work from those two accounts, which quote the abstract and tabulate every experiment. I have not read the original post and have not rerun anything. Reported means the source says it, and I am relaying. The question I care about is how far the headline sits from the method, and how cheaply you can see the distance if you read the table instead of the abstract.

What does the GPT-6 Astra weight-space post claim?

Four things, per the abstract as Willison summarizes it. Astra can tell what a network was trained to do from its raw weights. It can write small game-playing networks from scratch that beat networks trained with PPO for 100 million steps, with no environment feedback. It found the cause of the thinking loops that the Qwen3.5-0.8B model card warns about. And its edit to 0.016% of the weights, made without gradients, lifted MATH-500 from 7.9% to 48.1% and roughly tripled IFEval.

The authors call the skill “weight-space programming.” This is the framing Honnibal disputes, the abstract’s opening line:

Just by looking at the raw weights, GPT-6 Astra can tell what a network
was trained to do.

For the experiments it describes, the sentence holds. His complaint is that the same framing carries over to the Qwen result, which was produced another way.

Which GPT-6 Astra experiments read raw weights with no tools?

Three of the ten entries in Honnibal’s table, and they are the small ones. He splits each experiment by what the model was allowed to do. Experiments 1, 2 and 4 put raw weights in context with no Python, on networks of 17K, 24K and 172K weights. Every experiment on a language model used Python, and the Qwen result also ran the model.

GPT-6 Astra weight-space experiments, case by case: what each one measured

Naming the game, reported. Four policy networks were trained on 10x10 grid versions of Breakout, Pong, Pac-Man and Freeway. Each one’s weights went into a prompt as text, with the question of which game it was trained on and no tools. Astra got all four. The 24K diffusion MLP went the same way, three shapes out of three. These are the cleanest no-tools results in the set, and they are seven networks in total.

Fixing the car, reported. A 172K-weight Kinetix policy was stuck. Astra had its weights and one recorded failure episode, edited 3.5% of the weights in one attempt, and success went from 0% to 100%. One edit, evaluated once, no iteration. In my read it is the strongest single entry in the table.

Writing game networks from zero, reported. The abstract’s comparison is PPO trained for 100 million steps, and the table says Astra’s networks beat it. Against PPO trained for 500 million steps, Honnibal’s notes give three games: Breakout 517 to 25, Seaquest 53 to 89, Asterix 53 to 55. So the claim as stated holds, and it stops holding on two of three games once the baseline trains five times longer.

Spotting sycophancy, reported. With Python and Gemma 3 270M’s weights, Astra failed. Shown attention patterns on up to 16 texts, with the outputs withheld, it went 3/3. The second version reads activations, which is a different instrument from reading weights.

Repairing Qwen, reported. Per Honnibal, Astra wrote and ran Python and could run the model on up to 50 batches of practice problems. The model card already documented the failure mode, thinking loops that don’t terminate. So the 48.1% is what an agent with code, a documented symptom and an evaluation loop achieved, and the analogous Gemma 3 270M run failed. Goedecke’s critique, as Willison relays it, is that these are the steps a human ML researcher would take.

Can a smaller model repeat the GPT-6 Astra no-tools test?

On the game task, mostly yes. Willison took the four prompts from the authors’ public logs repository, checked that they differ only in the weights, and ran them through his llm tool.

Kimi K3.1 Pro, reported. Through OpenRouter, given the Breakout prompt, it answered Breakout after 9 minutes 41 seconds and 19,493 reasoning tokens.

Qwen 3.8 27B on a laptop, reported. The 17GB Q4_K_M build in LM Studio, with a long context window because the default 8,192 failed. It got three of four, and the three successful runs took 46 to 65 minutes each:

Willison finds the reasoning traces “almost incomprehensible,” and adds that an experienced human with a notepad and pencil could probably get there with enough effort. That a 27B model on a laptop repeats it in about an hour says the task is smaller than “reads neural networks” sounds.

What should you check before trusting the GPT-6 Astra Qwen number?

Four questions. Honnibal’s table answers the first and points at the other three, and the summaries I have don’t settle them.

What was the model allowed to use? Raw floats in a prompt are one instrument. Code, activations and a network you can run are others. A result that needed code and a test loop is an engineering result. Judge it against what an engineer with the same tools would do.

Was there a feedback loop? Up to fifty batches of practice problems is an evaluator. With evaluation feedback available, the score alone can’t tell a targeted diagnosis from iterative search, and whether the practice set overlapped MATH-500 is not stated in the accounts I read.

How broken was the baseline? A 7.9% MATH-500 score on a model whose card warns about non-terminating thinking loops looks like a model failing in a documented way. My read is that fixing a failure like that can buy a lot of points without the model learning anything new about maths. The summaries don’t separate how much of the 40 points came from fewer loops and how much from anything else.

Does it hold beyond the one case? The analogous Gemma run failed, and the game networks lose to the longer-trained baseline on two games of three. Mixed evidence, then, and nobody has mapped the boundary. Still, a claim has a domain the same way a benchmark holds only where you checked it, and the Gemma failure is the edge of that domain found for free.

What does the GPT-6 Astra result change?

It changes less than the abstract says, and not nothing. Honnibal’s own conclusion is that models of a year or two ago “would have failed at all these tasks.” An agent that writes the analysis code, runs a broken model, finds a fix and patches 0.016% of the weights is doing work that used to take an ML engineer. Willison is not ready to say “the age of source code is over,” and I am not either.

The angle I find more interesting than the capability is what the Qwen fix is as an artifact. Last week I argued that consolidating memory into weights takes away the address: you can’t list a fact once it is spread through the parameters, so you can’t remove it alone. The Qwen edit started from the other end, a documented failure, and produced a sparse patch. At 800M parameters, 0.016% is still about 128,000 weights, so this is a numerical address, not yet a semantic one. You can record the patch, revert it against the original checkpoint and ablate it. Whether it touches only the loops, and whether it can still be reverted cleanly after later training, is what nobody has measured. If weight-space editing matures, that is the number I would want printed next to every headline gain, with the tools listed beside it.