For the past couple of years, the unwritten rule of AI was simple: the most capable reasoning models live behind someone else's API. You send your prompt to their servers, you pay per token, and you trust their data policy.

This week, that rule took a hit. DeepSeek's R1 is a reasoning model you can download, run on your own hardware, and use commercially under the MIT licence. It has been the main topic in developer circles all week, and the story has spilled well beyond them into financial news and the markets.

Here's what actually happened, what "open reasoning model" really means, and what I think it changes for developers in practice.

What happened

• On 20 January 2025, DeepSeek released R1, a reasoning model, with its weights openly available.
• It's released under the MIT licence, one of the most permissive licences there is.
• Like OpenAI's o1, it uses chain-of-thought reasoning: it works through a problem step by step before giving its final answer.
• In the days since, it has made a big splash, not just among developers but in markets, as people ask what an openly available model at this level means for the AI industry.

I'll stay away from benchmark numbers and prices here. They're being argued about loudly, and they'll be out of date soon anyway. The more durable story is about access.

Why "open" matters more than "good"

Strong models are released all the time. What makes R1 different is the combination of three things that rarely come together.

1. Open weights

The weights are the trained model itself, the billions of numbers that make it work. With open weights you can run the model wherever you want: your own servers, your cloud account, a machine in your office. No API key and no rate limits set by someone else.

One nuance worth knowing: open weights isn't quite the same as fully open source. You get the trained model, but not necessarily everything that went into training it, such as the full dataset. For most developers, the weights are what matter.

2. A permissive licence

Plenty of "open" models come with licences that restrict commercial use or add conditions. MIT is about as simple as it gets: use it, modify it, build products on it, keep the licence notice. For a company deciding whether it can legally build on a model, that clarity is huge. (As always, have someone check licensing for your specific case before shipping.)

3. Reasoning, not just chat

Reasoning models are the ones that do well on multi-step problems: tricky logic, maths, planning, debugging. Until now, that class of model has mostly been available only through closed APIs. R1 brings that style of model into the open.

What it means for developers

Self-hosting becomes a real option

If your company couldn't send data to an external AI provider, the only path was a weaker local model. R1 widens that path. Be realistic, though: the full model is large, and running it well needs serious GPU hardware. For many teams, smaller open models will still be the practical choice for local use, while the full R1 runs on rented GPUs or through hosting providers that serve open models.

Privacy and control

This is, for me, the most interesting part. Think of systems that handle contracts, payments, HR records or medical data. Many of those teams have held back on AI features because sending that data to a third party is a hard conversation with legal and compliance. A model running inside your own infrastructure changes that conversation completely. The data never leaves your network.

The flip side: if you use DeepSeek's own hosted app or API instead of self-hosting, you're back to trusting a provider's data policy, exactly like any other hosted AI. Open weights only give you privacy if you actually run them yourself.

Cost becomes an engineering decision

With a hosted API, cost is per token and someone else's pricing page decides it. With your own deployment, cost is hardware, hosting and the engineering time to run it. Neither is automatically cheaper. It depends on your volume, how spiky it is, and whether you already have people who can operate GPU servers. But now you have a real choice to make, which is new for this class of model.

Less lock-in

If you design your AI features behind a small interface of your own (a ReasoningClient with one or two methods, say), switching between a hosted model and a self-hosted one becomes a configuration change. R1 is a good reminder to build that way. The best model this month may not be the best one next quarter.

What doesn't change

A reasoning model that you host yourself is still a language model. It can still be confidently wrong, invent APIs, and write code that looks right and isn't. Seeing its step-by-step reasoning can help you spot where it went off track, but the reasoning itself can contain mistakes too.

So the same rules apply: give it real context, ask for tests, run the code, and review it like a pull request from someone who has never seen your codebase.

What I'd do this week

• Try it on a few real problems from your own work, the kind you'd normally give a reasoning model. Judge it on your tasks, not on social media screenshots.
• Read the licence and model card yourself rather than relying on summaries.
• Talk to whoever owns data policy at your company. "Could we run this ourselves?" is now a much more interesting question than it was a month ago.
• Check your architecture. If switching AI providers would mean rewriting half your feature, fix that first.

The bigger picture is simple: competition between closed models from OpenAI, Anthropic and Google, and open models like Llama, Mistral and now DeepSeek R1, is good news for developers. More options, better bargaining power, fewer single points of failure.

Would you self-host an open reasoning model for your product, or is a hosted API still the better trade-off for your team? I'm curious what's deciding it for you: privacy, cost, or operations.