Skip to content
How-to Beginner 30 min read by Rajat Jain Updated August 13, 2026

How to Choose an Open-Weight Model for Your Use Case

License, VRAM, context, coding vs general, price per token - the five decisions that pick the right open-weight model, with a comparison table you can sort.

Note

Model facts and prices verified against official model cards and rate cards - DeepSeek, Qwen, Moonshot, Mistral and Meta records as cross-checked in our open-weight hub (published 11-12 August 2026); the hub page and pricing reconciliation were re-read 13 August 2026.

Before you start

  • A rough idea of your job: chat, coding, long documents, or agent loops
  • Know your hardware budget - RAM/VRAM if self-hosting, or an API budget per month
  • 10 minutes, and permission to change your mind as the field moves monthly
Jump to section
  1. 1

    Start with the job, not the benchmark

    Name the workload - daily chat, coding edits, long-context analysis, or agent loops. The field splits along exactly these lines.

  2. 2

    Decide self-host vs API

    Your hardware is the hard constraint: if you can't fit the weights in RAM/VRAM with headroom, the API is the answer regardless of preference.

  3. 3

    Check the license before you build

    MIT, Apache-2.0, and Llama's community license have different terms for re-licensing and fine-tune distribution. One row in the table decides whether your product ships.

  4. 4

    Match context to your documents

    1M-token context is the 2026 floor for serious work, but long context costs memory and latency. Size it to your real inputs.

  5. 5

    Price per token, honestly

    Use official rate cards with cache terms stated - tracker numbers blend cache-hit and miss prices and differ by 10-50x on the same model.

  6. 6

    Run a 24-hour trial before you commit

    Put the shortlist through your real workload with identical prompts. Benchmarks decide the shortlist; your logs decide the winner.

The 2026 open-weight field is a five-model race with wildly different prices, licenses, and hardware needs - and almost every comparison you read online gets at least one number wrong. This guide turns model choice into five decisions you can actually make: license, hardware, context, workload, and price per token. The comparison table below is the same one from our open-weight coding hub, built from official model cards and rate cards.

Step 1: Start with the job, not the benchmark

The field splits cleanly by workload:

  • Daily chat, Q&A, writing - almost anything works. Pick on price and privacy.
  • Coding edits, test loops, agent work - agentic benchmarks (Terminal-Bench 2.1) matter; the explainer shows why 82.7 means what it means.
  • Long documents, big repos - context length and long-context economics dominate.
  • Local privacy-first - your hardware becomes the filter before anything else.

Write your workload in one sentence before looking at numbers. Every subsequent decision is easier with that sentence on the table.

Step 2: Decide self-host vs API

The hardware question is unforgiving. Here’s what the field actually costs to host (weights only - add 10-15% headroom and KV cache on top):

ModelWeights footprintRealistic hosting
DeepSeek V4-Flash-0731~160GB INT4 (official estimate)2x80GB or 192GB class for the good tiers
Qwen3.8-Max418GB BF16 / ~218GB quantizedcluster territory
Kimi K3largest open weights ever (2.8T total)cluster territory
GLM-5.2753B totalcluster territory
Llama 4 Maverick404B totalcluster territory
8B-class model (Gemma 4, Qwen3)5-10GB quantizedany laptop with 16GB RAM

The VRAM reality guide walks the full math for the popular one. The pattern: if your hardware can’t fit the weights, the API is the correct answer - not a compromise.

The hardware-first shortcut

One 80GB GPU: skip the five-model field entirely; run an 8B-27B class model locally (a 27B at 17GB is the sweet spot) and use APIs for the heavy stuff. 2x80GB: DeepSeek V4-Flash 3-bit tier is viable. 192GB+: you can host the 4-bit tier of the flagship open models.

Step 3: Check the license before you build

License differences are real and specific:

  • DeepSeek V4-Flash-0731 - MIT (with an attribution clause above 100M monthly users)
  • Qwen3.8-Max - Apache-2.0, the friendliest for re-licensing and fine-tune distribution
  • GLM-5.2 - MIT
  • Kimi K3 - Kimi K3 custom license
  • Llama 4 Maverick - Llama 4 Community license

One practical test: can your product redistribute a fine-tune of the model? Apache-2.0 and MIT say yes with minimal strings; the custom licenses need reading. This decision is a permanent one - switch costs are real - so make it first.

Step 4: Match context to your actual inputs

The 2026 floor is 1M-token context for serious agentic work, and all five frontier models ship it. But context costs: every token of context occupies memory (the KV cache grows with prompt length) and slows prefill. Size it to your real inputs - a 1M-token context you never use is wasted VRAM. Qwen3.8-Max extends to 4M via TokenBox if your problem genuinely needs it.

