Back to articles

Why Open AI Models Are Essential in 2026

Artificial Intelligence 9 min read

Why open models remain essential in the face of OpenAI, Anthropic, and the other AI giants

For his very first post on X, Jensen Huang didn't announce a new graphics card, a giant partnership, or yet another performance record for NVIDIA.

He shared a letter in support of open artificial intelligence models.

The choice is obviously not a coincidence.

NVIDIA sells the chips used to train and run most of today's models. The more companies, researchers, and developers can grab a model, install it on their own machines, and adapt it to their needs, the more important the ecosystem around NVIDIA's hardware becomes.

But reducing this letter to a simple business play would be a bit too easy, because the topic goes well beyond the manufacturer's own interests.

The question is fairly simple: do we want the best AI models to remain accessible only through the servers of a handful of companies, or do we also want to be able to download them, study them, modify them, and run them elsewhere?

Jensen Huang's answer is fairly reasonable: we need both.

Closed models move fast, but we barely control any of it

The models offered by OpenAI, Anthropic, or Google are often the most capable on the market.

Using them isn't complicated. You create an account, grab an API key, and start sending requests. No need to buy a server packed with GPUs, pick an inference engine, or figure out how to fit a model with tens of billions of parameters into the available memory.

That simplicity is a huge advantage.

For quickly adding text generation, an assistant, or document analysis to a web app, an API is often the most pragmatic choice.

But that convenience comes at a cost: the provider stays in control.

They can change their pricing, swap out a model, alter their usage limits, or remove a version your application depends on. Your data also ends up on external infrastructure, which can be a problem depending on how sensitive it is, where it's stored, or the commitments made to your own customers.

And above all, you never really know what's going on inside the model.

You can read a spec sheet, check a few benchmarks, and test its behavior. But you can't download Claude or GPT-5.6 and quietly pick it apart on your own server.

OpenAI took a step, Anthropic still hasn't

OpenAI did release gpt-oss-20b and gpt-oss-120b back in August 2025. Both models can be downloaded, fine-tuned, and run locally or on private infrastructure. The smaller one can run with about 16GB of memory, while the larger one is aimed more at machines equipped with an 80GB GPU.

That was good news, especially coming from a company that still has the word "Open" in its name.

The problem is that neither base model has really been replaced since. Meanwhile, OpenAI has kept pushing its closed lineup forward much faster. Its page for open models still mainly features gpt-oss-20b, gpt-oss-120b, and their safety-focused variants.

Anthropic goes even less far.

The company publishes research papers, tools, studies on how Claude works internally, and documents detailing its safety choices. But it doesn't provide a single Claude model that anyone can download and run freely on their own machine or server.

That's a shame, because Anthropic is currently one of the most interesting teams in the field, particularly for code and autonomous agents.

Researchers can read their papers. Developers can call their API. But no one outside the company can actually get their hands on Claude to take it apart, study it, or deeply customize it.

Meanwhile, Chinese labs keep shipping releases

DeepSeek, Qwen, Kimi, and GLM now hold a massive place in the open-model ecosystem.

They regularly release new versions, models specialized in code, reasoning, or tool use, and let an entire community quickly put their work to the test.

DeepSeek, for instance, has kept evolving its V3 family with models capable of reasoning while calling tools, a key requirement for building real agents that can take action inside an application.

This produces a rather odd effect.

American companies still dominate most of the commercial AI market, but a large chunk of open experimentation now relies on models coming out of China.

For a developer, where a model comes from isn't necessarily the top priority. What matters is being able to test it, compare its results, read its license, and check whether it fits the project's needs.

For the United States, the issue is obviously more strategic. That's exactly what the letter shared by Jensen Huang is trying to highlight.

What the letter is really arguing for

The document compares the rise of open models to that of open-source software in the 1980s.

Back then, plenty of companies still believed that keeping their code secret was the best way to protect their edge. History showed that an open ecosystem could instead become the foundation for a huge chunk of the Internet, servers, development tools, and modern infrastructure.

The letter argues that AI is now facing a similar choice.

An open model lets a company, university, or research team build on an existing foundation instead of training a model from scratch. They can then test it, adapt it to their field, and choose where they want to run it.

