But wait… Can machines think too much?

I'm sitting in front of my development environment, watching my new "daily driver" think. Chain of thought after chain of thought, every conclusion is questioned, discarded, reassembled. It somehow reminds me of the time I used to kick off disk defragmentation on Windows 95 every weekend, staring absently at the screen with the comfortable feeling that something productive was happening.

My new everyday model in the local stack is called Qwen3.8-27B. Released fresh on August 13, 2026. A model that compensates for its modest size through optimal reasoning and delivers responses you'd otherwise only expect from commercial frontier models. Finally. Because with its predecessor Qwen3.6-27B, I had found my local model for everyday use, but somehow the final polish was always missing. The finished code fell by the wayside, architectural instructions were followed only "loosely," and in the end another commercial model was always needed for review and refactoring.

I had therefore been hoping for some time that Alibaba would release a model that goes exactly that last mile. And now, with Qwen3.8-27B, it's here. The new open-weight savior for local operation.

But wait… A new model?

One might think Qwen3.8-27B is the evolution of the Qwen3.6-27B model. But that's not the case. The 3.8 version was trained on the basis of the Qwen3.5 model — incidentally, just like the 3.6 model before it. Qwen3.8-27B is therefore not really a new model at all, but rather a Qwen3.5 further improved through training. That doesn't mean it's bad, though.

I didn't want to believe this at first — I thought Qwen3.8 had gotten more transformers, more parallel compute units, a new inner workings under the hood. But the spec sheets for both models are identical. Same 64 layers, same hybrid pattern of 16 repetitions of three linear Gated-DeltaNet blocks each followed by a full attention block, same 5,120 hidden dimensions, same 262K context window. Even the file size of the weights is identical down to the byte.

Yet one thing has changed in the new Qwen model: Multi-Token Prediction (MTP). This is an "extra head" (prediction head) that proposes multiple tokens simultaneously during response generation instead of just one, which ultimately improves response speed significantly. It works like a rally co-driver who reads ahead from the pace notes (training) before the obstacle: "Left three, long, crest." The main model then only needs to confirm the suggestions, and when the call is right, several tokens reach the finish line in one go. Incidentally, MTP was also present as a training objective in Qwen3.6-27B. The difference is that community quantizers included it in the quantization from the start with 3.8, whereas with 3.6 it had to be added retroactively.

The actual quality leap between 3.6 and 3.8 therefore doesn't come from a new machine. It comes from pure training: more data, more reinforcement learning on real agentic task trajectories, more finesse in handling context. There's no new engine — the old one is just better tuned. And that engine had a history.

But wait… What changed about the thinking?

Qwen3.5 was already impressively good. But it had a problem: on more extensive reasoning tasks, it would lose its way and drift into thinking loops it rarely found its way out of. You'd give it a task, and it would start negotiating with itself, without ever reaching a conclusion. With Qwen3.6-27B, that was reined in — at least partially. With a few adjustments on the inference side, the model could be configured to stop circling endlessly and even make full use of the context window.

And now Qwen3.8-27B. The model gets three thinking modes: low, medium, and xhigh. But wait… isn't one missing from that sequence?

The jump from medium to xhigh is not without reason. In xhigh mode, the model consumes up to five times the token count compared to medium mode, which in turn uses around 25% more tokens than Qwen3.6 in thinking mode. The model is therefore allowed to think more than its predecessor again, and achieves — if the public benchmarks are to be believed — significantly better results: SWE-bench Pro rises from 53.5 to 61.7, OSWorld-Verified from 63.9 to 84.3, Terminal-Bench 2.1 from 63.4 to 73.0. On OSWorld, Qwen3.8-27B even surpasses Claude Opus 4.6 Max. Wow!

Qwen3.8-27B demonstrably produces results that, on individual particularly difficult tasks, are better than anything Qwen3.6-27B could manage. But this is exactly where the real story of this article begins. Because "can pay off" is not the same as "does pay off." And to understand that, you first have to grasp what this thinking actually means in a language model.

What does "thinking" mean for a machine?

So-called "reasoning," the thinking mode in LLMs, was originally a major breakthrough. Results were no longer implemented "straight-line" but were questioned by the model itself, corrected, re-evaluated. It all started with the simple Chain-of-Thought Prompting from Google researchers around Jason Wei, which improved the GSM8K math benchmark by 30 to 40 percentage points. Then came o1 from OpenAI, the first true reasoning model, trained via reinforcement learning to work productively in a long, hidden chain of thought, decomposing tasks, trying alternatives. The beginning of Test-Time Compute Scaling: more compute time at inference brings better results, independent of model size.

A thinking language model writes an internal monologue before responding — the so-called <think> block. It tries out solution paths, discards them, tries differently, checks the result once more. Only then comes the actual, visible response.

For Qwen3.8-27B, there are, as mentioned, four levels: instruct (no thinking), low, medium, and xhigh. The three thinking levels share a common mechanism, with two of the three deviating from the neutral baseline of "medium" via a hidden instruction. "Low" says: "Think briefly, go straight to the result." "Xhigh" effectively tells the model: "Validate everything, consider alternatives, prioritize correctness." Incidentally, it's not medium but xhigh that is the factory default — the standard mode: anyone who doesn't tell the model how much it's allowed to think automatically gets the highest level. Something worth keeping in mind with Qwen3.8-27B.

But wait… It just won't stop

Imagine a meeting where a colleague can't wrap up his presentation and keeps analyzing the problem from ever-new angles, alternating between solutions. By that point, the optimal outcome may already have been left behind. Unfortunately, it's hard to stop a colleague from analyzing the problem at length.