Step 5: Price per token, honestly

Official rate cards, with cache terms stated (all figures per 1M tokens, as reconciled in the pricing article). Click a header to sort:

ModelInput (miss)Cache hitOutputLicense
DeepSeek V4-Flash-0731$0.14$0.0028$0.28MIT
Qwen3.8-Max$2.11 (CNY card converted)not published$6.33Apache-2.0
GLM-5.2 (Mistral-hosted)$1.40$0.26$4.40MIT
Kimi K3$3.00$0.30$15.00Kimi custom
Llama 4 Maverickno first-party API tier--Llama Community

Two warnings the trackers won’t give you: DeepSeek’s cache-hit price is 50x below its miss price - any comparison that blends them is meaningless - and DeepSeek has announced a significant price increase coming, so the current card is the low-water mark.

If two sites disagree, the rate card wins

Artificial Analysis, orcarouter and eesel all publish different numbers for the same models this week - on price and benchmark index. The official model card and official pricing page are ground truth; trackers are directional. That rule is the whole method of our hub.

Step 6: Run a 24-hour trial

Benchmarks decide the shortlist; your logs decide the winner. Run the top two candidates against your real workload - same prompts, same evaluation. For API models this costs a few dollars at open-weight prices; for local models it costs disk space and an evening. The model that wins your logs is the model you keep, regardless of leaderboard position.

All figures sourced

This guide’s numbers are the ones our hub verified against official cards: DeepSeek’s rate card at $0.14/$0.28, Qwen’s CNY official tariff, Mistral’s GLM-5.2 hosting, and the official weights and licenses on each model card. See the hub article for per-model source links.

How to verify your choice is right

The 24-hour trial checklist, in order:

# 1. Run your 3 most common tasks with identical prompts on both candidates
#    (same conversation twice - one per model - and keep the transcripts)

# 2. For API models: log spend per task, cache-hit vs miss
# 3. For local models: confirm load with `ollama ps` (GPU, not 100% CPU)
# 4. Count errors and re-prompts per task - not tokens, not vibes

If the cheaper model’s error rate stays within your tolerance, the trial says what the benchmarks already hinted: price-quality wins in the open-weight field.

When the answer is “none of these”

If your workload is chat-grade and your hardware is a laptop, the five-model field is wrong for you - a 17GB-class local model or an API subscription serves you better than a 284B model you can’t run. And if your constraint is privacy first, start from this guide and size downward until the weights fit. The right model is the one that runs, that you can ship with, and that fits the budget - in that order.

Questions, answered first

What's the difference between total and active parameters?

Active parameters are the ones computed per token in a mixture-of-experts model. DeepSeek V4-Flash is 284B total but only 13B active - that's why its per-token serving cost is tiny despite being a huge model. Total size decides how much memory you need; active size decides speed and per-token cost.

Is Apache-2.0 better than MIT for commercial use?

Both are permissive and commercial-friendly. Apache-2.0 is friendlier for fine-tune redistribution and patent protection; MIT is the most minimal. DeepSeek's MIT carries an attribution clause for deployments above 100M monthly users. Neither blocks the normal run, fine-tune, sell stack - but read the exact license text for your product.

Why do trackers give different prices for the same model?

Three known mechanisms: cache blending (DeepSeek's official spread is 50x between cache-hit and cache-miss input prices), effort labels treated as separate models, and currency rounding (Qwen's card is CNY-only). Our pricing reconciliation quotes the official rate cards with cache terms in the same row.

Do I need a 2.4T-parameter model for everyday coding?

Almost never. The field's price-quality answer for high-volume coding is DeepSeek V4-Flash-0731 at $0.14/$0.28 per million tokens - roughly 15x cheaper than Qwen3.8-Max on input. The big sparse MoEs win long-horizon refactors and 1M-token codebases; for ordinary edits and test loops, the cheap model is the right model.

I only have 16GB of RAM. Is local open-weight a realistic option?

Yes, with the right expectations: you're in the 7-14B model class (quantized), not the 284B class. An 8B-class model at 4-bit fits in ~6-10GB and handles daily Q&A and editing well. Anything labeled 'frontier-grade' in this field needs 100GB+ - run those on the API instead.

You did it

  • You can name your primary workload in one sentence
  • You checked the license row against your product's licensing needs
  • You know whether your hardware fits the model - or you chose the API
  • You read the price from an official rate card, not a tracker
  • You verified the context length matches your longest document
  • You ran the shortlist on a real task before committing
Official sources