← Blog

November 14, 2026 · Ibrahim Memon · 14 min read

We found where a small model doubts itself. Deleting it got 8× more math problems right.

Small reasoning models talk themselves out of answers. “Wait, let me double-check. Hmm, actually…” until they run out of room. We found the one direction inside Qwen3.5-0.8B that carries that habit, using four example pairs and no training. Then we removed it while the model ran.

4→32

GSM8K problems right out of 64, as shipped vs. direction removed

61:31

against MIT's Astra weight edit, 96 problems, their settings

0

weights changed, and no training

30

studies, each with its pass bars written before the data

The short version

  • Inside the model there is a single direction, at block 19 of 24, that lights up just before it writes “wait” or “hmm”. We built it from four hand-written pairs of reasoning, one that second-guesses and one that doesn't.
  • Subtracting that direction from the model's hidden state at every token took GSM8K from 4 of 64 right to 32 of 64 under a 3,000-token budget. It replicated at 23 and 26 on fresh problems and seeds.
  • Removing random directions of the same size got 1 to 7. Banning the words “wait”, “hmm” and “actually” outright got 13. So it is this direction, and it is more than vocabulary.
  • Under MIT CSAIL's own sampling, on 96 new problems with 9,000 tokens, it got 61 right against 31 for their Astra edit. Every problem theirs solved, ours solved too.
  • The honest catch. It mostly makes the model commit to an answer before it runs out of room. It doesn't make it better at math. We cover what it isn't in section 8.

Why look inside

Language models are a black box we mostly steer from the outside, with prompts, fine-tuning, and sampling tricks. We wanted to point at a specific habit, find where it lives, and change just that, the way you'd fix one function in a program.

The spark was MIT CSAIL's “Weight-Space Programming” post (November 2026, not peer reviewed). There, an AI agent called Astra edited 131,072 weights of Qwen3.5-0.8B and took MATH-500 from 7.9% to 48.1%. Its logs showed why. The model was getting stuck in reasoning loops, and Astra removed one “repetition” direction from 64 neurons in each of two layers. That took about 50 forward passes and 20 hours.

We first checked we could see the same thing with a much smaller lever. Four example pairs of looping against non-looping text gave a repetition direction that matches Astra's at cosine 0.75 and 0.70. It picked 39 of the same 64 neurons, where chance is about one. Erasing it cut repeated text from 46% to 11%, the same as Astra's edit, while a random edit of the same size did nothing. Then we asked a different question. The loops aren't random. They are full of “wait” and “let me double-check”. What if the real problem is self-doubt?

How we found it

A “direction” is a single arrow in the model's hidden space, 1,024 numbers long here. Many behaviors turn out to be readable as how far the model's state points along some arrow. To find the self-doubt arrow, we wrote four pairs. Each pair has the same math, but one version continues with doubt (“Wait, let me double-check. Hmm, actually, is that right?”) and the other doesn't. We ran both through the model and averaged block 19's output over the doubting text, then over the plain text. The difference between those two averages, scaled to length one, is the direction d.

To remove it, at every token, we subtract the hidden state's component along d:

h  ←  h − (h·d) d          # at block 19's output, every generated token

Nothing is trained and no weights change. The model runs as usual, minus one thing it would otherwise think. In our library, NeuroSpeak, it is three lines:

doubt = brain.concept("self_doubt", at=[19], pairs=four_pairs)
with brain.without(doubt, at=19):
    print(brain.ask(problem))

The result

On 64 GSM8K test problems the model had never been tuned on, with thinking on, one seed and a 3,000-token budget, the model as shipped got 4 right. With self-doubt removed it got 32. Repeated runs on other unused problems and seeds landed at 23 and 26 against 4 again. So the true size is probably closer to 25 than 32, which is still six times the baseline.

Figure 1 · Math problems right, out of 64

The model as shipped
4
Delete a random directionsame size, best of 4
7
Delete repetition, minus its doubt partbreaks loops, keeps the doubt
7
Ban “wait”, “hmm”, “actually”11 tokens, at the output
13
Delete the self-doubt directionone direction, block 19
32
Qwen3.5-0.8B · GSM8K test rows 800 to 863 · seed 20 · 3,000-token cap · thinking on. Replications of the last bar on other problems and seeds: 23 and 26.

Is it just any edit?

A result like this has an obvious way to be wrong. Maybe removing anything that size shakes the model loose. We tested that four ways.

  • Random directions. Four random directions, shaped like the model's own activity and tuned to remove as much as self-doubt does, got 1 to 7. Not one of them solved a problem self-doubt removal missed.
  • Breaking loops without touching doubt. We took the repetition direction and projected out its self-doubt part. Removing that cut verbatim repetition hard, from 47% to 17% of 8-grams, but got only 7 right. The model just kept second-guessing in new words.
  • Banning the words. Blocking the 11 tokens for “wait”, “hmm” and “actually” at the output got 13, and only 2 runs finished, against 17 with the direction removed. The doubt is upstream of the words.
  • Other learned directions. Removing directions for bullet lists, Chinese and restating did nothing. But those directions turned out to do nothing measurable on math text at all, so this is the weakest of the four controls.

Against MIT's weight edit

We reran Astra's published edit next to ours on 96 new problems, under MIT's sampling settings (including their presence penalty of 1.5), with a 9,000-token cap. First, their edit reproduced at the size their own logs predict, so the setup is fair. Then:

Figure 2 · Problems right, out of 96, at 9,000 tokens

As shipped, with their penalty
16
Matched random direction
14
MIT's Astra edit131,072 weights changed
31
Delete self-doubt0 weights changed
61
Both together
63
GSM8K test rows 704 to 799 · seed 18 · MIT's sampling with presence penalty 1.5 · 9,000-token cap. Of the problems: 31 both solve, 30 only ours, 0 only theirs.

