Open-Source vs Closed AI Models
Open-weight or proprietary AI models? How they differ on licences, cost, privacy, control and capability, and how to choose for each task.
If you're building an AI-powered product, one of your first decisions is which AI model sits at its core. And the first fork in that road is whether to use a closed model you rent from a provider, or an open model you can download and run yourself.
A few years ago the answer was easy: the best models were all closed. That's no longer true. Open models now handle a large share of everyday work well, and the decision has become a real trade-off between capability, cost, control and privacy.
A closed model is like a cloud service: you use it over the internet and the provider runs it. An open model is like software you can install: you get the files, run them where you like and change them, but you also look after them.
What "open" and "closed" actually mean
The words get used loosely, so it helps to separate three cases:
- Closed (proprietary) models. The company keeps the model's weights private. You use it through an app or an API, under the provider's terms. Most of the best-known assistant models work this way.
- Open-weight models. The company publishes the trained weights (the numbers that make up the model), so you can download, run and fine-tune it. The training data and full training code usually stay private, and the licence may restrict some uses.
- Fully open-source models. Weights, training code and often the training data are published under an open licence. These are rarer, and especially valuable for research and auditing.
Most models people call "open source" are really open-weight. Always read the licence: some allow any commercial use, some require attribution, and some restrict use above a certain size of company or for certain purposes.
How they compare
| Closed models | Open-weight models | |
|---|---|---|
| How you use it | API or app from the provider | Download and run, or use through a hosting provider |
| Top-end capability | Usually where the newest frontier models appear first | Strong and improving; often close behind on many tasks |
| Setup effort | Minimal: an API key | From easy (hosted) to significant (your own GPUs) |
| Cost model | Pay per token used | Pay for hardware or hosting; per-request cost falls with heavy, steady use |
| Data location | Sent to the provider (check their data terms) | Can stay entirely on your own infrastructure |
| Control | Provider can change prices, behaviour or retire versions | You choose the version and when to upgrade |
| Customisation | Limited to what the provider offers | Full: fine-tuning, quantization, changing how it runs |
| Transparency | Little visibility into training | Weights inspectable; data often still private |
The case for closed models
- Easiest start. No servers, no GPUs: send a prompt to an API and get an answer. Good for prototypes and small teams.
- Frontier capability. The most capable large language models for hard reasoning, long documents and complex agent work have usually been closed first.
- Managed reliability. The provider handles scaling, uptime and safety systems, and often offers enterprise agreements on data handling.
The trade-offs: your costs rise with every request, you depend on one company's prices and roadmap (models get retired), and your data leaves your network. That last point may be acceptable under a good agreement, or a deal-breaker in regulated work.
The case for open models
- Privacy and data control. Run the model inside your own network and your data never leaves it. For some healthcare, legal, government and finance work, that's a requirement.
- Predictable costs at volume. If you process a lot of requests steadily, paying for your own hardware or a dedicated server can cost less than paying per token. At low or unpredictable volume, it usually costs more.
- Control and stability. Nobody can retire your model version or change its behaviour overnight.
- Customisation. You can fine-tune it on your own examples, shrink it with quantization, or use a small language model built for one job.
The trade-offs: someone has to run it, keep it secure, monitor it and update it. GPUs are expensive and in demand. Open models may lag the newest closed ones on the hardest tasks, and the licence may limit what you can do.
A middle option: open models, hosted for you
You don't have to run open models yourself. Many cloud and inference providers host popular open-weight models behind an API, priced per token like closed ones. You get the model's openness (you could move it in-house later) without owning servers, but your data goes to that host, so the privacy benefit depends on where it runs.
Smaller, specialised models
Not every task needs the biggest model. A lot of open models are built to be small and efficient:
- Model distillation trains a small model to imitate a larger one, keeping much of its quality at a fraction of the size.
- Quantization stores the model's numbers with less precision so it needs less memory and runs on cheaper hardware, sometimes on a laptop.
- Fine-tuning a small open model on your own data can beat a general-purpose large model on one narrow, repetitive task.
Both open and closed models are usually built on the same transformer architecture and start as general foundation models. The difference is who gets the weights, not how the model works.
The hybrid approach most teams use
In practice the question is rarely "open or closed?" but "which model for which task?" A common pattern:
- Closed frontier model for the hard, user-facing work, such as complex reasoning, writing that has to be excellent, and multi-step agents.
- Smaller or open model for high-volume background work, such as tagging support tickets, summarising internal documents, extracting fields from forms and screening logs.
- On-premises open model for sensitive data that must not leave your network.
Software that routes each request to the right model also makes it easier to switch providers later, which is the best protection against lock-in.
A checklist for choosing
- How hard is the task? Try your real examples on both kinds before deciding.
- Where may the data go? If it can't leave your network, you need a self-hosted open model.
- How many requests, how steadily? Low or spiky volume favours paying per token; high, steady volume can favour your own hardware.
- Who will run it? Self-hosting needs people with infrastructure and security skills.
- What does the licence allow? Check commercial use, attribution and any size limits.
- How will you switch? Keep prompts and code portable so you aren't tied to one provider.
Want to run AI locally?
Curious about running open models on your own machine? Check out our list of the best local AI tools.
Frequently asked questions
Are open-source AI models free?
The weights are often free to download, but running them isn't: you pay for hardware, hosting, electricity and the people who maintain it. Some licences also restrict commercial use.
Are open models as good as closed ones?
On many everyday tasks, they're close. The newest closed frontier models have usually led on the hardest reasoning and agent tasks. Test with your own workload.
Is an open-weight model the same as open source?
Not quite. Open-weight means the trained model is published; open source in the strict sense also means the training code and data are open under an open licence.
Is my data safer with an open model?
Only if you run it on infrastructure you control. An open model hosted by a third party still sends your data to that host.
Can I use both?
Yes, and most teams do: a closed model for the hardest tasks, open models for volume or sensitive data.
Summary
- Closed models: easiest to use and usually the most capable at the top end, but you pay per token, depend on one provider and send data out.
- Open-weight models: you get the weights to run, tune and keep private, but you take on hosting and must check the licence.
- Hosted open models sit in between.
- Small, distilled and quantized models make open models practical for focused, high-volume work.
- Most teams mix both, choosing per task.

Stephen Gbolagade
Software Engineer and Technical Writer at Ploba
Writes Ploba's guides to AI tools, agents and protocols, explaining how they work in plain language.
Keep learning
Plain-language explanations, technical guides and practical comparisons.


