DeepSeek V4 Pro Reasoning Effort: low, high & max Explained

Reasoning effort controls how deeply the model thinks before answering. DeepSeek introduced three explicit levels — `low`, `high`, and `max` — with the August 13 GA release, for both V4 Pro and V4 Flash^[1][4].

The official announcement frames it as: low for simple tasks, high for daily agent workflows, max for complex tasks^[1]. The model card and Codex integration metadata confirm the same three levels, with `high` as the default reasoning level in Codex's models.json^[4][5].

Before GA, effort behavior was fixed and undocumented per build; the 0813 release made it an explicit, per-request control.

• Three levels: low / high / max
• Default: high
• Available for V4 Pro and V4 Flash (GA builds)
• Sets how much chain-of-thought the model spends before answering

Each level trades depth against latency and cost^[1][4].

The practical difference shows up in two places: latency (max can add many seconds of reasoning before the first output token) and bill (reasoning tokens are billed at output rates, so a max call can cost several times a low call for the same answer quality).

Independent testing of the GA build noted the model 'over-thinks simple problems' at default settings — a strong argument for dropping simple traffic to `low`^[6].

The parameter is `reasoning_effort`, passed per request. It works in both OpenAI-format and Anthropic-format calls^[3][5].

• OpenAI format: reasoning_effort="low" | "high" | "max"
• Anthropic format: reasoning block with effort set to none | low | high | max
• Default when omitted: high
• Codex: the setup script writes reasoning_levels into models.json; default_reasoning_level = high

from openai import OpenAI

client = OpenAI(api_key="<key>", base_url="https://api.deepseek.com")

# Simple chat — keep it cheap
client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[{"role": "user", "content": "Summarize this changelog."}],
    reasoning_effort="low",
)

# Hard agent task — max depth
client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[{"role": "user", "content": "Design and implement the parser."}],
    reasoning_effort="max",
    extra_body={"thinking": {"type": "enabled"}},
)

The cost difference between levels is the hidden variable in every V4 Pro budget. Reasoning tokens are billed at the output rate, so a max-effort call that thinks 5,000 tokens before answering pays 5,000 output tokens of thinking on top of the answer^[2][3].

Latency follows the same curve: a `max` call on a hard problem can run tens of seconds before the first token, while `low` returns almost immediately. For interactive products, effort choice is a UX decision as much as a cost decision.

The context caching guide shows how a stable prefix reduces the input side of the bill; effort control is the lever on the output side.

# Rough math, off-peak output rate $1.98 / 1M tokens
think_5k = 5000 * 1.98 / 1_000_000   # ≈ $0.0099 of thinking
answer_1k = 1000 * 1.98 / 1_000_000  # ≈ $0.002 of answer

# A max-effort call can spend ~5x the answer's cost just thinking.
# On peak hours the same reasoning doubles again.

A practical decision rule that keeps both quality and the bill in check^[1][6].

DeepSeek's own framing — low for simple tasks, high for daily agents, max for complex tasks — is a good starting point. Independent testing adds one refinement: the GA build's tendency to over-think means most 'simple' production traffic should be explicitly pinned to `low` rather than left at the default^[6].

For team-wide configuration, the Codex setup (Responses API guide) lets you set the default reasoning level once and override per request.

• low: Q&A, summaries, extraction, classification, code formatting — anything a fast model can do
• high: default for agent loops, tool calls, code review, multi-turn work
• max: competitive programming, theorem-level math, tricky debugging, one-shot hard problems
• Route by task type, not by model — the same key can mix levels per request
• If you see latency complaints from users, the first fix is usually dropping simple traffic to low, not changing models