Best open-source LLMs in 2026: ranked by cost to run

At CloudZero, Bill Buckley, our SVP of Engineering, gives every engineer a $5,000 monthly AI token budget and published the math behind it. His admission in that post applies to every model decision in this article: “nobody knows what the right number is.”

Every company running that experiment eventually asks the same follow-up: could open weights make the number smaller? The weights are free to download. The question is what they cost to run, and that answer has three different shapes depending on how you deploy them.

That’s the question this guide prices. We’re the AI ROI company: we don’t host models, rent GPUs, or run a leaderboard, so we have no lane to sell you. We measure what AI spend returns, whether it arrives as a per-token invoice or a GPU bill, and this ranking runs on the question the leaderboards can’t answer: which open-source LLM is best for the check you’ll actually write?

Open-source is a cost question wearing a technical costume

“Free weights” is the most expensive free in software, so someone in finance is now asking why you’re paying API rates when Llama is free. The weights cost nothing; running them costs GPU hours, serving infrastructure, and an operations tail, so the honest comparison is never model versus model. It’s lane versus lane.

You’ve got exactly three ways to run open weight models, and every option in this article lives in one of them:

Before any vendor math, one prerequisite: know what you currently spend per unit of AI work across APIs, GPUs, and the tooling around them. If nobody can produce that number today, a free cloud cost assessment gets you the baseline faster than any pricing page will.

What are the best open-source LLMs in 2026?

These eight families are the durable layer of the best open-source LLM question. Version checkpoints churn roughly monthly in this market; the leaderboard will have changed by the time you finish reading this article. So anchor decisions on family, license, and economics, and read the checkpoint column as a snapshot:

Two columns in that table matter more than the benchmark scores that usually headline these rankings. The license column is the first thing legal asks: MIT and Apache 2.0 deploy commercially with zero royalties, while the conditional licenses (Qwen’s Max tier, Kimi K3) need a careful read if your product resells inference, and Llama’s 700M-MAU cap plus its EU multimodal exclusion still decide real architectures in Europe.

The cost-signal column is the rest of this article. A model’s benchmark rank tells you what it can do; its parameter count, license, and serving footprint tell you what it costs to let it do that.

Vendor benchmarks are release notes, not referee calls. And the perennial Llama vs DeepSeek matchup mostly resolves by lane: Scout if you’re self-hosting on a single GPU, V4 if you’re buying serverless reasoning.

Open-source LLM leaderboards: inputs, not verdicts

On leaderboards specifically: leaderboards are useful inputs and terrible verdicts. And they come with a structural conflict worth naming: the popular ones are published by companies selling eval tooling, serverless hosting, or self-host infrastructure, so most leaderboards in this category are run by someone with a model in the race. Whichever model wins, they’d like to run it for you.

The scores themselves have limits too: they shift between eval harnesses, checkpoints ship monthly, and the top slot has changed hands repeatedly this year.

There’s also a structural mismatch: leaderboards measure quality per prompt, while your budget runs on cost per unit of work, and the two rankings rarely agree. A model two points down the board at a tenth the serving cost wins almost every production argument. Use leaderboards to build a shortlist of two or three families, then let your own eval and your own economics pick the winner.

What changed in 2026

Three shifts this year reset the open-model math. The top of the leaderboard turned over repeatedly, with GLM’s latest checkpoints taking the top open-model slot in recent coverage and DeepSeek, Qwen, and Kimi trading places beneath it.

Serverless open-model pricing compressed toward DeepSeek V4-Flash’s reported $0.14 per million input tokens, pulling the cheapest lane’s floor down with it. And licensing became a first-order architecture decision: OpenAI’s gpt-oss models arrived under Apache 2.0, GLM’s threshold license made a frontier coding model effectively permissive, and Llama 4’s EU multimodal exclusion started deciding real European deployments.

Serverless, self-hosted, or local: what each lane costs

Serverless open-model APIs: the default starting lane

