MIT-licensed runtime that runs open-weight LLMs on macOS, Windows and Linux with a local API, plus an optional paid cloud for larger models.
Choose Ollama if you are a developer who wants one command to run a local model and a drop-in endpoint for agents and editors. Skip it if you want a polished point-and-click workspace. The vendor reports over 9 million installs a month, and local use stays free and private.
One command to download and serve a model behind an OpenAI-compatible local endpoint.
Distribution and integrations create the lock-in: most agent and editor tools list Ollama first. The runtime itself is MIT and similar runners are close to it, so the moat is habit and defaults, not technology.
Main trade-off
Small default context and a minimal app leave beginners to tune memory and pick a front end themselves.
| Plan | Monthly price | What it includes |
|---|---|---|
| Pay as you go | Free | Run models locally with no usage limit; every cloud model billed per million tokens from the published table, no subscription, 3 concurrent requests, no service fees |
| Pro | $20/mo | $60 of cloud usage credits a month, access to larger pro models, 3 concurrent requests; $200 a year when billed annually |
| Max | $100/mo | $300 of cloud usage credits a month, early access to the newest models, 10 concurrent requests |
| Team (early access) | $500/mo | Unlimited users, $1,000 of cloud usage credits a month shared across the team, 10 concurrent requests, centralized billing and administration, priority support |
| Enterprise | Custom | Custom volume pricing, model access controls, cost budgets per user and API key, private Slack support channel, custom security questionnaires |
Local use is free with no cap. Cloud has no subscription floor: the $0 plan bills each request per million tokens from the model price table. Pro is $20 monthly ($200 on a yearly bill) with $60 of credits, Max $100 with $300, Team $500 for unlimited users with $1,000 shared, and Enterprise is custom. Some models cost half outside 12:00 to 18:00 UTC on weekdays and all weekend.
Ollama is an MIT-licensed runtime with about 186,700 GitHub stars that runs open-weight language models on macOS, Windows and Linux, free and with no usage cap. Larger models go to its own cloud, billed per token with no subscription needed, and a local API at localhost:11434 includes OpenAI-compatible routes.
Local model runner
Pulls a model with one command and runs it on your own CPU, Nvidia GPU, AMD Radeon GPU or Apple silicon, with no usage cap.
MLX engine on Apple silicon
On M-series Macs, supported models default to Apple's MLX framework since version 0.40; elsewhere Ollama loads GGUF files through llama.cpp.
Local REST API
Serves a native API on localhost, so scripts and apps call a local model the way they would call a hosted one, on any of the 3 desktop systems.
OpenAI and Anthropic compatibility
Exposes /v1 routes for OpenAI clients and an Anthropic-style endpoint, which lets existing SDK code switch by changing the base URL.
Ollama Cloud
Runs models too big for a laptop on Ollama servers through the same CLI and API, priced per million tokens in a published table.
Tool calling and structured output
Supports function calling, JSON-schema structured outputs, vision input and embeddings on models that offer them.
Agent and editor integrations
The docs carry setup pages for 26 tools, spanning terminal agents, code editors, desktop assistants and workflow apps.
Modelfile customization
A Modelfile sets the base model, system prompt and parameters such as context length, so a tuned variant becomes a reusable named model.
Speech models
Runs text-to-speech models such as Gradium's Phonon, which reads text aloud in 5 languages and streams audio as it is generated.
Most users expect these and they are not currently supported.
| Tool | Price from | Free plan | Runs on | Rating |
|---|---|---|---|---|
| $20/mo | Yes | Web · Mac · Windows | 4.0 | |
| -- | Yes | Web | -- | |
| $9/mo | Yes | Web | 4.0 | |
| -- | Trial | Web | -- |
MIT (runtime); each model carries its own licence
Running models on your own hardware costs nothing. Ollama Cloud starts on Pay as you go at $0 a month, where each request is billed per million tokens. Pro is $20 a month ($200 billed yearly) with $60 of usage credits, Max is $100 with $300, Team is $500 with $1,000 shared across unlimited users, and Enterprise is custom.
Yes for local use: the runtime is MIT licensed and has no usage cap. The free Pay as you go plan also opens the cloud model list, but each cloud request is paid per token, with 3 requests allowed at once. A subscription only buys a monthly credit allowance and more concurrency.
LM Studio suits people who want a desktop app for browsing and chatting with models, and its runtime builds on MLX and llama.cpp. Hosted routes such as OpenRouter or Together AI fit teams that would rather not own a GPU. Hugging Face is the better stop when you need the model hub itself.
It depends on the job. Ollama is a CLI and API first, with an MIT-licensed repository and documented setup pages for coding agents and editors. LM Studio leads with a graphical app, its own Bionic agent and chat over attached documents. Pick Ollama to give an agent a local endpoint; pick LM Studio to browse models and chat.
Install the app or the Linux script, then run one command to pull a model. The download is the slow part: the default Gemma 4 tag alone is 6.6 to 9.5 GB. You need Windows 10 22H2 or newer, macOS 14 or newer, or a current Linux distribution.
Ollama is an open-source runtime that downloads open-weight language models and runs them on your own computer, then serves them through a local API. The code is published under the MIT licence at github.com/ollama/ollama, where the project showed about 186,700 stars on 12 November 2026, and on 9 July 2026 the company announced an $88 million raise from Benchmark, Theory Ventures, 8VC and Y Combinator. It installs as a native app on macOS and Windows and as a one-line script on Linux, and a single command such as "ollama run gemma4" pulls a model and opens a chat in the terminal. The vendor's homepage reports more than 9 million installs a month.
The mechanism is simple. Ollama bundles the inference engine, a model downloader, a model library and an HTTP server into one program. Once it is running, anything on the machine can call http://localhost:11434, including through an OpenAI-compatible route at /v1 and an Anthropic-compatible route, so tools built for hosted APIs usually work after a one-line base URL change. On Apple silicon, models the MLX runtime supports run on Apple's MLX framework by default, and other models load as GGUF files through llama.cpp. The default context window depends on memory: 4k tokens under 24 GiB of VRAM, 32k from 24 to 48 GiB and 256k at 48 GiB or more, which is why coding agents are told to raise it to at least 64k. Nvidia GPUs, AMD Radeon cards and Apple silicon are supported, and Intel Macs run on CPU only.
Ollama also runs its own paid cloud. Models too large for a laptop, such as Kimi K3, GLM 5.3, DeepSeek V4 Pro and Mistral Large 4, run on Ollama's servers through the same CLI and API. Every cloud model carries a published price per million tokens: the free Pay as you go plan bills each request from that table with no subscription, and the paid plans add a monthly credit allowance on top. Ollama says it keeps no log of what you send its cloud and trains nothing on it, and that it hosts mainly in the United States. Smaller models such as Gemma 4 run locally with no usage limit and no account.
The integrations page lists 26 tools, mostly coding agents and editors: Claude Code, OpenCode, Cline, Codex CLI, VS Code, JetBrains, Zed and Xcode, plus the assistants OpenClaw and Hermes Agent, the automation tool n8n, and Claude Desktop and ChatGPT Desktop as gateway clients. The "ollama launch" command sets up a coding agent against a local or cloud model with no config file to edit. Frameworks such as LangChain and LlamaIndex also ship Ollama connectors. For model picks by hardware, start with our guide to the best AI models for local coding, and for the desktop rival head to head, read Ollama vs LM Studio.
Where the alternatives win: LM Studio is the easier first step for someone who wants a model browser and a chat window that reads attached PDF and Word files, and Jan is an open-source desktop chat app for the same offline use. llama.cpp gives finer control over how a model splits across graphics and system memory, for people happy at a command line. vLLM, a serving library built for many users on GPU servers, fits a team endpoint better than a laptop. Hosted routes such as OpenRouter, Together AI or the Hugging Face hub suit anyone who would rather not own the hardware.
Ollama is a command-line and API product first. The desktop app is a thin chat window, not a full workspace with document libraries or visual model management, so anyone who wants a point-and-click interface needs a separate front end such as Open WebUI. Quality also depends entirely on the model you pull and the memory you have: a model that does not fit in graphics memory spills to the processor and slows down. On 12 November 2026 Ollama's public library page for Gemma 4 listed the default tag that "ollama run gemma4" pulls as a 6.6 to 9.5 GB download with a 128K context window, and the 31B tag at 19 GB or more, so a laptop's memory, not the app, decides which tag is usable.
Product facts on this page (pricing, plans, integrations, compliance) are read from Ollama's own pages and documentation. The verdict is Hokai's reading of them, not the vendor's claim.