DeepSeek V3.1: One Model With Thinking and Non-Thinking Modes

Before August 2025, using DeepSeek meant choosing between two models: V3 for fast chat and R1 for slow, deliberate reasoning. They had different weights, different behaviour and different failure modes. DeepSeek V3.1, released on 21 August 2025, replaced that choice with one model that runs in either mode.

The merge is convenient, but it comes with a split that shapes how you build agents on it: the general tool-call format is documented for non-thinking mode, while thinking mode gets a separate format reserved for search. Understanding that split explains most of the design decisions below.

How the switch actually works

V3.1 keeps the V3 architecture: 671B total parameters, 37B active, a 128K-token context window. What changes is the chat template. The same weights produce reasoning or a direct answer depending on how the assistant turn begins.

• Thinking mode starts the assistant turn with <｜Assistant｜><think>, much like R1.
• Non-thinking mode starts it with <｜Assistant｜></think>, closing the reasoning block before it opens. That closing token is new compared with V3.

With Hugging Face Transformers you pass thinking=True or thinking=False to apply_chat_template. In multi-turn thinking conversations, the reasoning from earlier turns is dropped from the context while the closing tag is kept, so you are not paying to resend old reasoning.

On DeepSeek's own API at launch, the mode was chosen by model name: deepseek-chat was V3.1 non-thinking and deepseek-reasoner was V3.1 thinking. Aggregators generally expose it as a reasoning toggle instead, so check the provider's documentation for the exact parameter. The catalogue lists the model at deepseek/deepseek-chat-v3.1 with reasoning mode and tool calling both available.

General tool calls belong to non-thinking mode

DeepSeek's model card is explicit: tool calling is supported in non-thinking mode, and it points code-agent builders to that same format. The one exception is search. The card defines a specific search tool-call format for thinking mode, so the model can call a user-provided search tool over several turns while it reasons. Outside search, do not plan on the model reasoning at length and emitting an arbitrary function call in the same turn.

For agents, that leaves three workable patterns:

1. Non-thinking throughout. The simplest option, and the one DeepSeek's code-agent benchmarks were run in. Most coding agents should start here.
2. Plan, then act. One thinking-mode call produces a plan with no tools; the loop then executes it in non-thinking mode. Useful when the hard part is deciding what to do, not doing it.
3. Escalate on failure. Run non-thinking by default, and when a step fails repeatedly, make one thinking-mode call to diagnose before returning to the tool loop.

DeepSeek also added strict function calling in its beta API at launch, which constrains arguments to your schema. Agent planning strategies covers the plan-then-execute pattern in more depth.

Two modes, two score profiles

DeepSeek's comparison table shows the modes are good at different things:

• SWE-bench Verified (agent mode) — 66.0 non-thinking, against 45.4 for V3 0324 and 44.6 for R1 0528
• Terminal-bench (Terminus 1) — 31.3 non-thinking, against 13.3 for V3 0324
• BrowseComp — 30.0 thinking, against 8.9 for R1 0528
• GPQA-Diamond — 74.9 non-thinking, 80.1 thinking (R1 0528: 81.0)
• LiveCodeBench — 56.4 non-thinking, 74.8 thinking (R1 0528: 73.3)
• AIME 2024 — 66.3 non-thinking, 93.1 thinking (R1 0528: 91.4)

Two readings follow. First, the code-agent gains came from non-thinking mode, and the card reports no thinking-mode score on SWE-bench or Terminal-bench, so turning thinking on is not how you make a coding agent better. Thinking mode's agent result is BrowseComp, which runs through the search format. Second, thinking mode roughly matches R1 0528 on reasoning tasks, and DeepSeek says it gets there faster. If you were running R1 for maths or competitive programming, V3.1 thinking is the like-for-like replacement.

What changed under the hood

The base model received 840B tokens of continued pre-training on top of V3 to extend long-context ability. DeepSeek scaled the 32K-context phase tenfold to 630B tokens and the 128K phase 3.3 times to 209B tokens. That is a substantial investment in actually using the window rather than merely advertising it.

V3.1 was also trained with the UE8M0 FP8 scale format on weights and activations, for compatibility with microscaling formats. If you self-host, check that your inference stack supports the checkpoint's FP8 format before assuming it will load and run at full speed.

What thinking costs

V3.1 is listed on OpenRouter at $0.25 per million input tokens and $0.95 per million output tokens at the time of writing, with cache reads at $0.13. Thinking mode spends output tokens on reasoning before the answer, and output is the expensive side of that price. A thinking-mode call can easily produce several times the output of the same request in non-thinking mode.

That is the case for defaulting to non-thinking and turning thinking on only where you have measured a gain. The token cost of reasoning models works through the arithmetic.

V3.1 or its Terminus update

A month after launch, DeepSeek shipped V3.1 Terminus, which keeps the same architecture and modes but reduces mixed Chinese-English output and raises the agent scores, including SWE-bench Verified from 66.0 to 68.4. For new work, Terminus is usually the better default.

Stay on the original V3.1 if you have pinned it for reproducibility, or if your workload is one of the few where Terminus scored lower, such as Chinese-language browsing. If you are coming from V3 0324, the jump in agent benchmarks is large enough that the upgrade is worth testing straight away.