DeepSeek V4.1 Flash 1017: smarter, better at coding and nearly half the cost per task

DeepSeek has just released a new version of V4.1 Flash. It is called DeepSeek V4.1 Flash 1017 and, although the name suggests a minor update, the results are well worth a look. Some say it could just as well have been called V4.2.

The model keeps the architecture we met in September: 552 billion parameters, 16 billion active during inference and a context window of up to one million tokens. With the same size and the same architecture, DeepSeek has focused this time on getting more out of the resources the model already has.

And the gains are interesting.

On Terminal-Bench 4.0, an evaluation of agents that have to solve tasks using a terminal, it goes from 31.2 to 42.3 points. It also improves from 20.3 to 29.1 on ProgramBench and reaches 77 points on DeepSWE v1.1, a software development benchmark.

Those figures are published by DeepSeek, but the results from Artificial Analysis point the same way. Its Intelligence Index goes from 39 to 45 points, while the average cost per evaluated task falls by roughly 47%.

The combination is quite interesting: more capability without growing the model and, at least on that test suite, a considerably lower cost to complete the tasks.

But there is something we care about even more than benchmarks.

What happens when you hand it a real project, give it tools and let it work?

What has improved in DeepSeek V4.1 Flash 1017

To understand this update, it is worth briefly recalling what DeepSeek did in September.

V4.1 Flash brought major improvements in managing the memory needed to process long contexts. Its architecture can work with up to one million tokens of context, which is especially useful for agents that need to review repositories, consult extensive documentation or keep up conversations with many turns.

We explained that architecture and its implications at the time in our article on DeepSeek V4.1 Flash .

The 1017 update keeps that foundation and improves results across evaluations of reasoning, coding, automation and visual understanding.

These are some of the figures published by DeepSeek:

Source: official DeepSeek V4.1 Flash 1017 model card on Hugging Face . Results published by the developer, each with its own evaluation setup.

The jump on Terminal-Bench is particularly striking. But it is also interesting that the model improves on tasks where producing a correct answer on the first try is not enough.

When you use an agent to write code, it has to understand the project, decide which files to change, run commands, interpret errors and keep going. It may need dozens of steps before finishing a fairly simple task.

That is why improving on this kind of evaluation has different implications from gaining a few points on a question-and-answer benchmark.

That said, it does not mean DeepSeek has overtaken every proprietary model. In the results the lab itself published, Opus 5 is still ahead on Terminal-Bench and ProgramBench, although 1017 beats it on other tests such as DeepSWE and Automation-Bench.

Models do not work in isolation either: the agent, the tools and the strategy used to manage context can change the results considerably.

And this is where independent evaluations become especially useful.

Artificial Analysis confirms the gain

Artificial Analysis has compared the new version of DeepSeek V4.1 Flash with the previous one, using the Max reasoning setting.

The result is a six-point gain on its Intelligence Index, from 39 to 45.

It also improves on several individual evaluations. On the Terminal-Bench 4.0 implementation used by Artificial Analysis it goes from 27% to 34%, while SciCode rises from 52% to 56% and Humanity's Last Exam from 39% to 43%.

The Terminal-Bench figures do not exactly match the ones published by DeepSeek because the evaluation conditions and methodologies differ. It is important not to mix the two as if they came from the same test.

But perhaps the most interesting part of the comparison is what it costs to reach that score.

Source: Artificial Analysis comparison . The figures reflect its methodology and reference prices, not a cost measurement by Helmcode.

The average cost per task goes from $0.49 to $0.26. A reduction of roughly 47%, without any change to the list price per token used in the comparison.

On top of that, the new version produces around 17% fewer output tokens to run the Intelligence Index.

We cannot attribute the whole cost reduction to shorter answers alone, because input tokens, caching and the mix of tasks also play a part. But the economic improvement is significant within that evaluation.

I find this particularly relevant for coding agents.

In an ordinary conversation, a model needing a few more tokens to answer probably does not matter much. But when you have an agent making hundreds of calls, reviewing code and working for many minutes, the number of tokens it burns to reach a solution can make a big difference.

We should be careful, though, not to draw an overly optimistic conclusion.

Artificial Analysis does not record a general speed improvement. Latency and generation measurements vary between versions and can depend on the provider and on when they were taken.

Nor does it mean your applications will automatically cost 47% less. That figure belongs to the tasks and conditions of the index.

What the results do show is that DeepSeek has managed to increase V4.1 Flash's capability and improve its cost efficiency on an independent test suite.

And that deserves far more attention than a simple comparison of prices per million tokens.

We asked it to design a website from scratch

Beyond the evaluations, we wanted to see how DeepSeek behaved working on something that could not be solved just by writing a function. Design was not its strong point, and this was supposedly where it had improved a lot.

