---
title: "Empty LLM response? Reasoning tokens and max_tokens | BroadRouter"
description: "DeepSeek V4.1 Flash, GLM 5.3 and Qwen3.8 27B think before they answer, and that reasoning counts toward max_tokens. How to stop getting empty replies."
url: https://broadrouter.com/guides/reasoning-tokens-empty-response/
lang: en
updated: 2026-11-16
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

# Why a reasoning model returns an empty answer

Updated 2026-11-16

The model spent the whole max\_tokens budget on reasoning before it started the visible answer. On BroadNet Inference, DeepSeek V4.1 Flash, GLM 5.3 and Qwen3.8 27B reason first, and reasoning counts toward max\_tokens. Allow 1,000 tokens or more, or set reasoning\_effort to low.

You send a short prompt with `max_tokens: 100`, the request succeeds, and `choices[0].message.content` is empty. Nothing is broken: the answer never started.

## What happens

Reasoning models write a hidden chain of thought before the visible answer. Both share one `max_tokens` budget. With a small limit, the reasoning uses all of it, and in the standard chat-completions shape `finish_reason` is then `length`.

## Three fixes

**1\. Leave room.** Set `max_tokens` to 1,000 or more, as BroadNet’s docs advise. The [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) sizes the limit for your answer length and shows the cost.

**2\. Reason less.** Set `reasoning_effort` to `low` for simple tasks:

```python
import os
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])

response = client.chat.completions.create(
    model="broadnet/deepseek-v4.1-flash",
    reasoning_effort="low",
    max_tokens=1000,
    messages=[{"role": "user", "content": "Classify: 'refund my order' -> intent?"}],
)
```

**3\. Watch the usage.** When the model reports it, `usage.completion_tokens_details.reasoning_tokens` shows how much went to reasoning:

```python
print(response.choices[0].finish_reason)                       # "length" means the budget ran out
details = response.usage.completion_tokens_details             # None if the model doesn't report it
print(details.reasoning_tokens if details else "not reported")
```

In a stream, add `stream_options={"include_usage": True}` and the same usage arrives in the last chunk. See [streaming chat completions](https://broadrouter.com/guides/streaming-chat-completions/).

## Which models reason

| Model | Reasons first |
| --- | --- |
| DeepSeek V4.1 Flash (`broadnet/deepseek-v4.1-flash`) | Yes |
| GLM 5.3 (`broadnet/glm-5.3`) | Yes |
| Qwen3.8 27B (`broadnet/qwen3.8-27b`) | Yes |
| BroadNet Gemma 4 VL 26B (`broadnet/gemma-4-26b-a4b`) | Not listed |

## Troubleshooting

-   **Empty `content`, `finish_reason` is `length`.** Raise `max_tokens` or set `reasoning_effort` to `low`.
-   **Empty `content`, `finish_reason` is `stop`.** The limit was not the cause. Check your prompt and print the full response to see what came back.
-   **`AttributeError` on `completion_tokens_details`.** The model did not report the breakdown for that request; guard for `None` as in the example above.
-   **A slow first token in a stream.** The model is reasoning before it writes the answer. A lower `reasoning_effort` can shorten the wait.

If you run agents all day, reasoning tokens add up on pay-as-you-go. The [BroadNet pricing calculator](https://broadrouter.com/pricing/) shows when a flat [unlimited plan](https://broadrouter.com/guides/unlimited-llm-api-sessions/) costs less.

## Terms in this guide

[Token](https://broadrouter.com/glossary/token/)

A token is the unit of text a language model reads and writes: a word, part of a word, a punctuation mark or a byte sequence produced by the model's tokenizer. LLM APIs count, limit and usually bill usage in tokens.

[Chat Completions API](https://broadrouter.com/glossary/chat-completions-api/)

The Chat Completions API is OpenAI's HTTP endpoint, POST /v1/chat/completions, that takes a model name and a list of role-tagged messages and returns the model's next message. Its request and response shape became the common format that OpenAI-compatible providers and SDKs reuse.

[max\_tokens](https://broadrouter.com/glossary/max-tokens/)

max\_tokens is an LLM API parameter that sets the most tokens a model may generate in one response. When generation reaches the limit, it stops and the response is marked as cut off, for example with finish\_reason set to "length".

[Pay-as-you-go](https://broadrouter.com/glossary/pay-as-you-go/)

Pay-as-you-go is a pricing model in which you pay only for what you use, metered per unit such as tokens, requests or audio minutes, with no subscription or minimum commitment. Most LLM APIs bill this way, from a prepaid balance or a periodic invoice.

[Reasoning tokens](https://broadrouter.com/glossary/reasoning-tokens/)

Reasoning tokens are tokens a reasoning model generates to work through a problem before it writes its visible answer. They are usually billed as output tokens, count toward the output limit and the context window, and may be hidden or summarized by the API.

[Streaming](https://broadrouter.com/glossary/streaming/)

Streaming is a way of returning a language model response in small chunks while it is still being generated, instead of as one reply at the end. OpenAI-compatible APIs stream over server-sent events when the request sets stream to true.

[Tool calling](https://broadrouter.com/glossary/tool-calling/)

Tool calling, also called function calling, is an LLM API feature in which the model returns a structured request to run a function the developer has defined, with JSON arguments. The application runs the function and sends the result back; the model never runs code itself.

## Questions

### Does reasoning cost money?

On pay-as-you-go, reasoning is reported inside the completion tokens, which are billed at the output price. On an unlimited plan for DeepSeek V4.1 Flash there is no token meter, so they cost nothing extra.

### Does BroadNet Gemma 4 VL 26B reason?

BroadNet's docs list reasoning for DeepSeek V4.1 Flash, GLM 5.3 and Qwen3.8 27B, not for Gemma 4 VL 26B.

### Why is message content empty when finish\_reason is length?

The token budget ran out before the visible answer began. A reasoning model writes its reasoning first, and those tokens count toward max\_tokens. Raise max\_tokens to 1,000 or more, or lower reasoning\_effort.

### What does reasoning\_effort low do?

It asks the model to reason less before it answers. BroadNet's docs suggest it as the alternative to a bigger max\_tokens when a short limit leaves the answer empty. Use it for simple tasks such as classification or extraction.

### How do I see how many tokens went to reasoning?

Read usage.completion\_tokens\_details.reasoning\_tokens in the response, when the model reports it. In a stream, send stream\_options with include\_usage true and read it from the last chunk.

## Related guides

-   [Use the OpenAI Python SDK with BroadNet Inference](https://broadrouter.com/guides/openai-python-sdk/)
-   [Stream chat completions and handle dropped connections](https://broadrouter.com/guides/streaming-chat-completions/)
-   [BroadNet Inference error codes and when to retry](https://broadrouter.com/guides/errors-and-retries/)

Try it on your real workload. New accounts start with $5 of credit for Gemma and transcription. DeepSeek, GLM and Qwen3.8 need a top-up.

[Get started](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=guides-reasoning-tokens-empty-response&utm_content=page-cta) ·

**Sources**

-   [BroadNet Inference API reference, reasoning and cached tokens (checked 2026-11-16)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=guides-reasoning-tokens-empty-response&utm_content=sources#models)
