DeepSeek V4.1 Flash 1017 Tested: Intelligence Rises to 45, Cost per Task Drops 47%

DeepSeek quietly swapped out its model: as of October 17, 2026, requests calling deepseek-flash are actually being handled by DeepSeek-V4.1-Flash-1017. At launch, the only benchmark table came from DeepSeek itself, and The Decoder noted that same day that no independent results existed yet. Now third-party evaluator Artificial Analysis has filled that gap, and the numbers it reports are more convincing than the official claims.

Third-Party Evaluation: Scores Up, Costs Down Even More

Artificial Analysis's Intelligence Index shows the reasoning version of V4.1 Flash 1017 scoring 45, up from 39 for the previous-generation V4.1 Flash on the same index. The index uses version v4.3.2 and bundles 10 evaluations, including Terminal-Bench 4.0, SciCode, Humanity's Last Exam, and AA-LCR; both models were tested at the "Max" reasoning level.

Beyond the score, the change in the cost row is more noteworthy. Cost per task dropped from $0.49 to $0.26, a reduction of about 47%; the output tokens needed to run the full index fell from 250 million to 210 million, a decrease of about 16%. Meanwhile, the price per million input/output tokens is unchanged at $0.30 / $1.20. In other words, what got cheaper isn't the unit price — it's the way the model answers questions.

Among 121 models, 1017 ranks 2nd. The page FAQ says its score is "far above the average for open-weights models of the same size (median 19)." The license is MIT, and the context window is 1 million tokens.

