# How to Use the reasoning_effort Parameter to Control Thinking Levels in GLM-5.2

> Control GLM-5.2 thinking levels with reasoning_effort. Set high for deep analysis, omit for max mode, or disable chain-of-thought for faster responses and lower latency.

- Repository: [Z.ai/GLM-5](https://github.com/zai-org/GLM-5)
- Tags: how-to-guide
- Published: 2026-06-21

---

**Set `reasoning_effort="high"` to enable deep, thorough reasoning on complex queries, omit the field entirely for default `max` mode (faster, lower latency), or pass `enable_thinking=false` to disable internal chain-of-thought completely.**

The GLM-5.2 model (also referred to as GLM-S.2) in the `zai-org/GLM-5` repository exposes a `reasoning_effort` parameter that acts as a thinking budget controller. This API field allows you to trade latency for reasoning depth, making it straightforward to optimize the model's behavior for everything from quick completions to multi-step mathematical proofs. According to the repository's documentation in [`README.md`](https://github.com/zai-org/GLM-5/blob/main/README.md) (lines 81–82), the parameter supports three distinct operational modes.

## Understanding the reasoning_effort Values

The `reasoning_effort` field accepts string values that map directly to internal compute budgets. When you send a request to the chat completions endpoint, the model checks this field to determine how much chain-of-thought processing to apply before generating a response.

### Default Mode (`max`)

When you omit the `reasoning_effort` field from your payload, or set it to `"max"`, the model operates in its default fast-reasoning mode. This configuration provides normal-level reasoning with reduced latency, making it ideal for benchmark reproduction, simple Q&A, or high-throughput applications. The `max` value represents the standard thinking budget and is automatically applied when the parameter is missing.

### High-Effort Mode (`high`)

Passing `reasoning_effort="high"` instructs the model to allocate significantly more compute to internal reasoning steps. This mode produces deeper, more thorough analysis but introduces higher latency and increased token consumption. Use this setting for complex mathematical proofs, intricate logic puzzles, or tasks requiring multi-step deduction.

### Disabling Chain-of-Thought (`enable_thinking`)

To completely suppress the model's internal reasoning stream, add `"enable_thinking": false` to your request payload. This flag overrides the `reasoning_effort` budget and treats the model as a standard completion engine, removing all chain-of-thought-style processing. This is useful for pure token-generation tasks where intermediate reasoning steps are unnecessary.

## Code Examples

Below are production-ready implementations using Python with the `requests` library and standard `cURL` commands. All examples target the `https://api.z.ai/v1/chat/completions` endpoint using the `glm-s-2` model identifier.

### Default (Fast) Mode

Omitting `reasoning_effort` yields the fastest response times:

```python
import requests
import json

payload = {
    "model": "glm-s-2",
    "messages": [{"role": "user", "content": "Explain the difference between recursion and iteration."}]
    # No reasoning_effort field → defaults to max

}

response = requests.post(
    "https://api.z.ai/v1/chat/completions",
    headers={
        "Authorization": f"Bearer {YOUR_API_KEY}",
        "Content-Type": "application/json"
    },
    data=json.dumps(payload)
)

print(response.json())

```

### High-Effort Reasoning

Explicitly set the parameter for complex problem-solving:

```python
payload = {
    "model": "glm-s-2",
    "messages": [{"role": "user", "content": "Explain quantum entanglement in simple terms."}],
    "reasoning_effort": "high"
}

response = requests.post(
    "https://api.z.ai/v1/chat/completions",
    headers={
        "Authorization": f"Bearer {YOUR_API_KEY}",
        "Content-Type": "application/json"
    },
    data=json.dumps(payload)
)

```

### Disable Thinking Completely

Suppress all internal reasoning with the boolean flag:

```python
payload = {
    "model": "glm-s-2",
    "messages": [{"role": "user", "content": "Generate a list of 5 random numbers."}],
    "reasoning_effort": "max",
    "enable_thinking": False
}

response = requests.post(
    "https://api.z.ai/v1/chat/completions",
    headers={
        "Authorization": f"Bearer {YOUR_API_KEY}",
        "Content-Type": "application/json"
    },
    data=json.dumps(payload)
)

```

### cURL Equivalents

For shell-based integrations:

```bash

# Default (max) mode

curl -X POST https://api.z.ai/v1/chat/completions \
  -H "Authorization: Bearer $ZHIPU_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
        "model": "glm-s-2",
        "messages": [{"role":"user","content":"What is the capital of France?"}]
      }'

# High-effort reasoning

curl -X POST https://api.z.ai/v1/chat/completions \
  -H "Authorization: Bearer $ZHIPU_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
        "model": "glm-s-2",
        "messages": [{"role":"user","content":"Explain quantum entanglement in simple terms."}],
        "reasoning_effort": "high"
      }'

# Disable thinking

curl -X POST https://api.z.ai/v1/chat/completions \
  -H "Authorization: Bearer $ZHIPU_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
        "model": "glm-s-2",
        "messages": [{"role":"user","content":"Generate a list of 5 random numbers."}],
        "reasoning_effort": "max",
        "enable_thinking": false
      }'

```

## Source Code Reference

The behavior documented above is hardcoded in the repository's configuration documentation:

- **[`README.md`](https://github.com/zai-org/GLM-5/blob/main/README.md)** (lines 81–82): Contains the official description of the `reasoning_effort` and `enable_thinking` flags, explicitly stating that `max` is the default and `high` requires explicit configuration.
- **[`README_zh.md`](https://github.com/zai-org/GLM-5/blob/main/README_zh.md)** (line 81): Provides the Chinese-language equivalent of the same guidance for bilingual implementations.
- **[`example/ascend.md`](https://github.com/zai-org/GLM-5/blob/main/example/ascend.md)**: Demonstrates hardware-specific deployment contexts where you might combine `reasoning_effort` settings with specialized Ascend NPU configurations.

## Summary

- **Omit `reasoning_effort`** to run GLM-5.2 in default `max` mode for fast, low-latency responses.
- **Set `reasoning_effort="high"`** when you need deep, thorough reasoning on complex tasks, accepting the trade-off of higher latency.
- **Use `enable_thinking=false`** to completely disable chain-of-thought processing, treating the model as a standard completion engine.
- All GLM-5 family models share this API contract, allowing consistent reasoning control across the model ecosystem.

## Frequently Asked Questions

### What is the default value for reasoning_effort in GLM-5.2?

The default value is `max`. When you omit the `reasoning_effort` field from your request payload entirely, or pass any value other than `high`, the model automatically defaults to `max` mode. This provides normal-level reasoning with optimized latency, as documented in [`README.md`](https://github.com/zai-org/GLM-5/blob/main/README.md) lines 81–82.

### Does setting reasoning_effort to high increase token usage?

Yes. The `high` setting instructs the model to perform more thorough internal reasoning before generating a response, which typically consumes additional tokens and increases latency. While the output quality improves for complex tasks, you should expect higher compute costs and slower response times compared to the default `max` mode.

### Can I disable chain-of-thought reasoning while keeping reasoning_effort set to max?

Yes. You can combine `"reasoning_effort": "max"` with `"enable_thinking": false` in the same payload. The `enable_thinking` boolean acts as an override that suppresses all internal reasoning steps, regardless of the budget allocated by `reasoning_effort`. This configuration is useful when you want fast completions without any intermediate processing steps.

### Is the reasoning_effort parameter available in all GLM-5 family models?

Yes. According to the source analysis, GLM-S.2 follows the same API contract as the other GLM-5 family models. The `reasoning_effort` parameter is a standardized field across the model family, meaning you can use identical request payloads when switching between different GLM-5 variants, including when deploying on specialized hardware as shown in [`example/ascend.md`](https://github.com/zai-org/GLM-5/blob/main/example/ascend.md).