DeepSeek V4.1 Flash 1017: Thinking Off Fixed 30/30 Small Coding Tasks

With thinking turned off, DeepSeek V4.1 Flash 1017 solved all 30 of our small edit-and-test coding tasks at $0.0042 per solved task, 36% less than at its default thinking level ($0.0066), and still solved 28 of 30 with the test-running tool taken away. Thinking off failed on a different kind of work: single-shot questions whose answer has to be computed in one reply, such as counting under constraints, where it got 11 of 39 right. Thinking is the model's hidden reasoning before it answers, billed as output tokens; reasoning_effort is the request parameter that sets how much of it to do (low, high by default, or max), and thinking: {"type": "disabled"} turns it off. We measured every setting two days after the October 17 release, at DeepSeek's peak list price of $0.30 per million input tokens and $1.20 per million output.

TL;DR

• DeepSeek V4.1 Flash 1017 costs $0.30/$1.20 per million tokens at peak, half off-peak; peak is 35 of 168 weekly hours.
• On small coding tasks run as an agent, DeepSeek V4.1 Flash 1017 solved 30 of 30 at every setting: $0.0042 each with thinking off, $0.0066 at default high, $0.0099 at max.
• On 13 single-shot reasoning tasks, thinking off scored 11 of 39 and every thinking level scored 39 of 39.
• DeepSeek V4.1 Flash 1017 retrieved a hidden fact from three depths of a 1,001,531-token prompt.

What changed on October 17, and what does 1017 cost?

DeepSeek V4.1 Flash 1017 replaced the September V4.1 Flash on DeepSeek's API at the same price. DeepSeek's release note claims "faster task completion, and shorter outputs than the previous version" and shows a chart of DeepSWE v1.1 (fixing issues in real code repositories) pass rate against cost per task; it credits "reinforcement learning with self-feedback" for better end-to-end project work. The weights are open, meaning you can download them from Hugging Face and serve the model yourself. For a deployment, the name, price, peak hours and tokenizer work like this:

• On DeepSeek's API, the model behind your model name changed. DeepSeek's id is deepseek-flash, and its pricing page says the legacy names deepseek-v4-flash and deepseek-v4-flash-vision-exp are now served by 1017. Code that calls DeepSeek directly and never changed a line is calling a new model, so rerun your evaluations. Synthorai kept its old model ids on the old builds, as the last section explains.
• The price did not change. Prices are in dollars per million tokens; a cache hit is input the server already saw in an earlier request, such as a repeated system prompt:

	Cache hit	Input (cache miss)	Output
Peak	$0.006	$0.30	$1.20
Off-peak	$0.003	$0.15	$0.60

• Off-peak is most of the week. Peak hours are 01:00 to 04:00 and 06:00 to 10:00 UTC on weekdays (09:00 to 12:00 and 14:00 to 18:00 Beijing time); weekends and Chinese public holidays are off-peak all day.
• The tokenizer did not change. The same English, Chinese, Python and JSON samples counted to identical token totals on 1017, the September V4.1 Flash and V4 Pro, so token budgets carry over.

On the Artificial Analysis leaderboard (read October 19), an index of agent, coding, knowledge and science benchmarks that Artificial Analysis runs itself, 1017 at its highest setting scores 45.1, against 39.5 for the September build. DeepSeek also opened Search and Fetch APIs on its own platform, which return web results for a query and the contents of a URL, at $0.75 per 1,000 calls each; calls from Claude Code, Codex and DeepSeek Harness made with a DeepSeek API key are free until October 31, 2026 at 16:00 UTC. Those terms apply to DeepSeek's API only, and we tested neither the APIs nor the large-project claims. The rest of this post measures 1017 alone, by thinking setting.

Which thinking level should you use for single-shot reasoning?

low is enough on our tasks, and turning thinking off is not. 1017 ran our standard 13-task set (counting under constraints, a rule applied 200 times, a knapsack packing, modular arithmetic and similar problems with one checkable answer), three runs per task and setting, one request per run. Cost per correct answer is total spend divided by correct answers, at peak list price:

Setting	Correct (8 easier tasks)	Correct (5 hard tasks)	Output tokens, all 39 runs	Cost per correct answer
Thinking off	10/24	1/15	24,896	$0.0028
low	24/24	15/15	59,752	$0.0019
high (default)	24/24	15/15	90,488	$0.0028
max	24/24	15/15	117,241	$0.0036

Thinking off got 28 of 39 wrong, and 17 of those wrong answers were a bare number of five tokens or fewer, with no working shown. Every thinking level got every answer right, so the levels differed only in how much they wrote.

