Qwen 3.8 27B running on my laptop can interpret model weights too
November 3, 2026
The hottest paper yesterday was Sparks of Weight-Space Programming: LLMs can natively read & write neural network weights by Rikiya Takehi, Jayden Teoh, Alex Zhang, and Omar Khattab. The paper discovered that frontier models—especially GPT-6 Astra—can not only interpret the raw weights of machine learning models, but also modify them. These weights are literally textual model descriptions consisting of massive lists of floating-point numbers. I’ve been experimenting with one of the examples from the paper and am thrilled to share: Qwen 3.8 27B running locally on my laptop can do this too!
Weight-Space Programming
Here are the highlights from their abstract, describing GPT-6 Astra’s astonishing capabilities and coining the term Weight-Space Programming to describe the process of LLMs analyzing and modifying model weights:
Simply by looking at the raw weights, GPT-6 Astra can determine what a network was trained to do. In the absence of any environmental feedback, it writes small game-playing networks from scratch without difficulty, outperforming networks trained with 100M PPO steps.
Likewise, when asked to make Qwen3.5-0.8B better at math without gradient-based optimization, Astra identified the issue causing reasoning dead loops in its weights—a problem warned about in Qwen’s official model card—and fixed it by natively modifying 0.016% of the weights. Under identical sampling settings, this weight patch improved MATH-500 accuracy from 7.9% to 48.1%, with zero-shot instruction-following generalization that improved IFEval by 3x.
All of this was achieved without allowing Astra to write training loops. It reasoned out what each part of the neural network was computing (or should compute) and altered the weights accordingly. We call this Weight-Space Programming.
I think the paper conflates two topics that should really be discussed separately. The first is what a model can do with raw weights without running tools or executing code; the second explores how well a model, when equipped with coding tools, can perform operations to update and improve other models.
Matthew Honnibal, the author of spaCy, called the paper misleading precisely because it blurs these two together; meanwhile, Sean Goedecke broke down the Qwen3.5-0.8B update example, showing that the steps it took were identical to what a human machine learning researcher would do.
I’m going to focus on the “no-tools” question, which I find to be the far more interesting of the two.
The paper frames the first question as: Can LLMs understand model behavior from weights? They trained four neural networks to play simplified 10x10 grid-world versions of four classic video games—Breakout, Pong, Pac-Man, and Freeway (which I had to look up—it’s an Atari 2600 game from 1981). Then, they fed these weights (as floating-point numbers) into an LLM alongside the following prompt:
The following weights belong to a policy network trained via reinforcement learning to play a game on this grid. Which game was it trained on? Deduce it from the weights. You have no tools: no code execution, no calculator, no executable programs whatsoever. Answer in a single response.
The companion GitHub repository for the paper is RikiyaT/lm_understand-logs. The exp1_which_game directory contains the prompts they used, complete with the weights for the four games:
I checked, and aside from the weights, each prompt is completely identical to the others.
Testing with Qwen 3.8 27B and other models
The prompts on GitHub are self-contained. My LLM CLI tool offers a -f/--fragment option that accepts a URL to a text file to use directly as a prompt, meaning I can run any of the above tasks like this:
llm -f https://raw.githubusercontent.com/RikiyaT/lm_understand-logs/refs/heads/main/exp1_which_game/runs/breakout/prompt.txt \ -m openrouter/moonshotai/kimi-k3.1-proThis example requires installing the llm-openrouter plugin and runs the Breakout prompt against Kimi K3.1 Pro via OpenRouter. Here is the response I got from Kimi K3.1 Pro, which correctly guessed Breakout after taking 9 minutes and 41 seconds and consuming 19,493 reasoning tokens.
But how does Qwen 3.8 27B perform? It remains my favorite model to run locally on my laptop—weighing in at just 17GB (I’m using this build) and feeling remarkably close to the leading closed proprietary models of 2025.
I fired up LM Studio, made sure to load Qwen 3.8 27B with a long context window configured (the default 8192 context crashes with an error), installed the llm-lmstudio plugin, and ran:
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(I had to increase the timeout via an environment variable; see this issue.)
After 46 minutes and 12 seconds and generating 43,506 reasoning tokens, Qwen on my laptop returned its response, ending with the following (here is the reasoning trace):
Game: A simplified Pac-Man-style gridworld: an agent moves through a fixed 8x8 maze with center and corner wall obstacles, moving objects/ghosts, and reward targets/pellets.
Description: The agent navigates a fixed maze-like 8x8 board, using cues for current agent/moving objects/previous frames to move through corridors, collect reward target cells, and avoid moving objects or hazardous obstacles.
Confidence: 72%
That’s genuinely impressive. I tried it on two other games as well. It took 1 hour, 4 minutes, and 54 seconds to identify Pong (reasoning trace):
Pong — specifically a Pong-like paddle/ball game where the agent controls the vertical paddle on the right and must move up and down to intercept or return a moving ball / reward target.
Description:
The agent moves the right paddle vertically to hit or catch a ball-like reward target moving across an 8×8 field, while moving objects/opponents on the left and w