# Weight space programming: what the Astra and Qwen claim shows

> MIT CSAIL researchers say GPT-6 Astra read and edited neural-network weights, lifting a small Qwen model's MATH-500 score from 7.9% to 48.1%. Here is what is shown and what is not.

URL: https://claudegpt.si/news/weight-space-programming-explained  
Published: 2026-11-03T06:52:35.327Z  
Author: ClaudeGPT Si Newsroom  
Section: Research  
Topics: OpenAI, GPT-6 Astra, Qwen, MIT CSAIL, Interpretability  
Publisher: ClaudeGPT Si

## Key takeaways

- MIT CSAIL researchers say GPT-6 Astra read and wrote neural-network weights in small experiments, without gradient descent.
- Their Qwen3.5-0.8B edit changed 0.016% of the weights and raised MATH-500 from 7.9% to 48.1%, mostly by cutting looping that made 93.0% of base answers hit the token limit.
- OpenAI's own pages do not mention this work, and no outside group has reproduced it.

Weight space programming is the idea that a large language model can read and edit the raw numbers inside another neural network, with no training run, and change what that network does. A November 2 [post by four MIT CSAIL researchers](https://rikiyat.github.io/blog/weight-space-programming/) says OpenAI's GPT-6 Astra did this in a set of small experiments, including one that raised a small Qwen model's MATH-500 score from 7.9% to 48.1%.

The post reached 2,370 points on Hacker News on November 2. It is a blog post with logs and a released model, not a peer-reviewed paper, and the authors call the results "very early".

## What weight space programming means

A neural network is a large pile of numbers called weights. Normally people change them by training: show the network examples and nudge the weights with gradient descent, a method that adjusts every number a little in the direction that reduces error.

The authors, Rikiya Takehi, Jayden Teoh, Alex Zhang and Omar Khattab, ask a different question. Can a frontier model look at the weights directly, understand what they do, and write new ones from a plain-language goal? They call that weight-space programming. They say the model they used was GPT-6 Astra, given the weights as data and, in some tests, a Python sandbox.

## What the post reports

The experiments fall into three groups. All numbers below are the authors' own.

**Reading weights.** From weights alone, Astra named which Atari game each of four small game-playing networks was trained on. It identified which shape each of several small image-generation models drew, though it described every shape as an outline when the models draw filled ones. From four middle blocks of a small language model, it identified the training language and found every attention head that copies text, with no false positives. One test failed: from weights alone, Astra could not tell which Gemma 3 270M model had been trained to flatter users. Given permission to inspect attention patterns on texts it wrote, it picked the right model in all three pairs.

**Editing weights.** Astra fixed a failing driving policy of 171,664 weights in one try by editing 3.5% of them, and the car then succeeded in all 1,024 test episodes. In the Qwen3.5-0.8B experiment, it removed one direction in layers 15 and 19, which changed 131,072 weights, about 0.016% of the model.

**Writing weights from scratch.** With no data, gradients or practice games, Astra wrote networks for three small arcade games. The post says they beat a reinforcement-learning baseline trained for 100 million steps in all three. On Breakout the gap is large (517.4 against 15.8). A baseline trained for 500 million steps still beat Astra on Seaquest (88.9 against 53.1) and Asterix (55.2 against 53.2). In 9x9 Go, with 50 forward passes allowed, a 1.48-million-weight network Astra wrote beat a network trained on 20 million games.

## The Qwen result in context

The headline numbers are real as reported, and the editing method is narrower than the headline suggests. The post says the base Qwen3.5-0.8B model hit the token limit on 93.0% of MATH-500 answers because it got stuck in loops. Astra's edit removed a direction tied to that looping. After 50 forward passes the edited model scored as follows, according to the authors.

| Qwen3.5-0.8B | MATH-500 | GSM8K | IFEval | Hit token limit |
| --- | --- | --- | --- | --- |
| Base | 7.9% | 13.8% | 21.0% | 93.0% |
| Edited | 48.1% | 67.1% | 62.3% | 33.1% |

So the edit mostly stopped the model from running out of room, not made it smarter at math. The authors say as much: editing "could remove an obstacle that hid an ability, but it could not add an ability the model lacked." On Gemma 3 270M, Astra's edits did not help, with MATH-500 going from 6.8% to roughly 7 to 7.7%. A third of the edited Qwen's answers still hit the token limit.

The edited weights are on [Hugging Face](https://huggingface.co/RikiyaT/Qwen3.5-0.8B-weight-space-programming) under Apache-2.0. The model card repeats the table and adds a re-run of the full MATH-500 set that scored 51.0%. The card calls it independent but does not say who ran it. With 10 or 25 forward passes, the post says the loops barely decreased.

## What OpenAI has said

OpenAI has not commented on this work in anything we could find. OpenAI's [API changelog](https://developers.openai.com/api/docs/changelog) lists GPT-6 Astra on September 3 as "our most capable model, built for the hardest end-to-end work." The [model page](https://developers.openai.com/api/docs/models/gpt-6-astra) lists a 1,050,000-token context window and $10 per million input tokens. Neither page mentions reading or writing weights. We covered those details in our [GPT-6 Astra release date and price](https://claudegpt.si/news/gpt-6-astra-release-date-price) article. The announcement post on openai.com returned an error when we tried to open it.

## What is not verified

- No one outside the authors has reproduced the Astra experiments. The post links logs, and the authors say they are still building a benchmark and harness for evaluating the ability.
- The 7.9% to 48.1% figure comes from the authors and their model card. We could not open the Reddit post that circulated it.
- The post names GPT-6 Astra but does not say how the model was prompted or what tools surrounded it beyond a Python sandbox in some tests, so the results may depend on that setup.
- Uses like auditing hidden behaviors, unlearning and self-improvement are listed as possibilities, not results.

The thing to watch is the authors' benchmark. If other labs' models can run the same tasks, the claim that this is a general ability of frontier models, and not a trick tied to one model and one harness, can be tested.

## Frequently asked questions

### What is weight space programming?

It is the idea that a language model can read and edit the weights of another neural network directly, from a plain-language goal, without a training run. The term comes from an MIT CSAIL blog post published on November 2, 2026.

### Did GPT-6 Astra improve Qwen?

The authors say an Astra edit to Qwen3.5-0.8B raised MATH-500 from 7.9% to 48.1%. The gain came mostly from removing a looping behavior, and 33.1% of edited answers still hit the token limit.

### Has OpenAI confirmed that Astra can edit weights?

Not in anything we could find. OpenAI's API changelog and model page for GPT-6 Astra do not mention reading or writing weights.

### Can I download the edited Qwen model?

Yes. The authors published it on Hugging Face as RikiyaT/Qwen3.5-0.8B-weight-space-programming under the Apache-2.0 license.

## Sources

- [Sparks of Weight-Space Programming: LLMs can natively read & write neural network weights](https://rikiyat.github.io/blog/weight-space-programming/), Rikiya Takehi et al., MIT CSAIL
- [Qwen3.5-0.8B-weight-space-programming model card](https://huggingface.co/RikiyaT/Qwen3.5-0.8B-weight-space-programming), Hugging Face
- [OpenAI API changelog](https://developers.openai.com/api/docs/changelog), OpenAI
- [GPT-6 Astra model page](https://developers.openai.com/api/docs/models/gpt-6-astra), OpenAI