Reasoning

Several models expose a separate reasoning (thinking) step. When it runs, the response carries the reasoning in reasoning_content on the message and a reasoning_tokens count under usage, alongside the normal content.

The control differs by model family, so the table below is the quick reference. The sections that follow show each family in full.

Model family	Reasoning by default	How to turn on / off	Depth control
GLM 5.3, GLM 5.3-Flash	On	reasoning_effort: "none" or chat_template_kwargs: {"enable_thinking": false}	reasoning_effort: "low" or "high"; omitted uses maximum depth
GLM 5.2	On	chat_template_kwargs: {"enable_thinking": true / false}	reasoning_effort: "high" or "max"
GLM 5.1, GLM 5-Turbo	On	chat_template_kwargs: {"enable_thinking": true / false}	No effort levels
DeepSeek V4 (Flash, Pro)	Off	chat_template_kwargs: {"thinking": true}	reasoning_effort: "high" or "max"
MiniMax M3	On (adaptive)	chat_template_kwargs: {"thinking_mode": "disabled"}	Modes only, no effort levels
Kimi K2.7 Code	On (always)	Not toggleable	None
Qwen 3.8	On (always)	Not toggleable	reasoning_effort: "xhigh" (default), "medium", "low"

DeepSeek V4 reasoning is off by default on TensorX. Enable it per request with chat_template_kwargs: {"thinking": true}.

The key name is per family: GLM uses enable_thinking, DeepSeek V4 uses thinking, and MiniMax M3 uses thinking_mode. Sending the wrong key is silently ignored, which looks like the parameter "does nothing".

GLM 5.3 and GLM 5.3-Flash

Both models use maximum reasoning depth by default.

max_tokens is a budget for reasoning and the answer. GLM 5.3 and GLM 5.3-Flash default to maximum reasoning depth, which on even a trivial prompt can consume 400 to 750 tokens before the answer starts. If your max_tokens is smaller than that, the request ends with finish_reason: "length" and content comes back empty while you are still billed for the reasoning.

A finish_reason of "length", empty content, and reasoning_tokens close to max_tokens indicate that the response budget was exhausted during reasoning.

Measured on z-ai/glm-5.3 with max_tokens: 400, asking for a short Python function:

Request	reasoning_tokens	finish_reason	content
No effort set (defaults to max)	402	length	empty
reasoning_effort: "low"	1	stop	returned normally
reasoning_effort: "high"	4	stop	returned normally
reasoning_effort: "medium"	402	length	empty
chat_template_kwargs: {"enable_thinking": false}	0	stop	returned normally

Use one of these controls:

1. Set reasoning_effort to "low" or "high" to retain reasoning with a lower depth.

2. Leave max_tokens unset unless the application requires an explicit response budget. Query GET /v1/model/info for the model's max_output_tokens before setting one.

3. Turn thinking off with chat_template_kwargs: {"enable_thinking": false}.

reasoning_effort mapping

SGLang handles "none" before the chat template and disables thinking. The template has explicit depth branches for "low" and "high". Other accepted effort values use the maximum-depth branch, which is also the default when the parameter is omitted. Values outside the API's accepted enum are rejected during request validation.

Value sent	What the model gets
"low"	Low
"high"	High
"none"	Thinking disabled
"minimal", "medium", "xhigh", "max", or omitted	Max

"medium" is accepted but selects the maximum-depth template branch rather than an intermediate depth. Use "low" or "high" when a bounded reasoning depth is required.

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.tensorx.ai/v1"
)

response = client.chat.completions.create(
    model="z-ai/glm-5.3",
    messages=[{"role": "user", "content": "Write a Python function that reverses a string."}],
    max_tokens=400,
    reasoning_effort="low"
)

print(response.choices[0].message.content)
print(response.usage.reasoning_tokens)

Turning thinking off

response = client.chat.completions.create(
    model="z-ai/glm-5.3-flash",
    messages=[{"role": "user", "content": "What is 15% of 240?"}],
    extra_body={"chat_template_kwargs": {"enable_thinking": False}}
)

The key must go inside chat_template_kwargs. A top-level enable_thinking is not part of the OpenAI schema and is ignored, which looks like the parameter doing nothing.

Multi-turn: clear_thinking

On a multi-turn conversation these models replay the reasoning from previous assistant turns back into the prompt by default, which is what makes long tool-calling loops coherent. It also means your prompt grows faster than the visible message text suggests.

Set clear_thinking: true when prior reasoning should not be included in subsequent prompts.

response = client.chat.completions.create(
    model="z-ai/glm-5.3",
    messages=conversation_so_far,
    extra_body={"chat_template_kwargs": {"clear_thinking": True}}
)

GLM 5.3-Flash is multimodal and accepts images on the same endpoint. Reasoning behaves identically on image requests.

