My Laptop Got Stuck on 'Thinking' Forever

No answer ever came from my laptop—just an endless “thinking” indicator

Last weekend I downloaded an open model onto my laptop. It was Qwen 3.8 27B, which Alibaba released on the 14th. The file was 17GB. I couldn’t resist trying it out—it struck me as remarkable that a model small enough to fit in less space than a modern video game could code, read images, and even call tools.

But when I typed a question and waited, no answer came. The screen just kept spinning with a “thinking” indicator. I tried it as a gguf file, then through mlx on my Mac—same result either time. It sat there in some ambiguous state, neither clearly dead nor clearly timed out.

When I dug into the cause, it turned out the model itself wasn’t broken. The problem was that its default settings weren’t calibrated for a personal laptop environment. So I looked into exactly what conditions this model’s defaults had been tuned for.

---

I asked for one circle and got an animated shape

I wasn’t the only one this happened to.

Developer Simon Willison published a record on the 16th of running the same model on two machines — a 128GB MacBook Pro and an Nvidia DGX Spark, both running the same 17GB 4-bit quantized¹ build.

His first prompt asked for an SVG of a pelican riding a bicycle. The result, he said, was the best he’d ever gotten from a local model. The bike frame’s shape was accurate, there was one leg on each side, and the wings reached the handlebars.

The problem was that it took 21 minutes to produce. The model spent 22,276 tokens on reasoning and only 3,223 on the actual output — roughly seven times more tokens spent thinking than answering. When he ran the same prompt without reasoning enabled, it finished in 137 seconds. The quality dropped, but by his judgment, not by 21 minutes’ worth.

What impressed him more was the next experiment. This time he asked for something extremely simple: draw one circle in SVG. The model’s reasoning trace opened like this:

It’s a simple request, but I want to go beyond a plain circle tag and produce something carefully crafted — something with the character of a geometric study, incorporating subtle animation, layered rings, and a distinctive color palette.

A few minutes later, out came an animated shape complete with concentric guide lines, tick marks, gradients, and a slowly rotating dotted ring. It looked good — but he had asked for one circle.

The same tendency showed up in coding tasks, too. When he asked the model to build a simple web tool that draws a coordinate box over a photo, the model added features on its own that were never requested. For users without a test photo on hand, it even built in a sample screen where you could draw directly. Its reasoning trace included the line: “This would be fun since it’s self-contained and demonstrable.” The model had decided, entirely on its own, to add work that was never asked for.

The freeze I ran into was tied to the same underlying issue. Willison wrote that he immediately hit a wall at LM Studio’s default context limit of 8,192 tokens — even a trivial question was enough for the model to burn through the entire limit just on reasoning. Once he raised the limit to 262,144 tokens, the problem disappeared. The model hadn’t failed to produce an answer — it had used up the entire context limit on reasoning, leaving no room to actually write one.

Why the reasoning default is set to the highest level

Most articles jump straight to “the Chinese model just isn’t polished yet” at this point. I don’t buy that interpretation. To me, this isn’t a mistake that slipped through during development — it’s a setting deliberately chosen to match the evaluation conditions.

Qwen 3.8 officially supports a setting that adjusts reasoning depth. There are three levels — xhigh, medium, and low — and the default is xhigh, the highest one. The documentation itself describes it as meant for thorough analysis of complex tasks.

Why set that as the default? The answer becomes clear once you look at the benchmark measurement conditions.

The model card for the previous generation, Qwen 3.6, discloses its evaluation conditions in detail. The terminal task benchmark ran with a 3-hour timeout, 32 CPUs, 48GB of RAM, a maximum output of 80,000 tokens, and a context window of 256,000 tokens, averaged over 5 runs. The software engineering benchmark used a 200,000-token context window with a custom agent harness².

Under these conditions, the optimal strategy is obvious: think for as long and as deeply as possible. There’s no reason to finish in 3 minutes when you’re given 3 hours. The grader isn’t looking at how long it took — only whether the answer is correct.

And that strategy actually paid off. By Qwen’s own published figures, 3.8 improved over the previous generation by 10 points on the terminal benchmark, 20 points on computer-operation evaluation, 16 points on web tasks, and 12 points on Android tasks. These are self-reported numbers measured on a single harness, so some caveats apply — but the direction is unmistakable.

