Open-weight LLMs for coding in 2026: hardware and real costs

Choosing an open-weight LLM (large language model) for coding in 2026 starts from one concrete stake. The two paths, self-hosting a top-tier open model on an eight-H100 node and subscribing to a frontier proprietary coding agent, cost about $19,000 per month and roughly $200 per month, respectively; one rented node equates to 95 subscriptions. The rest of the decision involves three questions that usually get answered in the wrong order: which model, on what hardware, at what cost. The model question gets all the attention; the hardware and cost questions decide whether you should be self-hosting at all.

House rules apply doubly here: these are collected results, not my runs, every number links to its source, checked on 2026-07-04. This is a living page; the changelog at the bottom tracks revisions, because most numbers in this field change within a quarter.

The open-weight coding field, July 2026

Verified directly on Hugging Face this week:

Model	Total params	Org	Notes
Kimi K2.7-Code	1.1T (MoE)	Moonshot	code-specialized, released ~June 2026
DeepSeek-V4 Pro	862B	DeepSeek	+ V4 Flash at 158B
GLM-5.2	753B	Z.ai	FP8 variant has 1.26M downloads
DeepSeek-V4 Flash	158B	DeepSeek	the “small” frontier option
Qwen-AgentWorld-35B-A3B	35B (3B active)	Alibaba	agent-tuned, consumer-GPU class

On benchmarks, third-party roundups (kilo.ai’s compilation, checked today) report GLM-5-series posting 77.8% on SWE-bench Verified, the strongest open-weight result, with GLM-5.2 leading open models on SWE-bench Pro (62.1) and MiniMax M3 (June 2026) topping open-weight SWE-bench Pro among agentic models at 59.0 with a 1M context. Treat compiled numbers as directional: I could not verify them against a first-party eval harness today, and different roundups disagree on decimals.

A cautionary data point on leaderboards generally: the aider polyglot leaderboard, long the most practically useful coding benchmark, still shows a GPT-5-era top list with DeepSeek-V3.2 as the best open entry (74.2%), visibly behind the current release cycle, which shows how fast even a good benchmark falls behind. Whatever you read, including this page, is worth checking against its as-of date before you believe it.

The honest summary of the frontier gap: open-weight models in 2026 sit roughly one product cycle behind the best proprietary agents on hard agentic coding. They are close enough to be genuinely useful; far enough, however, that you should have a reason (cost structure, privacy, fine-tuning, research) for choosing them over a subscription agent for daily work.

The VRAM math

The VRAM (video random access memory) that a model’s weights occupy is plain arithmetic:

VRAM for weights ≈ total params × bytes per weight
  FP16/BF16:  2.0  bytes/param
  FP8:        1.0  bytes/param
  ~4-bit (Q4/AWQ/GPTQ): ≈ 0.55-0.6 bytes/param

Plus KV cache + runtime overhead: budget another 10-30%,
growing with context length and batch size.

In that table, FP8 (8-bit floating point) halves the weight bytes relative to FP16, and AWQ (activation-aware weight quantization) and GPTQ (post-training quantization for generative pre-trained transformers) are the two common routes to ~4-bit weights.

The MoE nuance that causes the most confusion: for mixture-of-experts models, total parameters determine memory, active parameters determine speed. A “35B-A3B” model needs ~35B params’ worth of memory but runs about as fast as a 3B dense model. A 1.1T-total MoE like Kimi K2.7 must hold 1.1T params somewhere, even though only a fraction fire per token.

Worked examples against the current field:

Model class	Q4 weights	Fits on
35B MoE (Qwen-AgentWorld class)	~20 GB	one RTX 4090 (24 GB), comfortably one 5090 (32 GB)
158B (DeepSeek-V4 Flash)	~90 GB	2× A100/H100 80GB, or 4× 4090, or 128GB+ unified-memory Mac
753B (GLM-5.2)	~420 GB	8× H100 node territory (FP8: ~750 GB → same, tighter)
1.1T (Kimi K2.7-Code)	~600 GB	multi-node or 8× H200/B200