The document also stresses several points:

  • avoiding total dependence on a single provider;

  • keeping control over one's data and infrastructure;

  • allowing researchers to study how models behave;

  • making it easier to build specialized models;

  • strengthening competition instead of concentrating AI in just a few hands.

The letter is signed, among others, by NVIDIA, Microsoft, Meta, Dell, IBM, Mistral, Hugging Face, Mozilla, GitHub, Palantir, Perplexity, Replit, and Y Combinator. OpenAI is also among the signatories, which makes the absence of a genuinely new generation of gpt-oss all the more interesting to watch.

For a developer, the difference gets very concrete

Take the case of an online retailer who wants to add an assistant to their Symfony back-office.

The goal would be to let the team ask questions about the catalog, orders, internal procedures, or product documentation.

With an external API, setup can be quick.

The application pulls the relevant information, sends it to the model, and displays the response. The provider handles the hardware, the updates, and the capacity needed to handle demand.

On the other hand, you have to accept that some information leaves the company's infrastructure. You also need to track costs on every single call and stay dependent on whatever models the provider offers.

With an open model installed on a private server, the data can stay in-house.

You can decide exactly what the model is allowed to access, adapt it to the company's vocabulary, and integrate it into the existing system without sending every question out to an external service.

You can also experiment much more freely during development. There's no API bill for every token generated, even though the compute obviously isn't free: you still have to pay for the machine, the electricity, the hosting, and the time spent maintaining everything.

This is where the whole "run everything locally" narrative bumps into reality.

Open doesn't mean free or easy

Downloading a model can sometimes take just a few minutes. Getting it to run properly in production is a whole different story.

You have to pick the right format, quantize the model if there isn't enough memory available, set up an engine like llama.cpp or vLLM, handle updates, monitor response times, and secure access to the server.

You also have to check the license.

A model available on Hugging Face isn't automatically free of commercial restrictions. Terms vary from one publisher to another, and some models come with specific conditions attached.

Finally, performance doesn't always match the best closed models.

A smaller local model can be enough to classify documents, extract data, summarize product sheets, or answer well-defined questions. It'll often struggle much more with a complex problem, a large codebase, or a task requiring lengthy reasoning.

So the right choice isn't necessarily to host everything yourself.

It's more about using the right model for the right job.

A small local model can handle repetitive tasks and sensitive data. A more powerful API can be reserved for harder requests, after anonymizing or filtering the information sent.

This hybrid approach strikes me as far more realistic than the oversimplified debate that constantly pits open models against closed ones.

Open models also raise real security concerns

The letter doesn't fully hide this point.

Once a model is released, its creator can no longer decide who uses it or stop someone from producing a modified version. It also becomes very difficult to pull the model back or patch every copy that's already been downloaded.

A closed model lets the provider block certain uses, monitor abuse, and quickly update its safeguards.

With an open model, those guardrails can be stripped away.

But the reverse is also true: a closed model isn't automatically safe just because how it works stays hidden.

It can contain flaws, behave unexpectedly, or be misused without independent researchers ever getting the chance to properly study it.

Open models are precisely what let more teams test them, hunt for weaknesses, and build their own protections. It's the same debate that's been going on for years in computer security: hiding how a system works isn't enough to make it solid.

We need both

On this point, Jensen Huang is right.

Closed models are useful. They give immediate access to very strong performance without having to build all the infrastructure behind them.

Open models are just as important. They keep research, experimentation, and part of the AI economy from depending solely on a handful of private APIs.

They also give developers a different way to learn.

Running a model locally, testing different quantizations, tweaking its behavior, or adapting it to a specific field teaches you far more than simply sending an HTTP request to a black box.

OpenAI took a first step with gpt-oss, but it should now go further and release a new generation that's genuinely in line with its recent progress.

Anthropic would also benefit from offering an open Claude, even a smaller one than its commercial models. It would be valuable to researchers, developers, and the entire ecosystem that's grown up around Claude Code.

The future of AI shouldn't just come down to choosing between three subscriptions and four APIs.

It should also remain possible to download a model, run it on your own machine, understand its limitations, and build something that doesn't entirely depend on some provider's next decision.

And for that, open models aren't some small bonus reserved for enthusiasts.

They're essential.

Full document: Open Weights and American AI Leadership

Jensen Huang's original post: see the post on X

Share this post

I’d like to use Google Analytics to see which pages are useful to you. Nothing is stored without your consent. Learn more