Ollama returns an empty response: how to turn off thinking (think)

How to tell whether this is the cause

The request doesn’t return an error. It takes much longer than usual and comes back empty: in the OpenAI-compatible API, choices[0].message.content arrives as empty text; in your program, that usually ends in “the response is not valid JSON” or a blank cell. If you repeat it, it happens again.

The clue is in the tokens used. In the case of this guide, the response showed completion_tokens 3,661 and total 4,096: exactly the size of the context. The model didn’t freeze; it ran out of room before it got to write the answer.

Fix 1: turn off reasoning

If the task is pulling out data, classifying or filling in a JSON, it usually doesn’t need to think. Each way of using Ollama has its own switch. In Windows PowerShell, use Invoke-RestMethod instead of curl, which is a different command there and doesn’t get along with JSON quotes.

Be careful with --hidethinking: according to Ollama’s official announcement, it only hides the reasoning on screen; it does not turn it off. The model keeps thinking and using up context.

• Ollama documentation: thinking
• Ollama announcement: thinking (console options)
• Ollama documentation: OpenAI compatibility (reasoning_effort)

Fix 2: let it think, but with more room

If you want it to reason (multi-step problems, reviewing a text with traps), raise the context so that your message, the reflection and the answer all fit. With 32,768 tokens, the small models we tested worked, and the speed dropped only slightly (86, 55 and 80 tokens per second with qwen3.5:4b, qwen3.5:9b and gemma4:12b). We didn’t measure how much qwen3.5:9b thinks with that room, so also set a maximum time in your program.

The OpenAI-compatible API doesn’t let you change the context on each request; Ollama’s documentation says to create your own model with a Modelfile.

How to check that it’s fixed

Repeat the same request and look at three things: the time (from about 60 s to a few seconds; in our test, 3.6 s), that completion_tokens is small and well below the context, and that the content isn’t empty and is valid JSON if you asked for it. In the native API, with thinking enabled, the reflection appears in a separate field (thinking) and the answer in content: if content is empty and thinking is full, this is the problem.

And protect your program so it doesn’t swallow the problem silently: if the content comes back empty, make it fail with a clear message instead of saving a blank row.

Why it happens

Models like qwen3.5 think by default: they write a reasoning before the final answer. Those tokens take up room in the context just like your message. With the context Ollama picked on the test PC (4,096 tokens; the log says so in the “vram-based default context” line), a message of about 435 tokens left about 3,600 for thinking and answering, and the reasoning used up all of it.

How much a model thinks is hard to predict. With another local server and a much larger model, we measured 54,512 tokens of hidden reasoning in a single answer. It is not a rare bug: it is what these models do if nothing holds them back.

The test numbers

Test PC with Windows 11 Pro, an NVIDIA graphics card with 16 GB and Ollama 0.40.14. Task: pull the actions out of some meeting minutes as JSON, calling qwen3.5:9b through the OpenAI-compatible API (/v1) with a response_format of type json_object.

• Without turning off the reasoning: two attempts, about 60 s each, empty text; completion_tokens 3,661 out of a total of 4,096.
• With reasoning_effort "none": 3.6 s and valid JSON.
• But the fix does not improve quality: qwen3.5:9b left the owner and date fields empty instead of writing “PENDING”, and the automatic check sent the minutes for review with 4 warnings (5 in the second set of minutes). gemma4:12b, with the same request, took 11.2 s and passed without warnings.
• In the rest of the local tests (speed, document search, invoice reading and quality) the native API was called with "think": false from the start.

Other empty responses that aren’t reasoning

• The message no longer fits: an agent like OpenCode sent 22,919 tokens before your request, with a 4,096 context (7,440 with an empty global configuration). The model never gets to see what you are asking. We explain it in OpenCode with Ollama not working.
• The model doesn’t accept think: the documentation says to check /api/show; if it doesn’t support it, the switch changes nothing.
• gpt-oss uses levels (low, medium and high) instead of on and off, according to Ollama’s documentation.
• The model doesn’t load: if it is bigger than your VRAM, it can end in a 500 error. That happened to qwen3.6:35b on 16 GB: Ollama error 500 “unable to load model”.