The field therefore splits cleanly: one genuinely consumer-class tier (≤~40B), one “small cluster or big Mac” tier (~160B), and a top tier that requires data-center hardware.

What the hardware actually costs

Rental first, because it’s the honest baseline. RunPod’s posted prices today (community cloud, dedicated pods):

GPU	$/hr	24/7 month
RTX 4090 24GB	$0.69	~$500
RTX 5090 32GB	$0.99	~$715
A100 80GB PCIe	$1.39	~$1,000
H100 80GB SXM	$3.29	~$2,370
H200 140GB	$4.39	~$3,160
B200 180GB	$5.89	~$4,240

Run the multiplication for the tiers above:

• 35B class: one 4090 → ~$0.69/hr rented, i.e. ~$500/month at 24/7. Compare that against whatever a card costs you locally: at this rental rate an owned GPU pays for itself within a few months of sustained use, the one tier where buying the hardware makes straightforward economic sense.
• 158B class: 2× H100 ≈ $6.60/hr ≈ $4,700/mo around the clock, or ~$2/hr on paired A100s if latency tolerance allows.
• 753B-1.1T class: 8× H100 ≈ $26/hr ≈ $19,000/mo. At this tier you are operating infrastructure, with everything that implies.

Set these rates, in contrast, against subscription pricing, the stake from the opening paragraph: a frontier proprietary coding-agent subscription costs on the order of $20 to $200 per month. The 158B self-hosted tier costs 20-200× that. For an individual developer’s interactive coding, self-hosting a frontier-competitive open model loses on pure economics by one to two orders of magnitude.

When self-hosting wins

Four cases, in descending order of how often I see them hold up:

1. Privacy/compliance is non-negotiable. Code that cannot leave the building makes the API comparison moot. This is the dominant legitimate driver, and it’s why the FP8 GLM downloads number in the millions.
2. Batch throughput, not interactivity. If you’re running pipeline-style workloads (bulk classification, generation, migration), a saturated GPU’s cost-per-token collapses, and rented spot capacity beats per-token API pricing at sufficient volume. Do the arithmetic for your volume; the crossover is real but higher than people assume.
3. Fine-tuning/research. You can’t LoRA a proprietary agent’s base model. If the weights themselves are the point, open-weight is the only option.
4. The 24GB consumer tier. One owned 4090/5090 running a 35B-A3B class model is cheap enough ($0 marginal) that “worse than frontier but free and private” is a perfectly sound daily tool for completion, drafting, and offline work, just keep a verification loop around it, because the error rate is real.

The anti-case, stated plainly: self-hosting a 750B-class model to replace a $100/month subscription is better understood as a hobby than a cost-saving measure. It can be a worthwhile hobby, as long as it is budgeted as one.

How to re-run this analysis when the field shifts

The numbers on this page will go stale; the method for re-checking them will not. When the next model is released:

1. Get total + active params from the actual HF model card
   (not the announcement tweet)
2. Weights VRAM = total × bytes/weight for your quant; +20% overhead
3. Map to the cheapest GPU config that fits (rental prices above)
4. Find a benchmark WITH a date newer than the model, ideally two
   independent ones; distrust single-source deltas under ~5 points
5. Compare monthly self-host cost vs your actual API/subscription
   spend, at your real duty cycle rather than a 24/7 assumption

Step 5 is where most self-hosting plans fail, and it’s a five-minute calculation. Do it before ordering hardware.

---

Changelog: 2026-07-06: second register pass (removed bolded mic-drop short sentences, added patient connectives, de-idiomed, sourced the subscription-price anchor). 2026-07-05: register pass (stake moved into the opener, VRAM/FP8/AWQ/GPTQ expanded, phrasing aligned with house style; no factual changes). 2026-07-04: first published (model field + prices as of this date).