Ollama
The short verdict
The default way to run an open model locally, and the right choice when privacy, offline use or unmetered cost matter more than peak intelligence. It loses to a frontier subscription on answer quality and asks you to own the hardware and read the licences, which is exactly what it is selling you relief from elsewhere. If you only wanted to talk to an assistant, buy one. If you need the model inside your own perimeter, start here.
- Maker
- Ollama
- Category
- Local & open models
- Entry price
- Freemium
- Free option
- Yes — the local runtime and the model library are free; a limited cloud tier and paid usage-credit plans sit alongside them
- Works on
- macOS, Windows, Linux command line; a local REST API; an SDK used by many third-party chat apps
- Pricing checked
- October 2026
What Ollama is, plainly
Ollama is the command-line way to pull an open model and talk to it on your own hardware. You install a binary, type something like `ollama run` followed by a model name, and a local server starts serving that model through an API on your machine. Nothing leaves your computer unless you ask it to. That single property — the inference happens where you are sitting — is the entire reason to choose it over a browser tab full of chat subscriptions, and it is also the reason it asks more of you: you are now the infrastructure team. It reads as a tool for developers and technically confident tinkerers rather than for someone who just wants answers in a text box.
Judged purely on the quality of the answers, Ollama loses to the big closed assistants almost every time, and pretending otherwise is how most roundups earn their retractions. The models it runs are open-weight, which means they trail frontier closed models on hard reasoning, long-context coherence and instruction following — you are usually approximating what a monthly subscription hands you in one click. Where it wins instead is control and privacy: no prompt leaves the machine, no per-token meter, no vendor deciding your data policy. The honest framing is that Ollama does not compete with ChatGPT on intelligence; it competes on the ability to embed a model in something that cannot send data out — an offline laptop, an air-gapped project, a product where the customer's text must never touch a third party.
The commercial shape has a seam worth reading before you trust the word free. Running locally is genuinely free and unlimited — there is no per-token bill for inference on your own box, only the electricity and the machine you already own. Ollama now also sells cloud access to hosted open models: a free cloud tier, then plans that Ollama's own pricing page lists at $20 a month for the middle tier and $100 for the top one, with higher team pricing on request. The subtlety is that these are not feature unlocks, they are usage-credit wallets — the page states a monthly credit allowance per plan, bills cloud calls per million tokens, and caps how many requests you can run at once (a small number on the entry tiers, more on the paid ones). The surprise bill lives there, in the cloud tier: local runs never metered, hosted runs on a credit balance that refreshes monthly and does not roll over.
The licensing paragraph is the one that bites later, and Ollama will not shout it at you. 'Open model' means public weights, not public rights: each entry in the model library carries its own licence, and they range from permissive Apache-style terms to use-restricted licences that forbid particular applications, to llama-family community licences that impose their own conditions and usage policy on you as the deployer, to weights released for research only. Pulling a model through Ollama does not launder its licence, and the runtime itself is a separate matter from what the weights allow. Before anything touches a product, read the licence field on the specific model's page, and see Hugging Face for the same warning written at length — it is the catalogue where most of these weights originate.
Where it wins
- Privacy is architectural, not a policy promise: with local inference your prompts never leave the machine, which is the one thing a cloud subscription cannot honestly give you.
- No usage meter on the thing you use most — local runs are free and unlimited, so a heavy week costs electricity, not a surprise invoice.
- The lowest-friction on-ramp in the category: one command and a model is running, with an API any existing client can already speak to.
- You control cost, uptime and data path — the model works on a train, offline, and no vendor can change its price or retire it under you.
Where it falls short
- The open models it runs are a clear tier below the frontier closed assistants on hard reasoning and long tasks; you are trading capability for control.
- You become the operations layer: driver issues, out-of-memory crashes and model updates are now your problem, not someone else's SLA.
- Real quality needs real hardware, and the requirement scales with model size and quantisation — a rule of thumb, not a fixed spec, so budget against what Ollama documents for the model you actually want.
- The licence on each weight is your responsibility to read; 'on the library' is not 'cleared for my product', and the runtime gives you no warning about it.
What it's built for
One-command model pull and run
A single command downloads a model and opens a chat against it locally. This is the feature that made Ollama the default first step into self-hosted models: the barrier to 'run a 7B on my laptop' went from an afternoon of Python to one line.
A local API on your machine
Serving a model exposes an OpenAI-compatible HTTP endpoint on localhost, which is why dozens of third-party chat apps, editors and agents can point at it. The model runs at home; the app is just a client.
A curated and versioned model library
Popular open models are packaged so `ollama pull <name>` just works, with tags for quantised sizes. Convenient, but the convenience hides the licence and the hardware cost, so treat the library as a starting point to verify, not a decision.
Modelfile for reusable configurations
Define a base model, a system prompt, temperature and other defaults, then build a named configuration on top. Quietly the most useful feature for people wiring a specific small model into a specific recurring job.
Cloud tier for models too large for your box
Hosted open models, billed per million tokens against the monthly credit allowance on your plan. The pragmatic bridge when you want open weights but lack the hardware for the size you actually need.
What it costs, and what these numbers cannot tell you
| Plan | Indicative price | What you actually get |
|---|---|---|
| Local (free) | $0 | The core runtime and the model library, running on your own machine with no metering and no per-token cost. For the majority of readers this is the whole product and it genuinely costs nothing beyond hardware and power. |
| Cloud free tier | $0 | A small hosted allowance with a low concurrency limit, aimed at trying the cloud path and at small models. Fine for experimentation; the request cap is the practical ceiling, not the credit balance. |
| Pro / Max cloud plans | $20 and $100 per month respectively, per Ollama's pricing page | Each grants a monthly usage-credit allowance rather than a feature list, bills hosted calls per million tokens, and raises the concurrency cap. Credits refresh monthly and, on the terms shown, do not roll over — so this is a meter, not an unlock. Check the live page before committing; allowances and prices move. |
| Team / Enterprise | higher fixed pricing; enterprise on request | Shared credit pools, centralised billing and the arrangements larger organisations ask for. If procurement is involved, the data-handling terms matter more than the credit numbers here. |
Who it fits, and who it doesn't
Reach for Ollama if you…
- Developers embedding a model in software that must run offline, on-prem, or without shipping a customer's text to a third party.
- Anyone with a capable machine who is tired of per-token costs and wants unlimited local experimentation on small and medium models.
- Prototyping a specific small model against your own data before deciding whether the whole hosted-subscription stack is even necessary.
- Privacy-sensitive work — drafts, notes, personal documents — where you would rather not paste the content into a cloud assistant.
Skip it if you…
- You mainly want the smartest possible answers with zero setup — a frontier closed assistant beats anything you will run locally, and costs less than a GPU.
- Your machine is modest and you need a large model: the honest experience is slow or out-of-memory, and the cloud tier or a subscription is the better path.
- You cannot read a model licence and would be deploying weights you do not understand into something commercial.
- You are not comfortable with a command line — in that case a graphical front end like LM Studio is the friendlier door to the same open models.
Where it stops fitting
How to test it properly in 30 minutes
Don't judge a tool on the demo. Run the same four tasks you'd actually do with it, and score it against this checklist — the same one this desk works from before a profile goes up (see how we check a tool).
- Pick one model you actually intend to use and check what Ollama and the model's own page say about the memory it needs; size your hardware against that documented figure, not against a blog post claiming a token rate.
- Run the same three tasks — a summary, a reasoning question, a piece of code — on the local model and on your usual cloud assistant, and note how often you reach for the cloud one. That gap is the price of control.
- Confirm the local API works from a real client (a chat app or a short script) before assuming you will enjoy the workflow; the API is the product for builders.
- Read the licence field on every model card you plan to ship, and record precisely what you would owe: attribution, use restrictions, redistribution rules.
- If you touch the cloud tier, model your monthly token volume against the credit allowance first — it is metered per million tokens and the concurrency cap binds before the credits run out.
Questions people ask
Is Ollama actually free?
The part most people use, yes: the local runtime and the model library cost nothing, and inference on your own machine is unmetered. What is not free is the cloud tier for hosted models — that runs on paid plans with monthly usage credits billed per million token, and the pricing page lists those at a couple of price points above the free cloud allowance. The honest split is: local free forever, hosted metered.
What hardware do I need?
It depends almost entirely on the model's size and quantisation, which is why any fixed spec table online is a guess. As a rule of thumb a quantised model needs roughly its own file size in memory plus headroom for context, so a small quantised model runs on an ordinary laptop while a large one wants a machine with a lot of fast RAM or a real GPU. Verify against what Ollama and the individual model page state for the specific model you want.
Are the models I download free to use commercially?
Some are, some are not — that is the trap. Each weight carries its own licence, from permissive Apache terms to use-restricted and llama-family community licences with conditions of their own, and pulling a model through Ollama does not change any of that. For anything commercial, read the licence on that model's page before you deploy it, not after. This is the same caveat that applies across Hugging Face.
Ollama or a normal chat subscription?
If you want the best answers with no setup, a subscription wins and will keep winning on hard tasks. If you need the model to stay on your machine, to run offline, or to cost nothing per token at volume, Ollama wins and the capability gap is the price you agree to. They are not really competitors; they answer different questions.
Alternatives worth comparing
The hub where open models, datasets and demos live — infrastructure for builders and researchers, not a consumer chatbot.
The default AI assistant — the broadest feature set, and the benchmark every other tool gets measured against.
Claude
The assistant for people who read a lot: long documents, careful prose, and fewer invented answers.
Disclosure: this profile is editorial. Ollama did not review it, pay for it or provide a free account for it. Links to the vendor are plain outbound links, not affiliate links. Errors are mine — report one and it gets fixed and logged on the updates page.