The Intelligence Index is a composite benchmark maintained by Artificial Analysis, not a single test. It weights and aggregates percentile scores from multiple capability evaluations into a single index value, covering dimensions such as code generation (e.g., Terminal-Bench 4.0, SciCode), long-context reasoning (AA-LCR), and general knowledge Q&A (Humanity's Last Exam). Because different versions of the index may adjust the question set or weights, scores across versions are not directly comparable; the article specifically notes that v4.3.2 was used precisely to emphasize that 45 and 39 were measured on the same ruler. The index also distinguishes reasoning levels and requires tested models to run at the same effort setting, otherwise comparisons would be distorted.

Where Does the 47% Cost Drop Come From

Prices didn't move, yet costs fell — the answer lies in token usage. Artificial Analysis didn't break down cost per task into input, cached input, and output, so it's impossible to determine precisely how much of the 47% comes from shorter outputs. In the release notes, DeepSeek^Ad promised "shorter outputs than the previous version," and total output tokens did indeed drop 16%, but the remaining reduction may come from cache hit rates or other factors.

Even after getting shorter, 1017 is still "chatty." The evaluation page says 210 million output tokens is "very verbose relative to the 140 million median." Low unit prices and long answers offset each other, so to judge cost, look at the cost-per-task row, not the price per million tokens.

Cached input (prompt caching) is a separate price tier in API billing. When multiple requests share the same prefix (such as system prompts, long documents, or codebase context), the server caches those tokens, and subsequent requests that hit the cache are billed at a price far below normal input. DeepSeek's peak-time cache-hit price is $0.006 per million, just 2% of the $0.30 miss price. Artificial Analysis's benchmark table doesn't separate cached from uncached input, so part of the 47% cost reduction may come from changes in cache hit rates rather than shorter outputs; to attribute precisely, you'd need to price prompt_cache_hit_tokens and prompt_cache_miss_tokens separately using the API response.

Two Preconditions Behind the $0.26

This number rests on two assumptions, and your actual traffic may not match them.

First, the price tier. Artificial Analysis calculates using $0.30 per million input tokens and $1.20 per million output tokens, which is the peak-time price for deepseek-flash. DeepSeek's pricing page shows off-peak prices are halved: $0.15 input, $0.60 output, and cached input drops from $0.006 to $0.003. Peak hours are 01:00–04:00 and 06:00–10:00 UTC, Monday through Friday, with Chinese public holidays billed at off-peak rates. A batch job running from 10:00 UTC on a weekday to 01:00 the next day, or all weekend, pays only half of what the benchmark table shows.

Second, the reasoning level. The test was at Max. DeepSeek's thinking-mode guide states that thinking is on by default, "the default effort is high," and the selectable values are low, high, and max. If you never set reasoning_effort, you're not running the configuration that scored 45 — and you're probably not paying its token bill either. In a Hacker News discussion, a user who tested an earlier Flash version (not 1017) said max "used way more tokens (roughly twice as many, from memory) with almost no gain over high." That's just one person's impression on an older model, not a measurement.

Calculate Your Own Cost per Task Using Your Traffic

You don't need a leaderboard to calculate your own cost per task. DeepSeek's chat completion API returns prompt_cache_hit_tokens, prompt_cache_miss_tokens, and completion_tokens in the usage object of each response. Sum the calls belonging to the same task, then apply the rate for the time period in which the request occurred:

// deepseek-flash, USD per 1M tokens (DeepSeek pricing page)
const PRICES = {
  peak: { hit: 0.006, miss: 0.3, out: 1.2 },
  offPeak: { hit: 0.003, miss: 0.15, out: 0.6 },
};

type Usage = {
  prompt_cache_hit_tokens: number;
  prompt_cache_miss_tokens: number;
  completion_tokens: number;
};

// Peak: 01:00-04:00 and 06:00-10:00 UTC, Monday-Friday.
// Chinese public holidays are off-peak; not handled here.
function isPeak(at: Date): boolean {
  const day = at.getUTCDay(); // 0 = Sunday, 6 = Saturday
  if (day === 0 || day === 6) return false;
  const h = at.getUTCHours();
  return (h >= 1 && h < 4) || (h >= 6 && h < 10);
}

export function costUSD(u: Usage, at: Date): number {
  const p = isPeak(at) ? PRICES.peak : PRICES.offPeak;
  const scaled =
    u.prompt_cache_hit_tokens * p.hit +
    u.prompt_cache_miss_tokens * p.miss +
    u.completion_tokens * p.out;
  return scaled / 1_000_000;
}

Accumulate costUSD per task and record it alongside whether the task passed. Run your evaluation set at both the high and max levels; the number that really matters is: how much does a passing task cost at each level?

Run It Against the Same Ticket as Your Current Model

Index scores describe how a model performs on Artificial Analysis's tasks; your codebase is a different set of tasks. DeepSeek's documentation explains how to point Claude Code at its API via the Anthropic-format endpoint https://api.deepseek.com/anthropic, so you can hand the same ticket to both your existing setup and a setup running on 1017. That guide sets CLAUDE_CODE_EFFORT_LEVEL to max — the expensive level mentioned earlier; if you want to compare levels, run it again at high.

If you want both sessions running on the same repository simultaneously without polluting each other's files, you can use the worktree mechanism. Take Hermes IDE as an example: each task starts in a separate hermes/<name> branch and a separate worktree, so two sessions can run side by side in a split view. It should be noted that the author of this article is a developer of Hermes IDE, which should be factored into your judgment. Hermes displays the cost reported by the agent, or a cost estimated from session records (marked as an estimate) along with total tokens; for models it doesn't have built-in pricing for, you can manually calculate against the token totals using DeepSeek's price list. The author has not personally tested 1017 in Hermes.

Worktree is a built-in Git mechanism: git worktree add allows multiple branches to be checked out simultaneously into different directories on the same repository. Each directory has its own working tree and index but shares the object database. Compared to copying the repository or switching with stash, worktrees let two agent sessions modify the same codebase in parallel without overwriting each other's files, and without cloning. When evaluating a model, you can have two sessions each work on the same ticket in separate worktrees, then compare patch quality and token cost; when merging, handle conflicts through the normal branch workflow.

Your deepseek-flash Calls Have Already Changed

This replacement requires no action on your part. The old names deepseek-v4-flash and deepseek-v4-flash-vision-exp are still usable, but DeepSeek's pricing page states that their corresponding models have been retired; requests are routed to 1017 and billed at Flash prices. If you want a version that won't be silently swapped, the MIT-licensed weight files are one path to a fixed version.

Whether 1017 is cheaper for you depends on when you call it and at what reasoning level. Have you explicitly set reasoning_effort, or have you been using the default all along? This may be the most easily overlooked variable in your cost bill.

Background

Reasoning effort controls the token budget the model spends on internal thinking before giving its final answer. DeepSeek sets the selectable values to low, high, and max: the higher the level, the more tokens the model consumes during the chain-of-thought phase, typically yielding higher quality but a larger output-token bill. Because thinking is on by default and the default level is high, a large number of calls that never explicitly set reasoning_effort actually run at high rather than the max used in the benchmark table — so they neither get the quality corresponding to a score of 45 nor pay the token cost of max. When evaluating, fix the level before comparing; otherwise neither scores nor costs are comparable.