Qwen 3.8 27B running locally also interprets neural network weights

The paper that started it all

On November 2, 2026, researchers Rikiya Takehi, Jayden Teoh, Alex Zhang, and Omar Khattab published "Sparks of Weight-Space Programming: LLMs can natively read & write neural network weights," a text the authors themselves call a blog post but that has the format of an academic paper, as Simon Willison reports on his blog. The central finding: frontier models, especially GPT-6 Astra, can interpret and even edit the raw weights of a neural network, that is, the sequence of floating-point numbers that defines what the model knows how to do, without running any code.

The team named this capability weight-space programming. According to the paper's abstract:

Just by looking at the raw weights, GPT-6 Astra can tell what a network was trained to do. And without any environment feedback, it has no trouble writing, from scratch, small game-playing networks that outplay networks trained with PPO for 100 million steps.

Rikiya Takehi, Jayden Teoh, Alex Zhang, and Omar Khattab, authors of the paper

The paper also shows GPT-6 Astra editing just 0.016% of the weights of Qwen3.5-0.8B to fix a reasoning loop already documented in Qwen's own model card, without using gradients. The result: the MATH-500 score rose from 7.9% to 48.1%, and the gain generalized even to instruction following, with IFEval tripling.

Two different questions within the same paper

Willison notes that the paper mixes two experiments that, in his reading, deserved to be treated separately. One is about what a model can do by looking at raw weights, without running anything. The other is about how much a model, already equipped with code tools, can edit another model. These are quite different capabilities, and the second is easier to dispute.

Matthew Honnibal, author of spaCy, called the paper misleading for mixing the two things. Sean Goedecke went further and took apart the Qwen3.5-0.8B editing example, showing that it repeats the same steps a human ML researcher would take, just narrated by an LLM. Willison chose to focus on the first question, interpreting weights with no tools at all, which he considers the more interesting one.

The experiment: guessing the game just from the weights

The authors trained four networks to play simplified, 10x10 grid versions of four classic Atari games: Breakout, Pong, Pac-Man, and Freeway. They then fed the weights of each network, as plain-text floating-point numbers, to an LLM, along with the following prompt, published in the RikiyaT/lm_understand-logs repository on GitHub:

The weights below belong to a policy network trained with reinforcement learning to play a game on this grid. What was the game used in training? Work from the weights. You have no tools: no code execution, no calculator, nothing to run. This is a single answer.

No running anything, no calculator, no interpreter: just the model looking at a pile of numbers and trying to reconstruct, by inference, what behavior it encodes.

Qwen 3.8 27B, on a laptop, repeating the feat

Willison took the same prompts from the paper's official repository and ran them against the local Qwen 3.8 27B, using LM Studio and the llm tool (his own creation) with the llm-lmstudio plugin. The command used was:

LMSTUDIO_TIMEOUT=900 \
llm -f https://raw.githubusercontent.com/RikiyaT/lm_understand-logs/refs/heads/main/exp1_which_game/runs/pacman/prompt.txt \
-m lmstudio/qwen/qwen3.8-27b

The -f/--fragment flag in llm accepts the URL of a text file directly as a prompt, which avoids having to download and paste the content manually. The default timeout had to be raised via the LMSTUDIO_TIMEOUT environment variable, because LM Studio's default context of 8,192 tokens failed before the model finished processing the weights.

The results, with Qwen 3.8 27B (a 17 GB model that Willison describes as his favorite to run locally):

In the Pac-Man case, the model's answer described an agent navigating a fixed 8x8 maze, using cues from its current position and previous frames to move through corridors, collect reward cells, and avoid moving objects, a functionally correct description even though the model had never seen the game running. Freeway, the most obscure of the four games (an Atari 2600 title from 1981), was the only one Qwen got wrong, confusing it with another grid-game variant.

For comparison, Willison also ran the Breakout prompt against Kimi K3.1 Pro via llm-openrouter, with the command llm -f <url> -m openrouter/moonshotai/kimi-k3.1-pro. Kimi got it right in 9m 41s and 19,493 reasoning tokens, much faster than the local Qwen, which is expected since it runs on dedicated cloud infrastructure instead of Willison's laptop.

What the reasoning traces reveal (and hide)

Willison published the complete reasoning traces from Qwen and describes reading them as fun to skim but nearly incomprehensible. A typical excerpt mixes row indices, channels, and discarded hypotheses in sequence, in the style of someone trying to decode a binary file by hand, with mentions of channel positions and successive hypotheses about where the agent would be on the grid.

This is the central point of Willison's skepticism: the process resembles an experienced human with pen and paper trying to decipher a spreadsheet of numbers more than it resembles a qualitative leap in capability. In his words:

I'm not ready to declare that the age of source code is over and our future involves incomprehensible machines editing their own model weights in incomprehensible ways.

Simon Willison

What changes for builders

For those developing or researching AI in Brazil, the most concrete data point isn't the capability itself, it's its cost. A single answer took between 46 minutes and over an hour running locally, with tens of thousands of reasoning tokens spent just to guess which of the four games a small network was trained to play. That's far from any debugging or interpretability workflow that fits into production today.

In summary: Willison's experiment proves an important point without overstating its reach. Weight-space programming, at least in the tool-free version, isn't the exclusive domain of billion-dollar closed models: a 27B-parameter open model, running on an ordinary laptop via LM Studio, performs the same kind of inference that GPT-6 Astra did in the original paper, with competitive stated confidence (72% to 88% on the three games it got right).

This has real value for those researching model interpretability without access to cutting-edge infrastructure: the barrier to entry for testing these techniques has dropped to a laptop with 17 GB free and an hour of patience per question. But the practical use case is still narrow. There is no demonstration, in the published material, of weight-space programming replacing fine-tuning, traditional debugging, or interpretability tools like probing and activation patching in a production setting.

The distinction between the paper's two experiments, which Honnibal and Goedecke demanded and Willison endorsed, also matters for anyone evaluating this kind of announcement: interpreting weights with no tools (what the local Qwen replicated) is one thing; editing another model's weights with the help of code tools (the Qwen3.5-0.8B example) is another, closer to what an ML researcher already does manually than to a new, emergent capability. Treating both as the same discovery is exactly what generates the kind of hype Willison himself tries to avoid.