Reasoning Model Latency: Why First Token Takes 10s+

Reasoning models feel slow because they think before they speak: in our 2026-07-26 streaming benchmark GLM-5 streamed its first token at 2.5s but the first token a user could read did not arrive until 13.9s, after 807 hidden reasoning tokens. That gap, not raw throughput, is what makes a reasoning model feel sluggish on a simple prompt.

This page explains the mechanics behind that delay and when the wait is worth paying. All figures are medians of three SSE-streaming runs against one fixed prompt from a single network location on 2026-07-26. DeepSeek V4-Flash was measured natively on api.deepseek.com; every other endpoint here was OpenRouter-routed and still needs native re-verification. This is a snapshot, not a load test, and it measures speed only, not answer quality.

Two clocks: first token versus first content token

Reasoning-model latency is the gap between the moment a model starts emitting any stream token and the moment it emits the first token of the visible answer. Instruct-style models collapse that gap to zero because they have no separate thinking phase. Reasoning models open a thinking phase first, so two different clocks run.

The first clock is TTFT, the time to the first streamed token of any kind, reasoning included. The second is TTFCT, the time to the first content token, the first character a user actually sees. On an instruct model these two clocks read the same number. On a reasoning model TTFCT sits far behind TTFT because hundreds of thinking tokens stream in between.

On this prompt only two of the seven endpoints behaved as reasoning models. GLM-5 and MiniMax-M2.5 both opened a thinking phase, streamed a chain of reasoning tokens, and only then began the answer. The other five, including DeepSeek native, Kimi K2, Qwen3-235B, and the GPT-4o Western baseline, produced zero reasoning tokens and started answering immediately.

The measured gap (verified 2026-07)

Here is the first-content-token tax laid out. Every number is a median of three streaming runs on 2026-07-26; DeepSeek native was measured on api.deepseek.com, the rest were OpenRouter-routed and need native re-verification.

The pattern is stark. GLM-5 reached its first stream token faster than Qwen3-235B, yet a user staring at the screen waited more than four times longer for GLM-5 to say anything readable. The thinking phase, not the network path or the decode speed, owns that delay.

First-hand evidence block

We streamed each endpoint three times on 2026-07-26 with a fixed prompt, temperature 0, and max_tokens 4000. On GLM-5 we measured a median TTFT of 2.5s but a median first-content-token time of 13.89s, with 807 reasoning tokens emitted before the answer began and a total wall time of 18.61s. MiniMax-M2.5 measured 1.5s to first token, 10.68s to first content, and 449 reasoning tokens. By contrast DeepSeek V4-Flash native measured 0.71s to both first token and first content with zero reasoning tokens. These are OpenRouter-routed figures for GLM-5 and MiniMax and need native re-verification.

Why the tax exists

A reasoning model spends its thinking budget generating tokens you never see, a private scratchpad it uses to plan before committing to an answer. According to Z.ai's model documentation, GLM-5 exposes a thinking mode that emits an internal reasoning trace ahead of the final response. According to MiniMax's platform documentation, MiniMax-M2.5 is built as a reasoning model that plans before producing output.

Those thinking tokens are real work. The model runs full forward passes to produce them, so every reasoning token adds decode time to the visible answer's start. The more tokens the model decides to think, the later the answer begins. GLM-5 thought roughly 80 percent more tokens than MiniMax on this prompt and paid a correspondingly larger delay.

Instruct models skip that phase entirely. According to DeepSeek's API documentation, the deepseek-chat model returns its response directly without a separate reasoning stage, which is why our native run showed identical first-token and first-content-token clocks at 0.71s.

Fit, not quality: when to pay the tax

The reasoning tax is a latency cost, not a verdict on output quality. This benchmark measured speed only and makes no accuracy claims. The right framing is fit.

On a simple generation task like listing ten facts, the thinking phase is pure overhead. A user waiting on a chatbot reply feels a 13.9s blank screen as a failure even if the eventual answer is fine. For latency-sensitive interactive UX, an instruct model that streams immediately is the safer default.

On a hard multi-step problem, the scratchpad may earn its keep by catching errors before they reach the user. The trade is straightforward: you pay seconds up front for a chance at a better-planned answer. Whether that trade pays off depends entirely on your workload, and it is a decision each team makes against its own task mix.

Reasoning depth also varies by prompt. In our earlier 2026-07-10 task benchmark, a different non-streaming prompt with shorter outputs, MiniMax-M2.5 posted a 3.64s median on short tasks, far below its 10.68s first-content time here. GLM-5 in that same run once spent 117.3s on a trivial summarization. The lesson is that a reasoning model's delay is not a fixed constant; it scales with how much the model decides to think, which shifts with the prompt.

If you want the broader ranking across all seven endpoints, see our fastest Chinese LLM API benchmark. For a deeper split of when the two model styles suit which job, see Chinese LLM reasoning versus instruct models.

FAQ

Why does a reasoning model take 10 or more seconds to show its first word?

It streams hidden reasoning tokens before the visible answer. In our 2026-07-26 run GLM-5 emitted 807 reasoning tokens over 13.9s before its first content token, and MiniMax-M2.5 emitted 449 over 10.68s. The delay scales with how much the model decides to think.

Is TTFT the same as the first token I can read?

No. TTFT is the first streamed token of any kind, reasoning included. The first token you can read is the first content token, or TTFCT. On instruct models the two match; on reasoning models the content clock lags far behind the token clock.

Are reasoning models worse than instruct models?

This benchmark measured speed only, so it makes no quality claim. Reasoning is a fit question. The thinking phase is pure latency tax on simple generation but may be worth the wait on hard multi-step problems where planning helps.

Which endpoints in your test were instruct-style?

DeepSeek V4-Flash native, Kimi K2, Qwen3-235B-A22B, and the GPT-4o Western baseline all produced zero reasoning tokens and started answering immediately. Only GLM-5 and MiniMax-M2.5 opened a thinking phase on this prompt.

Does the reasoning delay stay constant across prompts?

No. Our earlier 2026-07-10 task benchmark saw MiniMax-M2.5 post a 3.64s median on short tasks, and GLM-5 once spent 117.3s on a trivial summarization. Reasoning depth, and therefore the delay, shifts with the prompt and configuration.

For the full cross-endpoint leaderboard and the native-versus-routed overhead pair, start at the fastest Chinese LLM API hub. Benchmark run and analysis by Kevin Fan, 2026-07-26.