Orkun Soylu

2 min read

Qwen3.8-27B: thinking on vs off

With think=false the model just moves its reasoning into the visible answer, which gets longer. It only wins on plain fact lookups; on questions that need reasoning, thinking mode was 22–40% faster.

Tested
Setup

Radeon Pro W7800 48 GB — bare-metal workstationBare metal, Linux, ROCm (Ollama) · AMD Ryzen 5 7600 (6C/12T, AVX-512) · 64 GB DDR5-6400

Runtime
Ollama 0.32.14 (ROCm)
Models

qwen3.8-27b-uncensoredQ8_0tested

Verdict

Use think=false for simple factual questions (2× faster); leave thinking on for anything that needs reasoning — the model reasons either way, and it does it more compactly inside the thinking block.

Works

  • Fact lookup: 6 s without thinking vs 11–14 s with it
  • Reasoning prompts: thinking mode 22–40% faster end to end

Doesn’t

  • think cannot be set in a Modelfile — every caller must send it
  • Manual GGUF imports without RENDERER/PARSER silently ignore the think flag
Average time, think on
20.3s
Average time, think off
24.0s
Visible answer length, off vs on
1,064 vs 339chars

Time per answer

lower is better

3 questions × 2 runs, temperature 1, mean of the two runs

  • think = true
  • think = false
Simple fact (3rd most populous city)
12.5 sthink = true · 12.5 s
6.0 sthink = false · 6.0 s
Probability problem
22.5 sthink = true · 22.5 s
33.5 sthink = false · 33.5 s
List prime numbers
26.0 sthink = true · 26.0 s
32.5 sthink = false · 32.5 s
Data
think = truethink = false
Simple fact (3rd most populous city)12.5 s6.0 s
Probability problem22.5 s33.5 s
List prime numbers26.0 s32.5 s

Setup

3 questions × 2 runs each, temperature=1, on the abliterated Qwen3.8-27B Q8_0 (same architecture as the official model). I switched thinking on and off with the per-request think parameter.

Results

Question type think=true think=false Faster
Simple fact (“3rd most populous city”) 14 s, 11 s 6 s, 6 s no-think ~2×
Probability problem 22 s, 23 s 32 s, 35 s thinking ~40%
List prime numbers 26 s, 26 s 32 s, 33 s thinking ~22%
Average 20.3 s / 391 tokens 24.0 s / 463 tokens —

Why think=false is often slower

The model doesn’t stop reasoning — it moves the reasoning into the visible answer. The average visible answer grew from 339 to 1,064 characters. Reasoning in prose costs more tokens than the compact thinking block does. The only win is on questions that need no reasoning at all.

My rule of thumb: think=false for simple, factual lookups; leave it on when the question needs reasoning. If what bothers you is seeing the thinking rather than waiting for it, hide it in the client instead (e.g. --hidethinking) — the work still happens, it just isn’t printed.

The low/high effort levels gave inconsistent results on a single sample (low thought longer than high), and I couldn’t separate them from noise.

Two traps

think can’t live in a Modelfile. PARAMETER think false → Error: unknown parameter 'think'. It’s per-request only (--think=false on the CLI, "think": false in the API), so there’s no persistent default — whatever app is calling the model has to send it.

A manual GGUF import without RENDERER/PARSER breaks thinking control. My first import had just two FROM lines. The result: the raw <think> block showed up inside content, and the think flag did nothing. Copying RENDERER qwen3.8 + PARSER qwen3.5 and the sampling parameters (temperature 1, top_k 20, top_p 0.95, min_p 0) from the registry model fixed it. To diagnose it, diff ollama show --modelfile against the official model — the model still “works” without them, so this one fails silently.