Now let’s line up the conditions on the user’s side. A single laptop, a default context window of 8,192 tokens, one attempt, and at most a few minutes of patience. The very setting that boosts scores in the benchmark environment becomes the reason you don’t get an answer at all on a laptop.

What’s interesting is the community’s reaction. Even though 3.8 leads on benchmarks, local users still call 3.6 — released 4 months earlier — their daily driver. The reasoning given is that 3.6 is calmer, and less prone to endlessly extending its reasoning without ever landing on an answer. In fact, 3.6 has surpassed 7 million downloads over those four months. What we’re seeing is a split between the model that scores highest on benchmarks and the model people actually use locally, day to day.

When Anti-Repetition Settings Cause Language Mixing

The clue that these defaults are tuned for evaluation conditions shows up in the model documentation itself.

The Qwen 3.8 model card includes this guidance: if you get endless repetition, try raising the repetition penalty³ to somewhere between 0 and 2. And in the very next sentence, it warns that raising that value can intermittently cause language mixing and slightly degrade performance.

I think these two sentences sitting side by side capture exactly what this release is. It means the vendor knew that the fix for looping creates a different symptom — and shipped it anyway.

In practice, I saw Japanese and Arabic creep into answers when I asked questions in Korean. There’s research worth citing on why this happens. A paper quantifying language mixing in bilingual reasoning found that when one reasoning model was asked math problems in Chinese, 77.4% of its answers showed language mixing, switching languages an average of 7.22 times per problem. When asked in English, that figure was 0.6%. In other words, the dominant “thinking language” for this model family is English.

Put differently, users who ask questions in Korean run into language mixing far more often. But this problem doesn’t appear anywhere in the benchmark tables’ metrics. If it isn’t measured, there’s no reason for it to factor into how defaults get set.

The default-settings problem isn’t confined to the model itself, either. The settings of the runtime tools that actually run the model change the results just as dramatically.

One user’s log of running the same model in various configurations all day showed throughput ranging from 12 to 137 tokens per second on a single RTX 5090 — more than a tenfold spread. And in every setup where they enabled the feature that speeds things up by pre-guessing multiple tokens⁴, requests timed out entirely. The user themselves noted this was a runtime-environment compatibility issue, not the model’s fault. Meanwhile, Willison, using that same feature, got results 72% faster than the base build.

Turning on the same feature made one setup 72% faster and made another time out on every single request. The stalls I hit myself on both gguf and mlx were very likely tangled up in exactly this. The real-world performance of an open-weight model isn’t determined by the weights — it’s determined by the runtime stack layered on top of them. And the party that sets that stack’s defaults is yet another separate entity. The team that built the model, the team that uploaded the quantized build, and the team that built the runtime tool are all different groups. None of them set their configurations with my laptop in mind.

If you happen to be running this model yourself right now, here’s the order I’d recommend. First, raise the context limit generously. Then lower the reasoning depth to rein in overthinking. Then explicitly set the sampling top-k⁵ to 20. Save the repetition penalty as a last resort for stopping loops — because that’s exactly the value that triggers language mixing.

To be fair, I should add some balance here. Overthinking isn’t unique to this model. In community experiments, Google’s Gemma 4 26B actually used more tokens on the same questions. And on Hugging Face, there’s an ongoing dispute — one side arguing this is a structural flaw baked into the weights themselves, the other arguing that analysis was fabricated — with no resolution yet. And this is a model whose weights are fully open.

Oswarld’s Lens

I’ve sat in plenty of meetings while building GTM strategy where people argued over a product’s default settings. There’s a pattern that keeps repeating.

Two pressures always show up when defaults get decided. One side pushes for “let’s make sure a first-time user succeeds.” The other pushes for “let’s set things up so we look our best.” The second side wins more often than you’d think. The configuration that demos well, the one reviewers will flip on, the one that wins the comparison chart — that becomes the shipping default.

The problem is that this choice leaves no trace. No feature was cut, no performance was faked. It’s just a matter of where one setting gets placed. But from the user’s side, the default is effectively the product itself, since most people never open the settings screen.

That’s why I think the default reveals, better than anything else, who a product was actually built for. Marketing copy can target multiple audiences at once, but a default can only be set one way.

This case makes that choice unusually visible. An open-weight model has almost nothing to point to besides benchmark scores. With no sales organization, no distribution deals, no accumulated user data, all it can do is show its performance through leaderboard rankings. It’s not strange for a company in that position to pick defaults tuned to scoring conditions — if anything, it’s the natural move given the circumstances.

