Open models have never been this good.
Not long ago, building an application on them meant accepting that they would trail closed, proprietary models. You could gain control over the technology, customize the model or cut some dependencies, but you usually had to give up part of what the big labs offered.
Today the picture is very different.
Families like DeepSeek, Qwen, GLM and Kimi have achieved remarkable results in coding, reasoning, document understanding and tool use. We are no longer talking only about cheap alternatives for simple tasks. In many cases, these models are perfectly capable of running complex applications and products.
Above all, they already match or beat many of the closed models companies use in their applications, such as Claude Haiku, GPT-6 Luna or Gemini Flash.
Using frontier models for high-volume applications and agents is still overkill, and very expensive. So companies fall back on older, cheaper models.
But the reality is that open models already outperform those older generations and those less capable closed models. And every new generation keeps improving.
Even so, that progress doesn't seem to convince every company.
A few days ago, Tomasz Tunguz published the results of Theory Ventures' second annual survey of 455 people who build and use AI applications. One finding stood out: the share of teams mainly using open models had dropped from 66% in the 2025 sample to 41% in the 2026 one.
My theory is that much of that share was Gemma 4, which companies see as "safer" because it belongs to Google. And as it fell behind on many agentic tasks, companies replaced it with closed models.
At the same time, the rise of open frontier models has increased the use of Chinese models. But not enough to make them a strong enterprise bet.
If open models keep getting better and can be much cheaper, why are some companies still not making the move?
I think there are several reasons. And many have less to do with how intelligent the models are than with the sense of safety companies need.
DeepSeek is opening up much more than its model weights
What interests me most about DeepSeek isn't only how fast its models are improving. It's everything they are sharing with the ecosystem.
For a long time, the conversation about open models has focused almost entirely on weights. A lab trains a model, publishes its parameters and lets others download and run it under certain conditions.
That already matters, although access to the weights doesn't necessarily mean the model has a fully open license. It's worth separating *open source* from *open weights*, because not every project allows the same uses.
But building an AI application takes much more than a model.
You have to run it efficiently, manage memory and concurrency, connect it to tools and get it to work across several steps without losing context or breaking what it's doing.
This is where everything DeepSeek is sharing becomes especially interesting.
Over the last few months they have released projects that make it possible to understand and reuse different parts of their systems. Three of them go a long way toward explaining where the ecosystem is heading.
The first is the model itself. DeepSeek V4.1 Flash, for example, has 552 billion parameters, of which it activates roughly 16 billion during inference, and supports contexts of up to one million tokens. Its 1017 update substantially improves results in coding, reasoning and agents without making the model any larger.
According to Artificial Analysis, the new version goes from 39 to 45 points on its Intelligence Index. That doesn't make it the best model on the market for every task, but it does show how much the capabilities of a single architecture can improve.
The second is the inference engine. On October 20, DeepSeek released DeepInfer, the high-performance framework built to run its models at scale.
This is a less visible part of AI, but a fundamental one for its economics.
A capable model isn't enough. You also need it to run fast, make good use of the hardware and serve many requests without wasting resources.
DeepInfer includes optimizations for GPU operations, parallelism, asynchronous scheduling, decoding and structured generation. Technologies that usually go unnoticed by people calling an API, but that can have a big impact on system performance.
Thanks to its inference stack, DeepSeek achieves very high tokens per second, a high cache hit rate and very low costs.
There is a caveat: what DeepSeek has released so far supports offline inference, but doesn't yet include every component needed to build a complete production inference service. Nor is it something you can just install on any GPU.
Even so, a lab sharing part of the technology it uses to run its own models is an important contribution.
The third is the harness. In August, DeepSeek released DeepSeek Harness, the software that wraps a model to turn it into an agent that can use tools, work with files, run commands and keep track of a task's state.
We built an interactive microsite to explore its architecture, because I think it's one of those projects whose interest goes beyond the features it offers today.
A harness decides which tools an agent has, how its permissions are managed, what information it receives and what happens after each action. Two agents using exactly the same model can behave very differently depending on how that system is built.
DeepSeek Harness bets on a modular architecture based on Cordis that lets you replace and extend different components. It is still a work in progress, but it's especially interesting that its authors have also shared part of the theoretical foundations of its design.
What matters about these three projects is that they show something we often forget when we talk about AI.
An application's results don't depend only on the model. They also depend on how we run it and on all the software we build around it.
And when those pieces are shared, other companies and developers can learn from them, improve them and bring them into their own systems. And the whole ecosystem moves much faster.
DeepSeek isn't opening up all of its infrastructure or every internal process. But its contributions let part of its progress benefit projects that don't have to use DeepSeek's services at all.
Companies want to optimize the cost of AI
There's a fairly simple reason open models are becoming more attractive: cost.
When you're experimenting, paying a few euros to use an API is rarely a big deal. But once that application starts to grow, the numbers change. When you extend that use to the rest of the organization and consumption grows, so does the bill. And when models improve and prices go up, the bill goes up too.
Imagine you're processing millions of documents a month, adding AI to a product with thousands of users or running agents that make dozens of calls to complete a single task.
Every request counts. And so does every token.
That's why some companies start with the most powerful models and end up looking for alternatives for certain parts of their applications. Not because they no longer need quality, but because they need a balance between performance and cost that makes their product sustainable.
And many are getting interested in open models now because they can cut their bill by orders of magnitude.
They are also very flexible and don't tie you to a specific vendor. You can choose between inference providers, buy dedicated capacity or deploy the weights yourself when you have the volume and the team. On top of that, many models are optimized to deliver good results with fewer resources than their capabilities would suggest.
The DeepSeek V4.1 Flash update is a good example.
In Artificial Analysis' evaluations, version 1017 raises its Intelligence Index from 39 to 45 points and cuts the average cost per evaluated task from $0.57 to $0.26. A drop of roughly 54%, under the specific conditions of that evaluation.
That doesn't mean every application will halve its bill by using it. The result depends on the tasks, the prices, the quality required and the resources each run consumes.
But it does show that a model that was already cheap can become more capable without raising its price per token and, at the same time, need less money to complete a set of tasks.
With agents, that difference can matter a lot. An agent doesn't make a single request and stop. It reads files, uses tools, writes code, finds errors and tries again. Sometimes it needs hundreds of interactions to finish a job.
If we get it to solve more tasks correctly while using fewer resources, the product's economics change. Sometimes a product that isn't viable with closed models is profitable with open ones.
There is, however, an important difference between a cheap model and a cheap application.
The model with the lowest price per million tokens can turn out worse if it keeps failing or needs lots of corrections. And a more expensive model can end up paying off if it solves a hard task on the first try.
That's why I think we should compare the cost per correctly completed task much more, instead of looking only at API prices.
Open models don't guarantee savings, but they do greatly widen the chances of finding a more efficient solution.
Still, for many companies that aren't running Fable/Astra/Argon in production, open models are already at the frontier of their use cases, and the cost per completed task is vastly lower than what they pay today with closed models.
"Sure, but we don't want to send our data to China"
This is probably one of the objections we hear most when talking to companies interested in open models. There's a misconception that using models built by Chinese companies means sending your data to those companies.
They like the models. They see the results, compare the costs and understand they can be a good alternative for certain tasks.
But they worry about what really happens to their data.
The privacy policy of DeepSeek's official service states that its servers are located in China and that certain personal data may be processed and stored there.
For some companies, especially those handling sensitive information, customer data or specific regulatory requirements, that can become a major barrier.
There are also organizations with specific restrictions on using technology from certain vendors or countries. In those cases, changing where inference runs isn't enough: you have to check exactly what their policies and obligations allow.
And on top of that, for simple reasons of sovereignty and competitive advantage, you don't want your best research and breakthroughs to end up training a model and being available to everyone.
But there is a distinction here that I think is fundamental and that still causes a lot of confusion.
Using a model developed by a Chinese company doesn't necessarily mean sending your data to China.
When you use DeepSeek's official API, you are buying an inference service provided by DeepSeek under its terms.
When you use the model's weights deployed on other infrastructure, you are using the model's technology, but not the service of the lab that built it.
They are different things.
The closest example is any open-source software you install on your own machine and control 100%. Here, the model's weights are installed on other servers and DeepSeek no longer has anything to do with it.
You can run certain DeepSeek models on your own infrastructure, rent a dedicated environment or turn to a European provider that operates the weights independently.
In that last case, requests can be processed entirely in Europe, with no need to send them to DeepSeek's servers to get a response.
The model is still DeepSeek. Its behavior and capabilities come from the work of the lab that trained it. But the data path and the terms of service depend on the infrastructure and the provider that actually runs inference.
This separation is one of the great advantages of open-weight models.
Of course, running a model in Europe doesn't make every risk disappear.
You need to review licenses, verify where components come from, assess potential vulnerabilities and check what information the provider logs. You also need to understand what contractual guarantees exist and what security mechanisms protect the infrastructure.
Models can also have behavioral or security issues regardless of where they run.
Even so, today's open models deployed on infrastructure other than their creators' have been widely analyzed by agencies and companies looking for vulnerabilities or backdoors, with no findings. It simply comes down to distrust.
Right now, a company can want to benefit from DeepSeek's progress and, at the same time, require that its requests never leave European infrastructure under certain privacy conditions.
Both decisions are compatible.
And that is precisely one of the reasons it makes so much sense for open models to be able to run outside their developers' infrastructure.
"We don't want to manage our own GPUs either"
Once the question of where data is processed is settled, another one usually comes up.
Do we have to deploy the model ourselves? And load-balance it? And update it? And deploy the next version?
And this is where a rather different conversation begins.
Downloading a model's weights doesn't mean having a production-ready inference service. You need suitable hardware, memory management, good performance, and you have to solve concurrency, availability and maintenance.
All of that takes time, expertise and money.
And the bigger the model, the more demanding the infrastructure needed to run it.
DeepSeek V4.1 Flash has 552 billion parameters in total. Even though its architecture activates a much smaller fraction at each inference step, the weights, the model's distribution and the resources needed to serve it still pose major challenges.
This isn't something you can run on an ordinary laptop and immediately use to serve thousands of users.
Even with advanced tools like DeepInfer, you need to solve additional problems to turn an inference engine into a reliable service.
That's precisely why DeepSeek warns that the open version of DeepInfer doesn't yet include every component needed to operate a complete online service.
That said, being able to host your own models doesn't mean you have to.
Just as a company can use PostgreSQL without running its own database servers, it can also consume open models without directly managing the infrastructure that runs them.
And that lets us separate two decisions we often mix up: which open model we want to use and who we want to run it.
For a company with a large, steady inference volume, a specialized infrastructure team and very specific requirements, deploying open models on its own can make sense.
For another, it can be far more efficient to use a managed provider and spend its resources building the product. There are many: Baseten, OpenRouter, Bedrock, Helmcode.
The advantage is being able to choose. Something you can't do with closed models.
How to benefit from open models without taking on all their complexity
For years, much of the ecosystem's effort went into proving it could build models able to compete with the big proprietary labs.
That work is still necessary. Closed models still have advantages on certain tasks, and it would make no sense to ignore them.
But having competitive models is only part of the problem.
We also need companies to be able to use them easily, evaluate their results, control their costs and decide where they want inference to run.
That's why I find it so relevant that labs like DeepSeek don't stop at sharing their model weights, but also publish tools and components of the infrastructure they use to make them work.
Developing a model, running it, and the software used to build applications and agents on top of it can all evolve independently.
And that creates possibilities that used to be much more limited.
A company can use a model developed in China, run its inference in Europe and connect it to an agent built with open tools. It can also switch providers without changing the model, although it will need to check differences in implementation, performance and behavior.
Openness doesn't remove every problem, but it keeps many of these decisions from being imposed.
And this is where what we do at Helmcode fits in.
We don't develop DeepSeek's models. We build on what their open weights make possible to offer them to companies and developers through an OpenAI-compatible API, running them on European infrastructure, with no GPUs for our customers to manage.
That lets you benefit from increasingly competitive models, with data-processing terms and contracting models that differ from the original provider's.
It doesn't mean every open model is better for every task, or that you no longer need to evaluate their quality or review their security guarantees.
But it does remove some of the barriers that have held back their adoption.
Open models have never been this good. And the ecosystem being built around them is starting to be just as interesting as the models themselves.
Some companies may still be thinking it over.
But at least they have more and more options to decide how they want to use them.
If you have questions about bringing open models into your AI stack, write to us at info@helmcode.com