max wrote more than low on 12 of the 13 tasks and 1.96x the output tokens in total. We checked this with a sign test, which counts on how many tasks one setting wrote more, and a Holm correction, which adjusts for running five such comparisons at once; the gap holds (p = 0.002). high wrote 1.51x low's tokens and was longer on 11 of 13 tasks, but after the correction that is a direction, not a proven gap (p = 0.09). Sending no reasoning_effort at all, which DeepSeek documents as the same high, came out 14% below the explicit high run, which gives a sense of how much two identical runs can differ.

The two controls, and where the measured numbers sit in the response:

import os
from openai import OpenAI

client = OpenAI(base_url="https://synthorai.io/v1", api_key=os.environ["SYNTHORAI_API_KEY"])
prompt = "How many positive integers below 1000 are divisible by 3 or 5 but not by 15?"
resp = client.chat.completions.create(
    model="deepseek-v4.1-flash-1017",
    messages=[{"role": "user", "content": prompt}],
    reasoning_effort="low",                          # "low" | "high" (default) | "max"
    # extra_body={"thinking": {"type": "disabled"}}, # thinking off instead
)
u = resp.usage
reasoning = u.completion_tokens_details.reasoning_tokens  # billed as output
cache_hits = u.prompt_tokens_details.cached_tokens         # billed at 2% of the input price
thinking_text = resp.choices[0].message.reasoning_content

Do coding agent loops need thinking?

Our coding tasks did not need it, but they are simple ones: every setting solved 30 of 30, and thinking off and low were the cheapest. An agent loop here means the model works in turns, calling tools and reading their results, until it decides the task is done. 1017 got a small Python package and three tasks built around bugs we planted (fix an amount-parsing bug; add two new input formats; fix an overdraft check and a monthly report) and four tools: list files, read a file, write a file, and run the visible tests. A run counted as solved only if hidden tests, never shown to the model, passed on the files it left behind. Each task ran 10 times per setting, up to 30 turns, with the model's code executed in an isolated sandbox. Turns, output tokens and seconds are medians per run; cost per solved task is total spend divided by tasks solved, at peak list price:

Setting	Solved	Median turns	Median output tokens	Median seconds	Cost per solved task
Thinking off	30/30	9.5	2,213	25.5	$0.0042
low	30/30	8	2,398	24.7	$0.0044
high (default)	30/30	9	3,654	33.1	$0.0066
max	30/30	9	6,184	44.5	$0.0099
Thinking off, no test tool	28/30	6	1,680	16.4	$0.0034
low, no test tool	30/30	6	1,778	17.1	$0.0035

The number of turns barely changed with the level. What grew was reasoning per turn, from none with thinking off to 72% of output at max. We compared the 10 runs of each task with a Mann-Whitney test, which checks whether one setting's costs sit consistently above the other's, and Holm-corrected across 12 such comparisons. high cost more than low on all three tasks, by 1.24x to 1.70x, and max cost more than high on two of the three. Thinking off and low could not be told apart.

