GraftModel reading the run CAHQUk9fNaMUn3jPGsbBKdbmWBF2D1JCc3VaoP5GGhpump

Repairing a model by cutting into its weights.

GraftModel is a small agent that reads a model's weights, finds what it writes when it goes wrong, takes that out of a few dozen columns, and tests the result. If the model isn't better, the cut goes back.

The tree is drawn from the model itself. Each branch tip is a real neuron from Qwen3.5-0.8B, layers 10 to 13. Click one to read it.

How it works

Qwen3.5-0.8B has a bad habit. It works a problem out, then checks its answer, then checks again, and keeps going until it runs out of room. GraftModel goes after habits like that in four steps, and each one is on this page.

It reads the neurons straight from the model file, finds the direction the habit is written in, and takes it out of the 64 neurons that write it most. Then it lets the model answer real problems, and keeps the cut only if the model does better.

The method is from a team at MIT, who did this to the same model and took its MATH-500 score from 7.9% to 48.1% by changing 131,072 of 752 million weights.

Reading a neuron

Whenever a neuron fires, it adds the same 1,024 numbers to the model's running state, just scaled up or down. The model's word table lives in that same space, so you can hold a neuron's numbers up against the words and see which ones it pushes towards. You don't have to run the model at all.

Click a branch tip.

Loading

writes towards 

writes away from 

Loudness
-
Along the direction
-
Drives
-

Checked against 2,000 common words, in your browser. Middle layers rarely spell things out, so a jumble is a normal answer.

Making the cut

Drag to take the direction out of the 64 neurons marked in red. It's the real arithmetic on the real numbers, and the rest of the tree barely moves.

0%
Weights changed
0
Share of the model
0%
Mean first-branch strength
100%

This edits a copy in your browser. The model on the server isn't touched.

Running it for real

The only real test of a cut is to let the model answer problems, and that's slow on our machines. So GraftModel first scores each cut on saved text: does the model get readier to stop where it should, without stopping too soon? Only the best few are tried for real, on the same problems with the same random seeds as before. Anything that survives then gets one exam on problems it has never seen.

Trying it yourself

The idea underneath all this is simple. A lot of what a model does is carried by a handful of directions in its weights. Find the one behind a habit, take it out of a few columns, and the habit changes while every other weight stays exactly where it was. There's no retraining, and the edit is small enough to read, send to someone, or undo.

Looping is just the first case. The same steps could go after a needless refusal, a tone of voice, or a tic in the code a model writes. You can read any neuron straight from the file, compare what a layer writes when the habit shows up with what it writes when it doesn't, and try taking the difference out. What you get back is a patch: a layer number, one direction and 64 column numbers, a few kilobytes in all, plus the log of how it was found.

Connect over MCP

GraftModel runs as an MCP server. Connect to this one to read this model's neurons and follow the runs as they happen.

https://graftmodel.com/mcp

In Claude Code:

claude mcp add --transport http graftmodel https://graftmodel.com/mcp
read_neuron
layer, neuron: what one neuron writes
read_layer
layer: the main directions it can write
run_status
every cut screened, sampled and kept
model_info
layers, width and weight count

On your own model

The same server runs on your own machine. It should load most Hugging Face models built like Qwen, Llama, Mistral or Gemma; so far we've run it on Qwen3.5-0.8B.

curl -O https://graftmodel.com/graftmodel-src.tar.gz
tar xzf graftmodel-src.tar.gz
pip install torch transformers
python graftmodel/serve.py 8612 your-org/your-model

Then connect your client to http://127.0.0.1:8612/mcp. The repair loop is graftmodel/fix3.py. Give it practice problems from your own work and it runs on your hardware.