The overlap is one-sided. Every problem their edit solved, ours also solved. But a few things keep this in proportion.

  • Their edit is more careful when it does finish. It was right on 31 of its 33 finished runs (94%). Ours was right on 60 of 72 (83%). Ours commits far more often, and more of those commitments are wrong.
  • MIT's headline numbers come from runs up to 32,768 tokens, and their median run is about 11,000. At 9,000 tokens their edit shows roughly 43% of its final gain, so it may close the gap with more room. We didn't test that.
  • The penalty matters. Without it, self-doubt removal still beat the plain model 46 to 8. But 18 of those 46 wrote the right answer and then repeated it until the cap. Counting only runs that finished, it tied Astra.

Where it lives, and how much

Depth matters. The same direction works as well at block 15 as at 19. At blocks 7 and 11 it removes nearly as much of the hidden state, yet gains only a fraction (+9 to +12 points against +44). Directions built from the same pairs at blocks 3, 7 and 11 don't help. Self-doubt, as something you can delete, is a late-layer thing.

The last bit counts most. Removing a third or two thirds of the direction got 7 and 13. All of it got 32. The signal also has two parts, a steady level and a rise and fall that tracks the text. Flattening the rise and fall while keeping the level got 19 to 21. Removing only the steady level wasn't shown to help.

Figure 3 · How much you remove, out of 64

Nothing
4
A third
7
Only the steady level
9
Two thirds
13
Only the rise and fall
19–21
All of it
32
Same problems and settings as Figure 1. “Only the rise and fall” holds the signal at a constant. Two constants were tried, giving 19 and 21.

No small circuit writes it. We traced which parts of the model write the signal. It builds up gradually, with 79% of its variation written across blocks 13 to 19. It takes 7 components to carry half and 14 to carry 80%. There is no single “doubt neuron” to switch off, which is exactly why you edit a direction rather than a neuron.

What it encodes. On ordinary runs, the direction rises just before the model writes a doubt word. In our latest study we split it into a pure doubt part and a pure “don't conclude yet” part. The doubt part tracks the signal's token-by-token movement almost perfectly (r = 0.97), and removing it alone got 17. The conclude part turned out unrelated to the direction and did nothing. So the part that moves looks like doubt, as the name says. Whether its steady level is about holding back from concluding is still open.

What it isn't

We publish the failures too. Here is what this result does not show.

  • Not better math. At these budgets, “right” mostly means the model wrote its answer before running out of room. Across 576 runs we found one wrong boxed answer. The edit changes whether an answer appears, not how good it is. With a 10,000-token budget the gain held, but whether it is more than speed stayed unsettled.
  • Not proven to be the cause. Adding the direction raised doubt words with dose. But our pre-registered test that adding it causes the behavior failed.
  • Not portable yet. On a second model, MobileLLM-R1-360M, the method failed or wasn't shown against the plain model.
  • Not free. Removing it costs about 0.02 to 0.03 nats per token on ordinary text.
  • Not a prediction of behavior. The signal is only slightly higher at the moment the model first writes the right answer, about the size text style alone produces.
  • Small scale. One 0.8B model, mostly one seed and one layer, 64 or 96 problems per study.

How we kept ourselves honest

This came out of 30 studies. Each one started with a plan file that set its pass bars and predictions before any data existed. Every major result was rescored by an independent AI reviewer (Claude, a different model from the one running the work), which reran the numbers from the raw traces and listed what we couldn't claim. When a study failed, we wrote it up as a failure. Several did, and some of our own predictions were wrong by a lot. Readers in these studies were AI models, not people. A human study is designed but hasn't run.

NeuroSpeak, the language

All of this was done in NeuroSpeak, a framework we are building for reading and writing a model's internals in words a person can check. It is a Python library with a small script language on top. Every statement runs one tensor operation and prints an English readout.

concept repetition at L15, L19:
  ask  "Solve 3x + 7 = 22."
  is   "3x = 15. Hmm, wait. 3x = 15. Hmm, wait."
  not  "3x = 15. Divide by 3: x = 5. Check: 3*5+7 = 22."

where repetition                         # which layers know this
erase repetition from L15.mlp, L19.mlp writers top 64 strength 6
expect repetition.is falls               # a promise, checked by running the model
expect repetition.not steady within 0.02
explain edit "astra_edit.npz"            # read someone else's weight edit back into words

Two ideas came out of this work. First, the unit of meaning is a direction, not a neuron. Astra's first suspect neuron fires on “years” and “$” in ordinary text, and writes repetition only by going negative. Second, edits should make promises the language checks. Those promises caught a real cost that both our edit and Astra's share, about 0.03 nats per token on good reasoning. And explain edit read Astra's raw weight change back as “one direction, rank 1, subtracted 6× from 64 neurons, about repetition”.

We wrote up the language itself, with real program output and the tools that failed, in NeuroSpeak, a language for reading and rewriting what a model thinks.

What's next

  • Bake the self-doubt removal into the weights, as we did for repetition, so it ships as an ordinary model file.
  • Settle doubt against “don't conclude yet” with three more planned arms.
  • Try larger models, and a second model family where the method actually carries.
  • Run the human study, so the words are tested on people and not only on AI readers.

If you work on interpretability or small reasoning models and want to compare notes, or you want this kind of surgery on a model you run, book a call.

Model: Qwen3.5-0.8B. Benchmark: GSM8K test split. MIT CSAIL's Astra edit was taken from the authors' published logs. Numbers are counts from single runs unless noted, with paired bootstrap confidence intervals in our study files.