Empty replies from reasoning models in voice agents: thinking tokens eat your max_tokens

Why a reasoning model can return nothing

A reasoning model writes hidden "thinking" tokens before its visible answer. A token is the unit a model reads and writes, roughly a short word or part of one. The output cap you send with a request, called max_tokens, max_completion_tokens or max_output_tokens depending on the API, counts both the thinking and the answer.

OpenAI's reasoning guide says the cap limits the "total number of tokens the model generates", reasoning included, and that the limit can be reached "before any visible output tokens are produced" (OpenAI reasoning guide). When that happens the request still succeeds. The reply has no content, and its finish reason, the field that says why the model stopped, reads "length".

The rule is not specific to one provider. NVIDIA's open voice-agent framework keeps reasoning off by default. Its configurations that turn reasoning on raise the generation limit from 1,024 to 4,096 tokens, because the reasoning block and the spoken answer share one budget (NVIDIA NeMo voice agent docs).

Why it is hard to diagnose in a voice agent

An empty reply produces no error, so nothing alerts. And a silent agent is the symptom of half a dozen other faults, from a speech-to-text stall to a tool call the agent never spoke about, so the obvious suspects get checked first. Turn-taking settings and the prompt are usually blamed before anyone opens the raw response.

We hit this ourselves while probing a voice agent's model with a test harness. On the same model with a 320-token cap, 15 of 16 runs came back empty, each with about 320 reasoning tokens and no text. It nearly got written up as an empty-turn bug in the pipeline. The cause was the cap our harness was sending, not turn-taking and not the model.

Live calls were not affected, because production sent no output cap and no temperature for that model, so the provider's defaults applied. The fix was in the harness, which now sends exactly what production sends. We are not naming the model, because the lesson applies to any reasoning model.

How to spot it in your logs

Every OpenAI-compatible response carries the three facts you need: the finish reason, the visible content and the token usage. A reply where the finish reason is "length", the content is empty and there is no tool call is the signature. If usage also reports reasoning tokens close to the completion token count, the diagnosis is certain.

Log those fields on every turn, not only on errors. In a streaming pipeline the finish reason arrives on the last chunk, and token usage is often sent only if you ask for it, so make sure your client requests usage and your logger records it. The check below runs on a parsed response, including one from the Vyas LLM API, and is easy to wire into an alert on any assistant turn with no text and no tool call.

def empty_turn_reason(response: dict) -> str | None:
    """Explain an empty assistant turn in an OpenAI-compatible chat completion."""
    choice = response["choices"][0]
    message = choice.get("message") or {}
    content = (message.get("content") or "").strip()
    if content or message.get("tool_calls"):
        return None                                    # the turn said or did something
    usage = response.get("usage") or {}
    completion = usage.get("completion_tokens") or 0
    reasoning = (usage.get("completion_tokens_details") or {}).get("reasoning_tokens") or 0
    if choice.get("finish_reason") == "length":
        return f"output cap hit: {reasoning} of {completion} output tokens were reasoning"
    return f"empty reply, finish_reason={choice.get('finish_reason')}, {completion} output tokens"

# The shape reported in the o4-mini thread:
example = {
    "choices": [{"finish_reason": "length", "message": {"role": "assistant", "content": ""}}],
    "usage": {"completion_tokens": 3072,
              "completion_tokens_details": {"reasoning_tokens": 3072}},
}
print(empty_turn_reason(example))
# output cap hit: 3072 of 3072 output tokens were reasoning

What reasoning costs on a call, even when it works

Even when the cap is large enough, reasoning is expensive in a voice agent, because nothing can be spoken until the thinking ends. NVIDIA's documentation says that "no content reaches text-to-speech" until the reasoning block closes. A June 2026 post from Chanl, a company that builds customer-experience agents, estimates that a 4,000-token thinking budget adds 3 to 5 seconds before the caller hears anything (Chanl, 21 June 2026). Our guide to LLM time to first token on phone calls shows how small that budget is to begin with.

The money cost is direct too, because OpenAI's guide says reasoning tokens are billed as output tokens. An empty reply that hit the cap is therefore billed in full. Take an illustrative case: a model that spends 300 tokens reasoning on each of 4 turns a minute adds 1,200 output tokens a minute. A short spoken reply needs roughly 240 (our working assumption of 4 turns of about 60 tokens).

At gpt-5-mini's listed $2.00 per million output tokens (OpenAI pricing), output cost rises from $0.00048 to $0.00288 a call-minute. That is six times as much, before you count the delay.

Settings that stop empty turns

Pick one of three positions and set it on purpose. The first is to turn reasoning off for live turns. OpenAI's reasoning models take an effort setting whose values, depending on the model, include "none" or "minimal", and OpenAI notes that some models reject "none" with an error. Many open-weight models served by vLLM accept an enable_thinking switch through the chat template instead.

The second is to keep reasoning and size the cap for both parts. OpenAI recommends reserving at least 25,000 tokens for reasoning and output when you start experimenting, far more than a spoken reply needs. The third is what our production agents do: send no cap at all and let the provider's default apply. Reply length is then set through the prompt, and if you want a guard against runaway turns, a time limit provides one without cutting into the reasoning budget.