Serverless open-model APIs are where most teams should start: per-token pricing on open-model rates that undercut frontier APIs by an order of magnitude, no infrastructure, and checkpoints updated for you.

DeepSeek V4-Flash lists at $0.14 input and $0.28 output per million tokens at standard peak rates, and off-peak and cache-hit pricing go lower; our DeepSeek pricing breakdown covers the family’s full rate card, and OpenAI-class frontier rates are the comparison those numbers embarrass. Two rate-card details worth reading before you standardize: cache-hit pricing can cut the input bill sharply on workloads that repeat long prompts, and gpt-oss-120B currently posts some of the lowest output pricing on serverless hosts, which matters for generation-heavy work.

Self-hosting costs: the GPU math

Self-hosting trades per-token bills for per-hour ones. Our H100 cost breakdown puts on-demand H100s at $2.89 to $6.98 per GPU-hour depending on provider, with a September 2026 median of $3.25. Use $3.99 per hour, roughly $2,900 a month per GPU, as a conservative planning number; the full cloud GPU pricing comparison maps the provider landscape.

Llama 4 Scout on a single H100 is the cheapest option here that holds up on real work.

At the other end, the biggest DeepSeek, Qwen, Kimi, and GLM tiers need 8×H100-class clusters, which our published rates put at $49.24 to $55.04 per hour, roughly $36,000 to $40,000 a month before anything answers a prompt. And a self-hosted deployment bills you at 3 a.m. whether it’s answering anything or not, which is why utilization, not benchmark rank, decides whether this lane ever pays.

The GPU invoice also isn’t the whole invoice. Self-hosting carries an operations tail the pricing pages skip: a serving stack to run and patch, checkpoint upgrades to test and roll out, monitoring, and someone on call when inference falls over at peak. None of it appears in dollars per hour, and all of it appears in your real cost per token.

Best local LLM: what to run on your own hardware

Local hardware is the third lane, and the honest answer for local deployment: Gemma 4’s consumer-GPU sizes deliver the strongest quality on a single card you may already own, with Qwen’s 27B-class checkpoints close behind. To run a model locally, Ollama and LM Studio make it a one-command affair, and vLLM handles the serious serving.

One technical detail with budget consequences: quantization. BF16 weights cost about 2 bytes per parameter of memory, FP8 about 1, and 4-bit-class builds roughly 0.55, which is how a bigger model sometimes fits a smaller GPU, and how the download size of a 2.8-trillion-parameter model lands near 1.5 TB, a bit over a quarter of its 5.6 TB naive weight.

For development and small internal tools, local is effectively free after the hardware; the mistake is promoting a local prototype to production traffic without repricing it in one of the first two lanes.

Self-hosting breakeven: the open-source LLM comparison nobody runs

Here is the comparison: what each lane costs per month at real token volumes, using Q4 2026 rates, a 3:1 input-to-output blend, and our own published GPU numbers.

Two crossovers fall out of that table, and both land far from where the folklore puts them. Against frontier proprietary APIs, a single-GPU self-host breaks even near 850 million tokens a month under these assumptions. Against serverless open-model rates, it doesn’t break even until roughly 17 billion tokens a month, a volume most companies never see outside their top workload.

Some breakeven estimates put self-hosting ahead at around 50 million tokens a month. That number only works if you ignore utilization. Run that arithmetic yourself and the figure only survives with much pricier reference APIs, multi-model consolidation, or labor counted creatively. The general lesson is our build-vs-buy thesis applied to models: the crossover exists, it’s real, and it’s almost always further out than the pitch deck says.

Privacy, latency, and fine-tuning rights are all legitimate reasons to self-host below the breakeven, and sovereignty is increasingly the decisive one: European organizations reportedly run national AI workloads on European-controlled infrastructure precisely because the data can’t leave, whatever the per-token math says. Buy them with your eyes open, priced in dollars per month, instead of discovering them in the inference economics postmortem.

