Researchers at MIT CSAIL recently reported something counterintuitive about GPT-6 Astra: given only a game description, it can write all 20,486 weights of a Breakout network in a single reply, and that network scores 517 — against 25 for the same architecture trained with PPO for 500 million steps. A four-person team at the Alan Turing Institute spent three days replicating and extending the result. Their verdict: the ability is real, but it is not what it looks like.

What reproduces

Across three reruns, Astra's Breakout networks scored 514, 550 and 307, in line with the original 517. The team also designed two modified versions of Breakout that exist nowhere else; Astra's networks played those just as well, ruling out memorization from training data. On reading weights, Astra and Claude Opus 5.5 named the game for 12 of 12 networks, and fell to chance when the weights were shuffled.

The generational picture is sharper. Opus 4.5 (Nov 2025) could not even write good policy code. By July 2026, Opus 5 and GPT-5.6 Sol wrote strong programs (580 on Breakout) but weak networks, around 30. With Astra (Sep 2026), written networks finally keep half to two-thirds of its programs' scores — none of the earlier models managed that. Per the paper, translating programs into weights is the genuinely new part.

The nets behave like compiled programs

The team asked two models to independently decompile Astra's Breakout network back into Python. Both programs match the network's action in all 49,189 game states tested, and average 502.9 over 1,000 games — identical to the network itself. The structure looks hand-written too: only 815 of the 20,486 weights are non-zero, only 6 of 32 first-layer units are used, and weights in the hundreds make units act like on/off switches. The decompilation also found no connection to the bricks — the network simply ignores them.

The negative control is clean: on handwritten digit classification, a task with no program to compile, Astra's networks average 50%, below the 82% of a simple template classifier.

Reading weights is mostly reading the input layer

On three new games the team designed and trained themselves, Astra recovered where things are on the board — information a simple heatmap also shows to a human — while mostly missing how the games work. The audit experiment: reading plain-text weights without running any code, Astra picked out the model poisoned during training in 10 of 10 runs, the one poisoned by extra training afterwards in 7 of 10, and a malicious adapter in 23 of 32 cases — but it never found the trigger or described the malicious behaviour. Open-weight models lag: Kimi-K3.1-Pro scores 19 to 68 on Breakout (its own Python policies average 439), DeepSeek-V4-Pro scores 2 to 12, and Qwen3.8-27B averages under 5.

Where to temper the claims

The original PPO baseline is probably weak — tuned PPO reaches 679 on MinAtar Breakout, so the 25-point comparison flatters the result. Tokenizers offer a clue: GPT-5.2, GPT-5.6 Sol and Astra count tokens identically, as do Opus 4.8, 5 and 5.5, suggesting the ability came from further post-training of the same base models rather than new ones. On cost, MIT's Go network wins against smaller PPO networks even with a budget of 0 forward passes, but the paper notes that running a frontier LLM as an agent to build weights may cost more than training from scratch.

Independent support, and so what

Two independent papers side with the compilation view. Fischetti replaced the LP behind rank-one anti-loop edits with a plain sort and got 67.0% versus 67.4% on Qwen3.5-0.8B, non-inferior, suggesting that edit acts as nearly a constant bias. Golnari and Sanei had an analyst model read only topological digests of a frozen target and write transforms into feed-forward weights via closed-form ridge regression — no raw weights touched, and latent-space category purity still improved.

For interpretability there is a real opening: networks written by LLMs come with design notes, making them natural test cases for mechanistic interpretability — in the Tracr era you compiled RASP programs into weights by hand; now the model does it itself. Just do not say AI has learned to train models. It learned to compile programs it has already thought through into weights. Training is still alchemy; compiling is not. (Replication note: https://arxiv.org/abs/2611.21449; MIT post: https://rikiyat.github.io/blog/weight-space-programming/)