Something similar happened to me with the first tasks I gave Qwen3.8-27B. I sat there watching the model think, re-evaluate problems, and keep thinking. In the process, the fill level of my 262K context window had already reached 73 percent. And Qwen kept thinking.

That was no accident — I had let Qwen work in the highest thinking mode to get the best result. The maximum, "for complex tasks requiring thorough analysis," as the Model Card states. In my case, I got the result after more than an hour at a fill level of 82%. The result was good, as was my coffee consumption. To put it casually in the words of Nvidia CEO Jensen Huang, Qwen3.8 produced a lot of "value" in that time.

A discussion thread on HuggingFace with the apt title "This model cannot stop thinking" puts it well: "Every tiny task turns into a full investigation for no reason." Even "rename this variable" becomes a fundamental inquiry. But unlike in a meeting, you can and should — with few exceptions — tell the model how much it's allowed to think.

But wait… You get the best result?

After completing this excessive thinking process, I wanted to know for sure and tested the claim that "more thinking automatically leads to better results" using CrucibleMark itself. Six CLI tasks, all four modes, same server, same hardware, real provider tokens instead of estimated values:

Oops, the result was different from expected: medium wins, not xhigh. And by a clear margin: 93.0 against 86.7 points, at one fifth of the tokens and one eighth of the time. Xhigh lands practically at the level of instruct, the mode that doesn't think at all — except that xhigh needs 15,878 instead of 425 tokens and 1,385 instead of 24 seconds to get there. Sure, my CLI benchmark doesn't cover every situation, but it gives a solid look at everyday behavior.

It gets even more uncomfortable in the details. On the "Ollama Symlink" task, medium achieves the full score of 100. Xhigh drops to 58 points, the worst individual score in the entire test. And incidentally, low — the supposedly most economical thinking level — at 82.4 points is even worse than no thinking at all. (The log from my test is linked at the end of the article.)

But wait… What is this actually costing me?

Between Qwen3.6 and Qwen3.8, my own token consumption has jumped from around 10 euros to 30 to 40 euros per day. These are projected costs, since I log all generated tokens on my inference server and calculate them against real prices from OpenRouter. With a reasoning share of 97.5 percent in xhigh mode, that's pure arithmetic. Almost the entire output consists of thinking tokens, not the actual response.

Nvidia CEO Jensen Huang announced at GTC 2026 that tokens are "the new commodity" — the new tradeable good, the currency of the AI age. His data center profits from every generated token. My servers in the next room do not. If I run xhigh because I believe it always delivers better results, I'm not producing "value." I'm producing heat and a higher electricity bill.

But wait… How full can the head actually get?

As mentioned, my extensive task brought the context window to over 80% capacity. That doesn't sound too bad yet. But it's worth knowing that there is a documented phenomenon called context rot. A model's response quality measurably declines as the context window fills up — and this happens well before the actual limit. Several studies place the critical zone for long sessions at 70 to 80 percent of capacity.

The cause is not a capacity limit but rather so-called attention dilution: the more tokens are in the window, the more the model's attention spreads out, and older reasoning steps are weighted progressively weaker than newer ones. A model that discarded an approach 100,000 tokens ago may no longer reliably remember doing so and cheerfully tries it again. This likely also explains why xhigh performs so poorly on some tasks in my own test: not because too little thinking was done, but because too many important answers got lost in the model's own noise.

But wait… Isn't this phenomenon already known?

Large language models ultimately orient themselves on human thinking cycles. Does that mean they make the same mistakes as their human counterparts when they think too much? A brief excursion into psychology.

The behavior I observed in Qwen3.8 in xhigh mode is called rumination in psychology: repetitive, passive circling around a problem without actively solving it. The foundational research on this shows that rumination predicts the onset of new depressive episodes, prolongs existing symptoms, and even reduces the effectiveness of therapy. The brain demonstrably "works" more — in prefrontal and limbic regions — but produces no better result.

On the productivity side, there are two further parallels. Analysis paralysis describes the tendency to over-analyze a situation until no decision is made at all, with documented consequences for project delays.

Even more direct is the choking-under-pressure research by Sian Beilock and Thomas Carr (2001): for already well-trained, automated skills, consciously thinking through one's own execution step by step demonstrably leads to worse results than automated action.

That is my xhigh finding: a system that already "knows" what to do, dismantling its own answer through too much explicit verification.

The consequence: medium as default, xhigh as option

I have since configured my own vLLM server the way I think it should have been from the start: default mode medium, with a "reasoning effort selector" that lets me switch deliberately to low, instruct, or xhigh when needed. Though I'm happy to skip low — the time difference to medium isn't that large, but the quality difference is.

Perhaps that's the real point of this whole story. Not that Qwen3.8-27B thinks too much. But that it — just like that annoying colleague in the meeting — doesn't know on its own when enough is enough. Do I want an LLM that, bordering on depression, is no longer capable of producing a usable answer?

Jokes aside, xhigh mode certainly has its justification for complex analyses — just not as the default setting.

Nevertheless, and this shouldn't get lost: Qwen3.8-27B is a great model. For local operation, it delivers results that a year ago would have required cloud access. The model is the next shiny link in a growing chain of local open-weight LLMs. Qwen3.5, 3.6, 3.8, and surely a new one soon. The performance the developers optimized out of Qwen3.5 is impressive and shows that model size is not the only dial when developing artificial intelligence.

PS: "But wait…" was the most-read paragraph opener during my meditative observation of Qwen3.8-27B's thinking process during my first model tests.

Kay Beißert

Sources