Price-performance rankings for open-weight models

Choosing the right open-weight model is a trade-off between inference cost and task quality. These price-performance open-weight models rankings reflect what we’ve seen shipping production workloads across hundreds of millions of tokens, not synthetic leaderboards. Below we rank the most deployable open weights by where they sit on the cost-quality curve, with notes on where each breaks down.

1. Llama 3.1 8B

For most classification, extraction, and lightweight RAG tasks, Llama 3.1 8B is the default pick. It runs on a single 24GB consumer GPU at usable batch sizes, and hosted pricing is typically the lowest tier among capable instruction-tuned models—often under $0.20 per million input tokens on commodity providers. If you already own the hardware, the marginal cost is just electricity and amortized capital.

The quality gap versus 70B-class models is real on nuanced reasoning, but for structured output with a strict schema it is surprisingly close. We routinely use it behind a JSON mode guard and a retry loop, and the effective throughput on a single A10G beats any larger model on price per valid response.

from openai import OpenAI

client = OpenAI(base_url="https://api.n4n.ai/v1", api_key="sk-...")

resp = client.chat.completions.create(
    model="meta-llama/llama-3.1-8b-instruct",
    messages=[{"role": "user", "content": "Extract name and date from: ..."}],
    response_format={"type": "json_object"},
    extra_body={"route": {"fallback": True}}
)

Where it fails is long-horizon agentic loops. If the task needs more than two tool calls with state, bump up a tier. But for the 80% of enterprise NLP that is “parse this and return keys,” this is the best absolute price-performance open-weight model.

2. Mixtral 8x7B

Mixtral 8x7B was the previous generation’s sweet spot and still holds up. Its sparse expert architecture gives 47B total parameters but only ~13B active per token, so latency and cost land between dense 7B and 34B models. Public hosted rates usually put it around $0.24–$0.30 per million tokens for both input and output—slightly above Llama 8B but with better multilingual and code synthesis.

For middleware that rewrites prompts or does multi-step tool calling, we prefer it over 8B when the trace length grows. It handles 32K contexts without the sharp quality drop you see in Llama 8B at scale. The model responds well to explicit few-shot formatting; keep the system prompt tight because it loses coherence with verbose instructions.

{
  "model": "mistralai/mixtral-8x7b-instruct-v0.1",
  "route": {"prefer_provider": "any", "fallback": true},
  "cache_control": {"type": "ephemeral"}
}

One operational note: because it is MoE, batching matters less for compute but more for memory bandwidth. On shared endpoints you may see higher variance in tail latency than with dense models. Budget for that in SLOs.

3. Qwen2.5 7B and 14B

Alibaba’s Qwen2.5 series is aggressively competitive on price-performance open-weight models, especially for non-English workloads. The 7B variant matches Llama 8B on Chinese and code, and the 14B closes much of the gap to 34B-class Western models at a fraction of the cost. Hosted 14B typically prices near Llama 8B but delivers noticeably better long-context retention up to 32K tokens.

We’ve used Qwen2.5-14B for log summarization where the input is large but the output is tiny—ideal for per-token input cost sensitivity. It also has a native function-calling fine-tune that is more reliable than base Instruct with ad-hoc schemas. A quick cost estimate script helps when comparing tiers:

def cost_per_1k_output(price_per_m, input_tokens, output_tokens):
    return (input_tokens + output_tokens) / 1_000_000 * price_per_m

# Qwen2.5-14B at ~$0.15/M mixed
print(cost_per_1k_output(0.15, 8000, 200))  # ~$0.00123 per call

If your product ships outside the US/EU, this family should be on your shortlist. The 7B is a drop-in upgrade from Llama 8B for almost zero extra spend.

4. Llama 3.1 70B

When you need reliable agentic behavior without jumping to frontier pricing, Llama 3.1 70B is the workhorse. It handles multi-turn tool use and complex JSON nesting far better than 8B, and hosted rates commonly sit between $0.50 and $0.90 per million tokens depending on region and batch. The break-even versus smaller models is task-dependent.

If a 8B model needs three retries to get valid output, the 70B single-shot often wins on total spend. We measure this with per-token metering rather than list price, because provider efficiency varies wildly. A gateway that honors client routing directives—like n4n.ai—lets you pin Llama 70B on a cheap provider and auto-fallback when rate-limited, preserving the effective price-performance open-weight models economics.

Quantize to 4-bit AWQ if self-hosting; you lose <2% on MMLU-style probes but cut VRAM to 40GB. That makes single-node deployment realistic for most teams.

5. Qwen2.5 72B

Qwen2.5 72B is the sleeper hit for teams that need near-frontier quality on math and coding at open-weight prices. It outperforms Llama 70B on several multilingual benchmarks and is competitive on English reasoning. Cost is similar to Llama 70B but sometimes lower on Asian cloud providers, and the 128K context is genuinely usable.

If your traffic is global, route-aware inference cuts tail latency. We’ve seen it replace closed models for internal analytics copilots with no complaint from users. The only downside is that 72B dense weights are heavy to self-host (need 2x80GB or aggressive quantization), so most shops run it hosted.

curl https://api.n4n.ai/v1/chat/completions \
  -H "Authorization: Bearer $KEY" \
  -d '{"model":"qwen/qwen2.5-72b-instruct","messages":[{"role":"user","content":"Solve: integral of x^2"}]}'

6. DeepSeek V3

DeepSeek V3 (671B total, 37B active) rewrote the price-performance open-weight models conversation in late 2024. Hosted pricing is absurdly low for its capability—often below $0.30 per million input and $0.50 per million output on launch providers—because of its MoE design and subsidized rollout. It is not a toy.

For RAG over technical docs and medium-complexity codegen, it beats Llama 405B on many practical axes while costing 10x less per token. The catch is self-hosting requires serious GPU memory; treat it as a hosted-only option unless you have a cluster. We route to it when a task needs frontier-level reasoning but the budget is fixed at open-weight rates.

# compare effective cost for a 10K in / 2K out call
models = {
    "deepseek-v3": 0.30,   # $/M in
    "llama-405b": 3.50,    # $/M out approx
}
cost = 10000/1e6*0.30 + 2000/1e6*0.50

7. Llama 3.1 405B

At the top of open weights sits Llama 3.1 405B. It is the only open model that can mimic frontier-level nuance in long-form generation, but the price scales accordingly: typical hosted rates exceed $3–$5 per million output tokens. We reserve it for eval harnesses and occasional high-stakes drafting.

For continuous production, the price-performance open-weight models curve favors the 70B or DeepSeek V3 unless your quality bar is non-negotiable. If you must self-host, plan for 8x80GB GPUs and pipeline parallelism. Even then, tokens/sec per dollar trails smaller models by an order of magnitude.

Synthesis

The rankings are not static; provider competition shifts hosted rates weekly. The durable lesson is to map model size to task complexity and measure total cost including retries, not just sticker price. Use metering to find where small models silently cost more via failures.

Pick the smallest model that meets the accuracy SLA, then enforce it with routing and metering. That is how you extract maximum value from price-performance open-weight models in production.