Qwen3.8 27B overthinks. Turning off reasoning reduced a 21-minute process to 137 seconds

When you install a local LLM and think, "This is slow," sometimes the cause isn't the model's performance, but the initial settings.

Qwen3.8 27B was exactly that case. Reading the actual measurements published by Simon Willison, the same prompt went from 21 minutes to 137 seconds with just one setting change. That's about 9 times faster.

What you will learn in this article:

• Qwen3.8 27B specs and required disk space

• What happens with default settings (including actual measurements)

• 3 settings you should change first

Basic specs of Qwen3.8 27B

First, let's organize the prerequisites.

• Parameter count: 27B

• License: Apache 2.0

• Maximum context length: 262,144 tokens

• Download size: 17GB (Q4_K_M quantized GGUF)

Since it is 17GB, it falls within a barely realistic range even for a Mac with 24GB of memory. The fact that the license is Apache 2.0 also makes it easy to handle.

Simon Willison's verification environment was a 128GB M5 Max MacBook Pro and an NVIDIA DGX Spark. The generation speed when running the GGUF version in LM Studio was 15-30 tokens/second. For reference, the API-side figures he cites are 74 tokens/second for OpenAI 5.6 Sol and 184 tokens/second for Luna. I think it is well within the practical range for local use.

The problem wasn't speed, it was "overthinking"

This is where the main point begins.

Qwen3.8 27B allows you to switch the depth of reasoning with `reasoning_effort`. The values are in three levels: `xhigh`, `medium`, and `low`. And the default is `xhigh`.

Here is the result of sending the prompt "Draw an SVG of a pelican riding a bicycle" with the default settings.

• reasoning_effort is xhigh (default): 22,276 reasoning tokens, 3,223 output tokens, 21 minutes

• Reasoning off with the same prompt: 3,715 tokens, 137 seconds

The amount of output itself is not much different. The difference is entirely in the amount of thinking done before producing the answer. It was calculating in a way that spent over 20,000 tokens on a simple drawing.

Since local LLMs have no costs other than electricity, it is easy to run them without thinking because 'it's free.' However, the actual experience of waiting for a response changes completely with this setting. Some of the impressions that '27B is heavy' might be caused by 'xhigh' rather than the model itself.

3 settings to change first

1. Increase context length to 262,144

The default context length in LM Studio is 8,192 tokens. Since Qwen3.8 easily uses this up, it will get stuck even on simple problems if left as is.

Please set the context length to the maximum of 262,144 on the model loading screen. This is not a setting where 'it's better to increase it,' but rather a type of setting where you won't get the raw performance unless you increase it.

2. Set reasoning_effort to low, or turn it off

When calling via API, pass 'low' to 'reasoning_effort'. For tasks that don't require much thinking, such as translation, summarization, or formatting, you can turn off reasoning itself.

Conversely, it is practical to use 'medium' or 'xhigh' only when code generation or multi-step reasoning is required. You just need to keep in mind that the default is set to the heaviest setting.

3. Enable MTP in llama.cpp

If you want to go for even more speed, llama.cpp's Multi-Token Prediction (MTP) is effective. According to his measurements, compared to the default GGUF in LM Studio, it resulted in about 72% faster performance.

These are the three flags for server startup.

--spec-default
--spec-type draft-mtp
--reasoning-preserve

Since MTP is a mechanism that predicts multiple tokens at once, the difference is more pronounced in tasks with longer generations. It is straightforward to reduce unnecessary thinking with 1 and 2, and then use this to speed up the generation itself.

Summary

• Qwen3.8 27B is an Apache 2.0 27B model. 17GB with Q4_K_M quantization, context is 262,144 tokens

• The default 'reasoning_effort: xhigh' takes 21 minutes for the same prompt. 137 seconds if turned off

• LM Studio gets stuck with the default context of 8,192. Increase it to the maximum

• You can add about 72% speed with llama.cpp's MTP ('--spec-type draft-mtp')

Before concluding that a local LLM is 'unusable,' sometimes just reviewing three settings can change your impression. Qwen3.8 27B was a typical example of this.

Note that the actual measurements in this article are based on verification by Simon Willison. These are not values run in my own environment, so please be careful about remaining memory when trying it on a 24GB class Mac.

Even when it comes to "running locally," the premise itself falls apart as models get larger. The story about how it actually required at least 223GB to run GLM-5.2 should help you make faster decisions if you read it before buying equipment.