DeepSeek V4.1 Flash 1017 Hands-On: Token Efficiency Fixes Its Biggest Weakness

Title

DeepSeek V4.1 Flash 1017 Hands-On: Token Efficiency Fixes Its Biggest Weakness

Meta Description

DeepSeek^Ad V4.1 Flash 1017 tested: Terminal Bench rises from 31 to 42, reasoning tokens cut by about one-third, and coding task cost drops from 50 cents to 20 cents at the same unit price. Full tests of long-horizon agent tasks, 3D rendering, vision, and frontend capabilities, plus advice on choosing reasoning levels.

Article Content

DeepSeek has released the 1017 version of V4.1 Flash. Officially it is a "small update," but the benchmarks and weekend hands-on tests send a much stronger signal. The most notable thing is not how much the scores rose, but that it consumes noticeably fewer tokens to complete tasks—exactly the long-standing criticism of the DeepSeek Flash series.

From "cheap per token" to "cheap per task"

The number on a model's pricing page is the price per token, but actual spending is the unit price multiplied by the total number of tokens the model generates to complete the task. A model that is half the price but thinks three times as much can end up with a bigger bill. That was exactly the problem with DeepSeek Flash before: low rates, but high token consumption.

According to artificial analysis's test of V4 Flash last April, it was one of the most token-hungry models they had tested at the time; the September V4.1 Flash was even more verbose, consuming nearly twice as many tokens on the same benchmark as open-source models of similar scale. The low price was quietly eaten away by "thinking too much."

The key change in the 1017 version is here: DeepSeek's own chart shows that at the same unit price, the cost of coding tasks at the max level drops from about 50 cents to about 20 cents. That kind of drop is only possible when generated tokens fall substantially.

Why token consumption becomes the key to cost-effectiveness

LLM APIs usually price input and output tokens separately, and reasoning models also produce a large number of invisible "thinking tokens" before generating the final answer, which are billed as well. For tasks requiring multi-step reasoning or long-horizon work, thinking tokens can be several times the visible output, so "cheap per token" does not equal "cheap per task." The industry commonly uses "cost per task" to measure real expense, that is, the total cost of completing a standard task (such as a coding problem or webpage generation). The DeepSeek Flash series previously suffered from excessive thinking that drove up token consumption and weakened its low-price advantage; the 1017 version significantly lowers the total cost of the same tasks by reducing redundant thinking tokens, and this is the core mechanism behind its improved cost-effectiveness.

Benchmarks and real tests: more than paper numbers