Still, understanding why they made that choice is different from accepting the default as-is. I learned that the hard way this week, hitting dead end after dead end on my laptop, waiting for answers that never came.

Closing

This run confirmed three things.

• Qwen 3.8 27B’s default reasoning level is xhigh, the highest setting available. Ask it for a single circle and it produces an elaborate animated shape, and when the context limit is tight, it burns every token on reasoning, leaving no room to actually write the answer.
• This isn’t a bug — it’s a choice tuned to grading conditions. In an evaluation that allows a 3-hour timeout and 80,000 tokens of output, the model that thinks longer wins.
• An individual user’s conditions are the opposite. That’s why the model that leads on benchmarks and the model people actually run locally end up being different — and why 3.6, released four months earlier, is still the everyday choice.

This same check isn’t specific to this one model. Open the settings screen of whatever AI tool you’re using right now. Was this default set for you — or for whoever is grading this product? More tools than you’d expect give different answers to those two questions.

Reader, has sticking with an AI tool’s default settings ever cost you something? Tell us in the comments which tool, which setting, and what changed once you switched it.

---

💬 Share in the comments what happened to you because of a default setting · 📨 If a colleague is evaluating local models, forward them this issue

---

References & Further Reading

Primary sources

• Simon Willison, “Qwen 3.8 27B is excellent, but it defaults to wildly overthinking things”, Simon Willison’s Weblog, 2026. 8. 16. Link ··· This is the source for the 21 minutes and 22,276 tokens. The full thinking trace from the circle-drawing example is linked here—I’d recommend opening at least that.
• Qwen, “Qwen3.8-27B Model Card”, Hugging Face, 2026. 8. 14. Link ··· The original document with the reasoning-step default and the presence_penalty warning. Good for checking what the vendor actually knew.
• Qwen, “Qwen3.6-27B Model Card”, Hugging Face, 2026. 4. Link ··· The benchmark conditions—a 3-hour timeout and 80,000 tokens—are written here. This is the core piece of evidence for today’s issue.
• “Why Qwen3.8-27B overthinks? Here the reason”, Hugging Face Community Discussion #76, 2026. 8. Link ··· A thread where claims of a structural flaw go back and forth with rebuttals. It’s also a good example of how open weights don’t guarantee consensus on behavior.

Background

• Yihao Wang et al., “The Impact of Language Mixing on Bilingual LLM Reasoning”, arXiv:2507.15849, 2025. Link ··· The source for the 77.4% and 0.6% language-mixing rates. It explains why non-English-speaking users end up with a different experience.

Related issues worth reading

• Issue 170: Six AI Claims of a Perfect Score, Only Two Officially Graded
• Issue 155: Gemini 3.6 Flash—Why You Should Compare Cost Per Task

---

The author is Oswarld (Kwangseob Ahn). Current roles: Adjunct Professor at Sejong University, Strategy Consultant at INLEVEL9. Career, research, books, and recent work are kept current on the About page. Latest · July 2026: HEMA-2: A Consolidation-Aware Tri-Memory Architecture with Multi-Channel Scheduling for Lifelong Conversational AI.

📝 Glossary

Footnotes

1. Quantization: The process of reducing a model’s numbers to lower precision, cutting file size and memory use. It’s similar to saving a high-resolution photo at slightly lower quality. This is how a 27B model shrinks down to 17GB and fits on a laptop. ↩

2. Harness: The outer wrapper used to evaluate or run a model. It’s what decides which tools the model can use, how many attempts it gets, and when to stop. The same model can score differently under a different harness. ↩

3. presence_penalty: A setting that lowers the probability of a phrase reappearing once it’s already been used. It reduces the symptom of the model repeating itself endlessly, but if the value is set too high, the model avoids its usual word choices and sometimes picks words from the wrong language entirely. ↩

4. Multi-Token Prediction (MTP): A method where a lightweight module guesses several upcoming words in advance, and the main model just quickly checks whether the guesses were right. When it works well, speed improves dramatically—but if the runtime environment doesn’t properly support this feature, it can grind to a halt instead. ↩

5. top_k: A value that determines how many of the highest-probability candidates are kept when choosing the next word. If this isn’t capped, even extremely low-probability, rare words remain in the candidate pool—which occasionally produces an unexpected character out of nowhere. ↩