So we set up a web design challenge we called Signal / Noise.

The idea was simple: give the same creative brief to DeepSeek V4.1 Flash 1017 and Claude Opus 5.5, and see what each could build.

They did not start from a finished design. They had to interpret the brief, make decisions about composition, choose a visual direction and turn all of it into a working website.

I particularly like this kind of test because it mixes quite different disciplines. A model can write correct code and still have little judgement for designing an interface. It can build a technically flawless site that says absolutely nothing visually.

Here we needed both.

The models arrived at proposals that shared some visual decisions, which also made us wonder why they tend to land on similar solutions when given similar creative instructions.

But the process was very different.

DeepSeek needed about 40 minutes and used roughly 770,000 tokens. Opus finished in 17 minutes, using around 195,000.

In other words, DeepSeek used almost four times as many tokens and took more than twice as long.

Those are considerable differences.

That does not mean Opus is automatically four times better, or that DeepSeek is necessarily more expensive. To work out the cost of both runs we need to take into account the price of input and output tokens, the billing model and the conditions of the environment. Even so, DeepSeek is so cheap that it comes out ahead in any comparison.

It is also a single concrete test, with no multiple runs or statistical results behind it.

But it does show why you need to look at more than the end result.

When you use agents to build complete applications, the quality of what they produce matters, but so do how many iterations they need, how long they take and how many resources they consume.

In this case, both reached a good solution.

You can browse both websites, see every screen and compare their metrics in Design Challenge 001 .

We also wanted to try it on motion graphics

After the web design challenge, we decided to push the experiment a little further.

This time we did not want a web page. We wanted a short audiovisual piece that looked like a commission for a motion graphics studio.

The concept was quite open: What happens when machines begin to dream? We wanted to explore the transformation of information into intelligence, and of intelligence into something that almost seemed alive.

And we wanted to go beyond the usual neural network animation: visual storytelling, composition, movement, transitions and a recognisable art direction. Something with personality that did not just look like a technical demo.

There is an important nuance: the piece is built entirely in code, without any generative video model. We wanted to see how far DeepSeek could go that way.

That means solving quite different problems.

You have to work on pacing, design the elements, animate them, coordinate the transitions and keep a coherent look from start to finish. And, as with a website, getting it to work technically is only part of the job.

The first version let us explore the model's possibilities, but also its limits. There were interesting decisions and a base to keep iterating on, although the result still needed work to reach the level of finish we were after.

And I think that is precisely one of the most interesting parts of using models like these for creative projects.

They can generate code, build animations and execute an idea with growing autonomy. But there is still an important difference between producing something that works and giving it good art direction.

What this test measures is the model's ability to build an audiovisual piece in code and make decisions along the way, which is a different thing from a video generation benchmark.

Why this update matters so much to us

There is something I particularly like about this release.

Over the last few months we have watched the labs compete to improve their models' capabilities, extend their contexts and get better results on coding and reasoning tasks.

DeepSeek V4.1 Flash 1017 shows that part of that progress can come without making the model bigger or completely changing its architecture.

The gain on its Intelligence Index and the lower cost per task on Artificial Analysis are good examples of that.

But it also raises an interesting question: are we paying enough attention to how much work an agent needs to reach a result?

With coding agents, cost does not depend only on the price per token. The number of calls, the amount of context processed, the iterations needed and the errors the model manages to fix on its own all play a part.

And all of that ends up affecting the time, the consumption and the experience of whoever is using the agent.

Our web design and motion graphics experiments do not replace independent evaluations. But they let us observe a complementary aspect: what happens when you give a model a complete project, instead of asking it to solve an isolated task.

That is why we like to combine both approaches.

Benchmarks help compare models under defined conditions. Real projects let you see how they behave with more open briefs, with technical and creative decisions and plenty of chances to get things wrong.

And if we want to build these models into products, we need to understand both.

DeepSeek V4.1 Flash 1017 on Helmcode

At Helmcode we work so that you can use open models without having to manage all the infrastructure needed to serve them.

DeepSeek V4.1 Flash was already part of our catalogue, and this update improves precisely some of the capabilities we care about most for coding, agents and high-volume inference applications.

If you already use the previous version, it is worth running your tests again. Overall results may improve considerably, but that does not guarantee that all your prompts, tools or agents will behave exactly the same.

And if you have not tried it yet, we recommend going a bit beyond the usual questions.

Give it a project. Make it use tools, write and run code, find errors and decide how to carry on.

Then review what it has built, how long it took and how many resources it needed.

You can check the official DeepSeek V4.1 Flash 1017 model card , its evaluations on Artificial Analysis and our analysis of the original V4.1 Flash architecture .