The model scale is exactly the same as the September version, but the weights are clearly different. DeepSeek says further training improved all benchmarks, with Terminal Bench rising from 31 to 42—quite substantial for a version billed as a "small update." According to its own data, it can now compete with GPT 5.6 Sol (not OpenAI's latest model), while costing only a fraction. On Arena's Web Dev leaderboard, it became the top-ranked open-source model, just eight points behind the Gemini version of Argon.

I reran the same batch of prompts and settings used for the September version: reasoning tokens at the high level fell by about one-third, the drop at the max level was even larger, and accuracy rose instead, with particularly obvious gains in object-detection projects involving vision. One interesting detail is that I finished testing before the official announcement; the model name and response fingerprint in the API had not changed, but the model behind it had clearly been swapped.

Long-horizon agent tasks: from a 3D dragon to a running robot dog

I threw the same batch of long-horizon tasks I had given to the Gemini version of Argon a week earlier into the DeepSeek harness to run unattended. Each task was a goal; the agent kept working, checked its output with screenshots, and stopped only when it considered itself done.

The first was a 3D test that graphics researcher Kenan Crane had run on another frontier model: use signed distance functions (SDFs) to describe each shape purely mathematically, without Blender or any 3D software, and build a dragon. Given the same two prompts and reference image, every scale, horn, and eye in the final render is a mathematical function in a single shader file.

Next came three open-ended 3D worlds: a procedural planet, a portal physics lab, and a mechanical watch with real gear transmission. Each was a single-page webpage it wrote itself, tested in the browser, and kept improving for about an hour. For a self-hostable open-source model, that is a strong result.

More convincing were the real GPU experiments. I gave it access to a DGX Spark, and the first task was a binary galaxy collision simulation with more than 500,000 stars: it wrote the simulation itself, checked that total energy was approximately conserved, and then rendered the full merger process. On the first run, the Spark froze outright because three heavy tasks were running at once—that was my own configuration problem, but the model did not proactively point it out.

The most impressive was the robot dog from the beginning: it was asked to hand-write the PPO reinforcement learning algorithm from scratch, without using any RL library, and teach a quadruped robot ant to walk. After 46 seconds of training it began moving forward, reached the target score in under two minutes, and after 26 minutes was running at nearly 6 meters per second. Writing the code, training, rendering the video, and generating the results page took about 22 cents in total.

Technical background on SDF and PPO

A signed distance function (SDF) is a method of describing a 3D shape with a mathematical expression: for any point in space, the function returns the shortest distance from that point to the shape's surface, with the sign indicating whether the point is inside or outside. By combining basic SDFs such as spheres, cylinders, and toruses and performing Boolean operations, complex models can be built purely in code without traditional polygon meshes. This requires strong mathematical abstraction and spatial reasoning abilities from the model.

Proximal Policy Optimization (PPO) is a classic algorithm in reinforcement learning that stabilizes training by constraining the magnitude of policy updates. Having a model hand-write PPO from scratch and train a quadruped robot to walk tests its comprehensive grasp of reinforcement learning principles, reward design, hyperparameter tuning, and parallel environment simulation, rather than simply calling an existing library.

Multimodality and frontend: smart, but not frontier

The model natively supports image input, not video, so the agent needs to extract frames itself to watch.

The first vision test was a floor plan missing the dimensions of two rooms, with the requirement to generate a complete 3D walkthrough. It inferred the missing dimensions from the rest of the drawing and produced a dollhouse view, a top-down floor plan, and an auto-guided walking mode. The second was a 20-second video of chaotic double-pendulum motion, with the requirement to build a side-by-side comparative simulation. It tracked the light points on both pendulum arms across all 500 frames, then fitted the physical parameters, and then let the simulation run fully autonomously—it matched for the first few seconds and then gradually drifted, exactly as a real chaotic system should. By comparison, the Gemini version of Argon tested last week measured the pendulum angles from the video and then used a hidden spring to pull the simulation back toward the target region.

The frontend is where the gap shows. For simple landing pages, it rebuilt them almost pixel-perfectly; but for complex pages like the NASA homepage, it consistently fell slightly short of Argon—even though human voters on Arena liked its design almost equally. Argon's visual fidelity is clearly stronger. It performed impressively when adding dark mode to pages; all the photos in the page were hand-drawn by it in SVG, and the parachute on the NASA page was thousands of lines of hand-written vector code.

The difference between visual fidelity and design preference

Frontend page reconstruction involves two dimensions: visual fidelity (pixel-level reproduction of layout, colors, fonts, and images) and design sensibility (subjective human preference). The Arena Web Dev leaderboard is based on human pairwise votes and reflects the latter; precise reconstruction of complex pages (such as the NASA homepage) depends on the former. DeepSeek 1017 is close to frontier models in design preference, but its visual fidelity still lags behind Gemini Argon, indicating gaps in fine-grained spatial localization and style reproduction in its multimodal understanding. The model's hand-written SVG image generation demonstrates its code-generation ability to turn visual elements into vector code.

How to choose the reasoning level

The model has three levels: low, high, and max. I reran 20 tasks on high to compare with max: max generated about 16% more tokens, and total time for reasoning tasks was almost the same; on reasoning problems and webpage reconstruction, max showed no measurable difference, and high was already enough for perfection; but in long-horizon open-ended builds, max completed the floor plan that high timed out on, and the 3D worlds were noticeably richer. My advice is simple: default to high, and switch to max only for long-horizon open-ended builds that need repeated polishing.

Another practical reminder: DeepSeek says the model was trained inside the DeepSeek harness, and recommends upgrading to the latest version (0.2.1 at the time of recording). I saw no obvious difference when testing with the older version, but it is worth keeping in mind.

What the reasoning level does

The reasoning level controls the upper limit on thinking tokens the model may consume before generating an answer. The low level favors fast responses and suits simple queries; the high level balances accuracy and cost; the max level allows a longer internal reasoning chain and suits complex tasks that require repeated trial and error and self-correction. The higher the level, the more likely the model is to find and correct errors, but token consumption and latency also increase accordingly. Hands-on tests show that for reasoning problems with clear answers, the high level is already sufficient; for open-ended long-horizon builds, the max level can complete tasks that the high level times out on and produce richer details.

Conclusion

The real significance of the 1017 version is that DeepSeek has, for the first time, achieved both "cheap per token" and "cheap per task," closing the token-efficiency gap. It is not a frontier model, and the gap is visible to the naked eye when doing precise frontend reconstruction; but in the long-horizon agent task range at this price, it is the most cost-effective model I have tested so far. The price war has already begun, and even Chinese vendors are using it to pressure one another.

One-line Summary

DeepSeek V4.1 Flash 1017 greatly improves token efficiency and stands out on long-horizon agent cost-effectiveness, but frontend visual fidelity still lags behind the frontier.

Paragraph Summary

DeepSeek released the 1017 version of V4.1 Flash, officially a "small update," but hands-on tests show its core improvement is token efficiency: at the same unit price, coding task cost drops from about 50 cents to 20 cents, high-level reasoning tokens fall by about one-third, and accuracy rises instead. Terminal Bench rises from 31 to 42, and it becomes the top open-source model on Arena Web Dev. Long-horizon agent tasks are impressive: a purely mathematical SDF-generated 3D dragon, a 500,000-star binary galaxy collision simulation, and hand-written PPO from scratch teaching a robot dog to walk (starting in 46 seconds, nearly 6 m/s in 26 minutes), all for only 22 cents. Multimodal support includes image input but not video, and complex frontend page reconstruction still trails Gemini Argon. Recommended: default to high, switch to max for long-horizon open-ended builds, and upgrade DeepSeek harness to 0.2.1.