The last two rows are a control: the same tasks with the run-tests tool removed, so the model had no feedback before grading. Thinking off still solved 28 of 30, which is not a significant drop (Fisher's exact test, which compares two success counts, p = 0.49), so test feedback was not necessary for thinking off to succeed here. The tasks that broke thinking off in the single-shot set needed many steps of arithmetic or search done in one reply; these coding tasks needed reading and editing a few files, which 1017 handled without thinking.

The tasks are deliberately small: a few files, bugs you can find by reading the code, and fewer than 30 turns. Harder agent work, such as features that span many files, long debugging sessions or an unfamiliar codebase, may well need a higher level, and DeepSeek's own pitch for 1017 is about exactly that kind of project work. We did not test it. A reasonable default is to start at thinking off or low for simple tool tasks and move to high when the task is complex or when you see runs fail.

When thinking is on and the request includes tools, DeepSeek's thinking-mode guide requires the reasoning_content of every earlier assistant turn to be sent back, and documents a 400 error otherwise:

msg = resp.choices[0].message
messages.append({
    "role": "assistant",
    "content": msg.content or "",
    "tool_calls": msg.tool_calls,
    "reasoning_content": msg.reasoning_content,  # required with tools in thinking mode
})

How much do caching and off-peak hours save?

In our agent runs, caching cut the bill by more than half, and off-peak hours halve whatever is left. Every turn of an agent loop resends the whole conversation, so input was 90% of the tokens across the 120 runs with the test tool, and 82% of that input was billed as cache hits at 2% of the input price. At peak list price the 120 runs cost $0.75; with no cache discount the same tokens would have cost $1.66. After caching, output was 71% of the bill and uncached input 27%, so the thinking level is the largest remaining lever on what a 1017 agent costs. Run off-peak, the same tokens would cost $0.38.

Caching is automatic on DeepSeek's API: there is no cache-write fee and nothing to mark. In our check, a 6,069-token prompt sent twice billed 6,016 tokens as hits on the second request, so keep the start of the prompt stable (system prompt and tool definitions first, anything that changes per request last).

Is the 1M context window real?

The full window is usable for retrieval. We hid one sentence holding a seven-digit code in filler text of varied sentences and asked for the code, with thinking off, at three depths into the prompt:

Prompt size (tokens)	10% depth	50% depth	90% depth	Seconds	Cost per request, peak
128,292	not run	found	not run	4.7	$0.04
256,351 to 256,538	found	found	found	7 to 8	$0.08
512,795 to 513,058	found	found	found	12	$0.15
1,001,357 to 1,001,531	found	found	found	25 to 26	$0.30

A 1.15-million-token request failed with HTTP 400 and an error naming a limit of 1,048,568 tokens, so an oversized request fails before it starts and is never truncated quietly. This is retrieval of one stated fact; reasoning across many facts spread through a long prompt is a harder test we did not run.

Which setting fits which workload?

Workload	Setting	Measured basis
Simple coding agent tasks (a few files)	Thinking off or low	30/30 solved at $0.0042 to $0.0044 per task; high costs 1.24x to 1.70x more per task
Complex agent work (many files, long debugging)	Start at high	Not measured here; our simple tasks are the only agent evidence
Single-shot math, planning, counting	low	39/39 at $0.0019 per correct answer; thinking off 11/39
Retrieval from long documents	Thinking off	Hidden fact found at every depth up to 1,001,531 tokens; $0.30 per full window at peak
Batch or overnight jobs	Any, scheduled off-peak	Half price outside 35 peak hours a week
max	Only where you measured high failing	No task in either suite needed it

No thinking setting replaces a test suite or validator the agent can run: without the test tool, thinking off still solved 28 of 30, but nothing caught the other two before grading. Plan a regression run after October 17 as well if you call deepseek-v4-flash or deepseek-flash on DeepSeek's API, since the model behind those names changed.

How Synthorai handles it

On Synthorai, 1017 has its own model id, deepseek-v4.1-flash-1017. To keep existing integrations behaving the same, we did not repoint the older ids the way DeepSeek did on its API: deepseek-v4.1-flash is still the September V4.1 Flash, and you move to 1017 by changing the model id. It is listed at $0.30 input, $1.20 output and $0.006 cache read per million tokens, DeepSeek's list price, on /v1/chat/completions. reasoning_effort and thinking: {"type": "disabled"} pass through, reasoning_content comes back on thinking calls, and cache hits are reported in usage.prompt_tokens_details.cached_tokens. Every cost in this post is at DeepSeek's peak list price so you can apply your own hours.

FAQ

Is DeepSeek V4.1 Flash 1017 a different model from deepseek-v4-flash?

On DeepSeek's API it is now the model behind that name: DeepSeek's pricing page says the legacy ids deepseek-v4-flash and deepseek-v4-flash-vision-exp are served by DeepSeek V4.1 Flash 1017 and billed at the Flash price, and deepseek-flash points to it too. The September V4.1 Flash is no longer on DeepSeek's API, though third-party hosts still serve its open weights. On Synthorai the old ids stay on the old builds and 1017 is deepseek-v4.1-flash-1017.

Should you turn thinking off on DeepSeek V4.1 Flash 1017?

Turn it off for simple coding and tool-use tasks: in our agent loop 1017 solved 30 of 30 small coding tasks with thinking off at $0.0042 each, and 28 of 30 even without a test tool. Keep it on, at low, for single-shot questions that need several steps of arithmetic or planning, where thinking off scored 11 of 39 against 39 of 39 at low, and consider high for complex agent work, which we did not test.

Does DeepSeek V4.1 Flash 1017 really have a 1M-token context window?

Yes: 1017 retrieved a hidden fact at 10%, 50% and 90% depth of a 1,001,531-token prompt, in about 25 seconds and $0.30 per request at peak list price, and a request past 1,048,568 tokens returned HTTP 400.

Related: DeepSeek V4.1 Flash cost, DeepSeek V4 Pro GA vs preview, LLM thinking controls, prompt cache write cost, long-context pricing tiers.

Measured October 19, 2026 through the Synthorai gateway, model id deepseek-v4.1-flash-1017: 195 single-shot calls (13 tasks, five settings, three runs), 180 agent runs (three tasks, six settings including the two without a test tool, 10 runs) and 11 long-context requests. Costs at DeepSeek's peak list price; Artificial Analysis figures read October 19, 2026.