# What Qwen is thinking when it gets stuck saying "Wait"

> Source: <https://alisorcorp.github.io/inside-a-reasoning-loop/>
> Published: 2026-11-03 12:28:15+00:00

On November 2, Rikiya Takehi, Jayden Teoh, Alex Zhang and Omar Khattab posted a set of experiments in which GPT-6 Astra reads and edits neural network weights. The one that drew the most attention on [Hacker News](https://news.ycombinator.com/item?id=50341174) has Astra find why Qwen3.5-0.8B loops on math problems and fix it by changing 0.016% of its weights, which took MATH-500 from 7.9% to 48.1%.

A lot of the thread decided the fix was abliteration: find a direction, project it out. The authors released the diff, so the edit can be rebuilt exactly, run locally, and read through the Jacobian lens at the token where the model decides to loop.

Astra's edit subtracts one direction six times over from 64 neurons in each of two layers, so those neurons now push the opposite way at five times their old strength. Removing the direction once, the abliteration recipe, barely moves the model's odds at a single loop point, though over a full generation it still cuts loops by about a third. Astra's version cuts them by 86%. Through the lens you can see what the edit changes. At the token before another "Wait", the unedited model has nothing but "Wait" and doubt in mind, and the edited one adds "Verification", "Completion" and "Result".

Claude Opus 5.5 did the work behind this page on my laptop and a mini PC. It rebuilt the edit, wrote and ran every script, spotted the alpha-6 structure in the diff, and ran the evals.

## The loop

In the authors' evaluation the unedited model ran out of its 32,768-token budget on 93% of MATH-500 answers. Read a few of those texts and they end the same way. The model reaches an answer, checks it, and checks it again, writing "Wait, $140 * 6 = $840." for thousands of tokens. The authors' sampling includes a presence penalty of 1.5, which can't break a cycle like this because every token in it has already appeared and carries the same flat penalty.

The decision to loop happens at one token (here the whitespace after the bullet), where the model chooses between another "Wait" and moving on. That's where the lens reads in the figure above. The unedited model puts essentially all of its probability on "Wait", and from about 60% depth on, the lens finds little else in its workspace.

## Keep checking or stop

To see what's specific to looping, the comparison below uses two kinds of decision point in the unedited model's own generations: the token before an in-loop "Wait" in 8 looping texts, and the token before `</think>` in 8 texts that finished. The lens readouts below are averaged over each group.

From about 60% depth on, loop points are full of "Wait" plus "Wrong", "Nope" and "Hmm". Stop points hold `</think>`, "Answer", "Output" and "Formatting", so at that point the model seems to be thinking about how to present the answer rather than whether it's right. At 50% depth the looping model already has "Final" and "Conclusion" in mind, which makes the later doubt look like something that overrides a decision it had half made. It isn't perfectly clean. "Wait" also turns up at stop points at 71% and 88% depth, and an average over 8 texts hides a lot of variation.

## What the edit is

The released diff for the 50-pass run touches two matrices, the MLP down-projections in layers 15 and 19, and in each one it's exactly rank one. On the 64 edited columns, the component along that single direction ends at −5.0 times its original value, which is W − 6uuᵀW. Astra's own notes call it "top64 alpha6". The 10-pass run used the same kind of edit at alpha 1.5 across 30 matrices.

Run through the lens, one end of the direction reads "Actually", "?!" and Chinese tokens meaning roughly "or is it", "actually it's" and "not at all". The other end reads "results", "outcomes" and "calculations". Those 64 neurons were writing toward the doubt end, and much harder in looping text, so flipping them turns the strongest doubt-writers into conclusion-writers.

A plain difference of means between looping and finishing activations doesn't find the same direction. Averaged over windows, it lines up with Astra's direction only partly (cosine 0.36 in layer 15 and 0.45 in layer 19). Taken at the exact decision tokens, it barely does (0.17 or less at every layer). The lens reads both as formatting noise. Astra's notes describe matched productive and repetitive contexts plus dose and random-direction controls, which found something a simple average misses.

## Why removal isn't enough

Keeping the same direction and the same 64 neurons and varying only the strength shows how much the size of the push matters. The measure is the model's probability of writing "Wait" at in-loop decision points, teacher-forced on 9 looping generations. Alpha 1 is plain removal.

In generation, on 40 GSM8K test problems, the unedited model looped on 29 and got 8 right. Plain removal (α = 1) looped on 19 and got 13 right. With Astra's edit it looped on 4 and got 19 right, fixing 12 problems and breaking 1. That's more than the teacher-forced numbers suggest. The likely reason is that a slightly lower chance of "Wait" at each cycle compounds over a long loop until the model gets out. Forty problems is a small sample, so read the middle bar as "helps some" rather than an exact third. Every answer the unedited model managed to finish was correct (8 of 8), which fits the paper's reading that the loop hides math the model can already do. The authors report 67% for the edited model at a 32k cap. Most of my gap is probably the 12 edited answers that hit my 16k cap.

## Quantization

The edit converts to GGUF cleanly, and the base and edited bf16 files differ only in the two edited tensors, entry for entry. At Q4_K_M it still holds: 1 loop in 40 and 16 correct. The 4-bit model finishes more often but gets more of its finished answers wrong (16 of 29, against 19 of 24 at bf16). I read that as the usual cost of running a 0.8B model at 4 bits, since the loops stay fixed.

## Method and limits

- Model: `Qwen/Qwen3.5-0.8B` at revision`2fc0636` , thinking on. The edit was rebuilt with the authors'`apply_edit.py` from`exp8_math/runs/p50c/edit` , and every tensor hash matched their evaluated checkpoint.
- Lens: Neuronpedia's pre-fitted Jacobian lens for this model (233 prompts), read as `lm_head(norm(J`<sub>l</sub> h))
the way[anthropics/jacobian-lens](https://github.com/anthropics/jacobian-lens) does it.
- Texts: the authors' released first samples from the unedited model on GSM8K. Loop points come from a compression-based detector calibrated on their outputs, which caught 85% of answers that never finished and wrongly flagged 1% of the ones that did.
- Evals: llama.cpp on a mini PC's integrated GPU, 8 parallel slots, the same detector stopping loops early, a 16k-token cap instead of the authors' 32k.

It's one small model, and the samples are small: single examples or 8 to 9 generations for the lens and dose readouts, 40 problems for each eval. The dose test is teacher-forced on text the unedited model wrote, so it measures the next-token choice, not what the edited model would go on to write. The lens shows what a state is disposed to make the model say, which is suggestive and nothing more.

Scripts and the figure data are in the [repo](https://github.com/alisorcorp/inside-a-reasoning-loop/tree/main/code).