Your variables will move these numbers: committed-use GPU discounts, batch inference, cache-hit pricing on repeated prompts, and utilization above all. A GPU at 20% utilization quintuples your effective per-token cost, which no leaderboard will ever mention.

The best open-source LLM for coding

For coding work specifically: GLM-5.3 and Kimi’s current checkpoint lead the open coding benchmarks, with DeepSeek V4-Pro strongest on agentic, terminal-style coding tasks and V4-Flash the budget pick for high-volume code generation.

Coding is also where 2026’s loudest open-model receipts live, and two are named and specific. Vercel’s v0 team, working with Fireworks AI, reported an error-free code generation rate of about 93% for its composite model after reinforcement-tuning an open model for the auto-fix step. In the same evaluation, Vercel CTO Malte Ubl said Sonnet 3.5 compiled at 62%, and that the tuned model performs “substantially better than SOTA.” Fireworks published the case study in November 2025.

Cursor reported roughly 1,000 tokens per second on a tuned open 70B model for its speculative-edits pipeline, about a 9x speedup over its previous GPT-4 speculative-edits deployment, published in May 2024. Both predate the current checkpoint generation, so treat them as evidence that the pattern works rather than as current benchmarks.

The pattern that keeps repeating: a mid-size open model tuned on your data beats a giant generalist on your workload, at a fraction of the per-token cost.

Fine-tuning is also the quiet fourth reason to choose open weights at all: you can own the tuned model. Closed APIs rent you improvement; open weights let you bank it, which changes the long-run math for any workload stable enough to train on. The training run itself is a one-time cost worth pricing next to the monthly serving bill before you commit.

Where this hits a real budget: coding assistants and agents are the highest-volume token consumers in most engineering orgs, which is why per-engineer AI budgets became a discipline, and why Bill’s $5,000-per-engineer program exists in the first place. The same logic governs open-model coding stacks: give the spend a per-engineer denominator and watch cost per unit of work, not the sticker.

The CloudZero lens: free weights, expensive electrons

All three lanes end in the same place: an invoice that no longer says which team, product, or workload spent it. Per-token bills fragment across providers; GPU bills are worse, because a GPU-hour is the least self-explanatory line item in cloud billing, and an idle cluster costs the same as a productive one.

Mechanically, that’s the problem we build for. Serverless open-model invoices land through AnyCost custom sources, GPU spend arrives with your cloud bill, workload context flows in through the telemetry streams API, and all of it resolves into one financial control plane beside the rest of your AI spend, allocated to the teams and features that used it.

Two numbers decide whether your open-model deployment is working, and neither appears on any invoice. Effective cost per million tokens, self-hosted, is your GPU bill divided by tokens actually served, and it’s routinely 3 to 5x the theoretical rate, which is what utilization between roughly 20% and 33% does to the math. Utilization itself is the second: finance sees a flat $2,900, engineering sees a busy dashboard, and nobody sees that the cluster idles nights and weekends unless something is measuring it.

That measurement muscle is buildable, and AI-native companies build it at scale: Upstart, an AI lending platform, used CloudZero to cut $20 million in cloud costs, and model workloads are exactly the spend category where that discipline pays fastest.

The breakeven table is a planning estimate; your actual cost per million tokens, at your real utilization, is a number you can only get by measuring, and it’s the number that tells you when to switch lanes. If you’d rather see that with your own workloads than read about it, that’s what a demo is for.

That’s the specific gap this category creates, and it’s why whether AI spend returns anything stays a live question long after the model choice is made. Open models don’t get an exemption just because the weights were free; rates and checkpoints also move fast enough that we track them continuously in our 150+ AI statistics library, so whatever you deploy, diary a quarterly rate check.

How to choose in five steps

The selection method that survives contact with this market, in order:

Frequently asked questions about open-source LLMs

Author Spotlight

Lyne Carolyne

Lyne Carolyne has several years of experience in AI and cloud economics and brings that understanding into the content she creates. Outside work, she's an avid explorer.