--- title: "What Did GPT-6 Astra Do With Raw Model Weights? Results" url: "https://goremy.ai/blog/articles/gpt-6-astra-weight-editing-experiments-results" author: Luis Chavez-Mattos editor: Luis Chavez-Mattos editor_title: Director, Product published: "2026-11-05T21:00:13.546Z" updated: "2026-11-05T21:00:13.546Z" topic: AI Model Reviews & Comparisons description: "Astra identified games from raw weights, fixed a stuck car by editing 3.5% of a network, and wrote Atari networks from scratch. Here are the numbers and limits." --- # What Did GPT-6 Astra Do With Raw Model Weights? Results > Astra identified games from raw weights, fixed a stuck car by editing 3.5% of a network, and wrote Atari networks from scratch. Here are the numbers and limits. Edited by Luis Chavez-Mattos, Director, Product ยท Published 2026-11-05 ## What did GPT-6 Astra actually do with raw model weights? In a set of experiments on "weight space programming," researchers gave GPT-6 Astra a network's weights as plain text and asked it to work without gradient descent. Astra identified which game a network was trained on, guessed what a diffusion model would draw, identified the language a character model was trained on, and fixed a failing driving network by editing 3.5% of its weights. It also wrote game-playing networks from scratch that beat trained ones. ## TL;DR - Astra named the correct game for **all four Atari-style networks** (Breakout, Pong, Pac-Man, Freeway) from raw weights, with no list of candidate games. - It identified circle, square and triangle diffusion models, but drew **outlines instead of filled shapes**, which suggests it read weight structure rather than simulating the model. - With only intermediate layers, it still identified **English, Japanese and Python** character models. - In a single try with no tools, its edit made a stuck car succeed in **all 1,024 episodes** by changing 3.5% of the weights. - Networks Astra wrote directly as text **beat networks trained for 100 million steps** in all three test games. - The source material I had covers the first five experiments in detail. The tool-use and sycophancy results are not covered by the figures available here, so I don't report numbers for them. ## What is weight space programming? A neural network is a large set of numbers called weights. Training, usually gradient descent, adjusts them by repeated trial and error to reduce errors. It works, but it does not tell you why a given set of numbers produces a given behavior. The model stays a black box. Weight space programming flips the usual workflow. A general-purpose LLM reads a network's weights directly, as text, and writes new ones. No optimizer sits in the loop. Until now, LLMs have mostly been pointed at text, code and prompts, and asked to improve them. This work points one at the numbers themselves and asks it to find a hidden trait, repair a failure, or write a new network. ## Can Astra tell which game a network was trained on? Yes. Researchers trained four small networks to play Breakout, Pong, Pac-Man and Freeway. From the outside they look identical. Each network's weights went to Astra with one question: which game was this trained on? No options were given. Astra got all four right. In the Breakout example, roughly 17,000 weights were pasted in as text. Astra answered Breakout with 99% confidence and used 846 tokens. Its reasoning inferred a bottom-mounted paddle that moves horizontally, a moving ball above it, and reward targets in upper rows. The other games followed the same pattern: | Network | Structure Astra inferred | |---|---| | Pong | A paddle confined to the left edge with vertical controls and an independent ball | | Pac-Man | A fixed maze, collectibles, pursuing entities and four-direction movement | | Freeway | A bottom safe strip, horizontally moving lanes and a destination at the top (described as a road-crossing game, with Frogger as the name it gave) | ## Can it predict what a diffusion model will generate? Also yes, with a caveat. Researchers trained three diffusion models, one each for circles, squares and triangles. Astra matched all three from the weights alone. The error is informative. The real models generate filled shapes. Astra described and drew outlines. The researchers read that as evidence that Astra was not computing a forward pass in its head and checking the output. It was interpreting the geometry of the weights, and that produced a slightly wrong picture. ## Does it work on middle layers, not just the first and last? The first two experiments used the first and last layers, which leak a lot about what a model is for. The third removed that help. Researchers trained three small next-character models on English, Japanese (written in Latin letters, or romaji) and Python code. Astra received only intermediate weights. It identified all three languages correctly. It also predicted the behavior of internal components, small groups of weights that respond to particular features, without being allowed to run the model. Its predictions matched what researchers later measured for the Python, romaji and English models. ## How did Astra fix a failing network? This is the experiment with the clearest practical angle. A network trained for a physics driving task kept getting a car stuck at the top of a ramp. Astra received the weights, a description of the scene and one recorded episode. It had to explain the failure and write new weights. Reported results: - **One attempt, no tools.** Astra did not iterate or run code. - **1,024 of 1,024 episodes succeeded** after the edit. - **3.5% of the weights changed.** - **The diagnosis was specific.** Astra read the network as a velocity-sensitive throttle controller that effectively never samples reverse. The car needed to back up first to build speed, so the edit added that behavior. One of its commands overwrote a row of an embedding matrix with new values. The video's author speculates this points toward models editing their own weights, which would be much faster than retraining. That is speculation, not something the experiment tested. ## Can Astra write a network from scratch? The fifth experiment tested that. For three miniature Atari-style games (Breakout, Seaquest and Asterix, as best I can tell from the transcript), Astra got the game rules, the source code and a corresponding network. It had no access to data, losses, gradients or tools. It output the weights as text, and researchers evaluated the resulting network. Astra's networks beat the conventionally trained model, trained for 100 million steps, in all three games. Against a model trained for 500 million steps, the transcript says Astra's network scored 20 times as much in at least one game (apparently Breakout). The source cuts off there, so I can't give the other per-game comparisons. ## Where did it fall short? The sources I had show a few limits clearly: - **Outline versus fill.** The diffusion result shows that Astra's understanding can be structurally right and still wrong about details. - **Small networks.** Every experiment described involves compact models, such as roughly 17,000 weights in the game example. These results say little about frontier-scale networks. - **Narrow tasks.** The car fix and Atari networks have clean, well-defined success measures. The brief also lists a 1.5-million-parameter tool-use experiment and a sycophancy test where Astra fell short. The material available here does not include their figures, so I won't guess at them. Check the paper for those numbers before citing them. ## Is this result a big deal for interpretability? It's promising, with limits. Reading intent from raw numbers is a form of interpretability that does not require running the model or training a probe. If it scales, a capable LLM could audit another model's weights for hidden behaviors. The evidence so far comes from small, purpose-built networks where researchers know the ground truth, so it does not yet show that this works on production models. ## Frequently Asked Questions ### Did Astra use gradient descent or any training to edit the weights? No. In the from-scratch experiment it had no access to data, losses, gradients or tools. It wrote the weights directly as text, and researchers then evaluated the resulting network. ### How much of the car network did Astra change? About 3.5% of the weights. That one edit made the car succeed in all 1,024 test episodes, and the model got one attempt with no tools. ### Why does the diffusion mistake matter? Astra described circles as outlines, while the real model produces filled circles. That suggests it was reading the geometry of the weights rather than simulating the model's output. A forward-pass simulation would likely have caught the fill. ### Does this mean models can safely rewrite their own weights? Nothing in the experiments tested self-editing. They show one model reading and editing a different, much smaller network. Self-improvement is a speculation drawn from the results.