GLM (5.2, 5.1, 5-Turbo)

GLM models think by default. Turn thinking off with enable_thinking: false inside chat_template_kwargs:

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.tensorx.ai/v1"
)

# Thinking off (direct answer, no reasoning_content)
response = client.chat.completions.create(
    model="z-ai/glm-5.2",
    messages=[{"role": "user", "content": "What is 15% of 240?"}],
    extra_body={"chat_template_kwargs": {"enable_thinking": False}}
)

On GLM 5.2, reasoning_effort has two effective levels, "high" and "max". It is passed at the top level (OpenAI-standard):

response = client.chat.completions.create(
    model="z-ai/glm-5.2",
    messages=[{"role": "user", "content": "Prove that the square root of 2 is irrational."}],
    reasoning_effort="high"
)

"high" gives shorter reasoning, "max" gives the deepest. "low" and "medium" are accepted but map to "high". To skip reasoning entirely, use reasoning_effort: "none" or enable_thinking: false. GLM 5.1 and GLM 5-Turbo support on/off but not effort levels.

DeepSeek V4 (Flash, Pro)

DeepSeek V4 models default to non-thinking mode. Enable reasoning with thinking: true inside chat_template_kwargs:

Moving from DeepSeek V4 to Qwen 3.8? The chat_template_kwargs: {"thinking": false} key shown here is accepted but ignored on Qwen 3.8. The request returns 200, reasoning still runs, and you are still billed for it. Qwen 3.8 cannot have reasoning disabled.

response = client.chat.completions.create(
    model="deepseek/deepseek-v4-pro-0813",
    messages=[{"role": "user", "content": "Prove that the square root of 2 is irrational."}],
    extra_body={"chat_template_kwargs": {"thinking": True}}
)

print(response.choices[0].message.reasoning_content)
print(response.choices[0].message.content)

Once thinking is on, control the depth with reasoning_effort, passed at the top level. There are two effective levels, "high" and "max":

response = client.chat.completions.create(
    model="deepseek/deepseek-v4-pro-0813",
    messages=[{"role": "user", "content": "Prove that the square root of 2 is irrational."}],
    extra_body={"chat_template_kwargs": {"thinking": True}},
    reasoning_effort="max"
)

"high" is the standard depth, "max" reasons the longest. "low" and "medium" are accepted but map to "high". reasoning_effort has no effect unless thinking: true is also set.

MiniMax M3

MiniMax M3 has three reasoning modes, set with thinking_mode inside chat_template_kwargs:

• "enabled": always reason.

• "adaptive": the model decides when to reason. This is the default.

• "disabled": no reasoning, direct answer.

# Reasoning off
response = client.chat.completions.create(
    model="minimax/minimax-m3",
    messages=[{"role": "user", "content": "What is 15% of 240?"}],
    extra_body={"chat_template_kwargs": {"thinking_mode": "disabled"}}
)

M3 uses thinking_mode, not thinking or enable_thinking, and the value is one of the three modes above. It does not take graded reasoning_effort levels, so use the modes to control reasoning.

Kimi K2.7 Code

Kimi models reason by default and cannot be toggled off. There is no enable_thinking or thinking flag to set. reasoning_content is always populated.

Qwen 3.8

Qwen 3.8 thinks on every request. Unlike the other families, reasoning cannot be switched off. The model rejects any attempt:

• chat_template_kwargs: {"enable_thinking": false} returns 400 Disabling thinking is not supported.

• reasoning_effort: "none" returns the same error.

Depth is controlled with the standard top-level reasoning_effort, but the accepted values differ from other models on the platform:

Value	Effect
"xhigh"	Default. Asks the model to validate assumptions and weigh alternatives. Most thorough, most output tokens
"medium"	No additional reasoning-depth steering
"low"	Asks the model to keep thinking brief and reach the conclusion directly

reasoning_effort: "high" returns a 400 on Qwen 3.8. Use "xhigh". "high" is the OpenAI-standard value and works on GLM 5.2, so ported code often sends it by default.

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.tensorx.ai/v1"
)

response = client.chat.completions.create(
    model="qwen/qwen3.8-2.4t-a95b",
    messages=[{"role": "user", "content": "A bat and ball cost 1.10 in total. The bat costs 1.00 more than the ball. How much is the ball?"}],
    reasoning_effort="low"
)

print(response.choices[0].message.reasoning_content)  # the thinking
print(response.choices[0].message.content)            # the answer
print(response.usage.reasoning_tokens)                # billed as output

Reasoning arrives in reasoning_content, with no <think> tags left in content. When streaming, reasoning arrives as delta.reasoning_content deltas before the content deltas begin.

Reasoning tokens are billed as output tokens. They are counted inside completion_tokens and reported separately as usage.reasoning_tokens.