The Best Coding Model Is Also the Cheapest, Which Almost Never Happens

Every model, side by side

Prices are US dollars per million tokens. The benchmark column is Terminal-Bench v2.1, the agentic-coding test most of the open-weight labs now report against. Anthropic and OpenAI do not publish scores on it, so those cells are blank rather than guessed — see the FAQ for why that matters.

Model	Input	Output	Terminal-Bench v2.1	Weights
DeepSeek V4.1 Flash	$0.30 $0.15 off-peak	$1.20 $0.60 off-peak	90.6	Open
Kimi K3	$3.00 $0.30 cache hit	$15.00	88.3	Open
GLM-5.3	$1.40 $0.26 cached	$4.40	88.2	Open
Qwen 3.8 Max	$2.00	$6.00	86.6	Open
GLM-5.2	$1.40	$4.40	81.0	Open
Reflection Beam	Self-host	Self-host	80.1	Apache 2.0
Claude Opus 5.5	$4.00	$20.00	not published	Closed
Claude Opus 5	$5.00	$25.00	not published	Closed
Claude Sonnet 5.5	$2.00	$10.00	not published	Closed
GPT-6.1 Sol	$2.00	$10.00	not published	Closed
GPT-6 Luna	$0.10	$0.50	not published	Closed
Claude Haiku 5.5	$0.10	$0.50	not published	Closed

What 1,000 agent attempts actually costs

Per-token prices hide the thing that decides your bill, which is that agentic coding retries. A single run of a real task is rarely one call — it is a loop that reads, edits, tests, fails and tries again. So the number worth computing is cost per attempt, multiplied by how many attempts you will really make.

The table below models 1,000 agent attempts at 10,000 input and 25,000 output tokens each. The 25,000 figure is not arbitrary: it is the mean generated length Reflection reported for Terminal-Bench attempts, which makes it a defensible stand-in for one agentic coding task. This is arithmetic over verified prices, not a measurement — your own token profile will differ, and the point is the spread, not the absolute.

Model	1,000 attempts	Benchmark
GPT-6 Luna	$13.50	not published
DeepSeek V4.1 Flash (off-peak)	$16.50	90.6
DeepSeek V4.1 Flash (peak)	$33.00	90.6
GLM-5.3	$124	88.2
Qwen 3.8 Max	$170	86.6
GPT-6.1 Sol	$270	not published
Kimi K3	$405	88.3
Claude Opus 5.5	$540	not published

Two readings jump out. First, the spread is roughly 33x between the cheapest credible option and Opus 5.5 — and the cheapest credible option also holds the top benchmark score, which almost never happens in this category. Second, Kimi K3 and GLM-5.3 score within 0.1 of each other (88.3 and 88.2) while Kimi costs 3.3 times as much per attempt. On this benchmark, at these prices, that is difficult to justify.

The hidden 30% on Claude pricing

This one is in Anthropic's own pricing documentation and almost no comparison page accounts for it. Claude 4.7 and later models use a tokenizer that produces about 30% more tokens for the same text. So Opus 5.5 at a nominal $4 input and $20 output behaves, for identical source code, closer to $5.20 and $26 against a model on an older tokenizer.

That does not make Opus 5.5 a bad model. It does mean the gap between it and the open-weight options is wider than the headline rates suggest, and that any spreadsheet comparing providers on nominal per-token price is understating Claude by roughly a third. Anthropic's Batch API cuts both figures by 50% if your work tolerates asynchronous processing, which brings Opus 5.5 to $2/$10 nominal.

DeepSeek V4.1 Flash

Verdict: the top score and the lowest price in the same model. Start here unless you have a specific reason not to.

What it does: 90.6 on Terminal-Bench v2.1, the highest verified figure of any model publishing on it. 1M-token context with up to 384K output tokens, which is enough to hold a substantial codebase and still emit a large diff.

Pricing: $0.30 input and $1.20 output per million at peak, halving to $0.15 and $0.60 off-peak. Peak windows run 01:00 to 04:00 and 06:00 to 10:00 UTC, Monday to Friday. Cache reads are $0.0060.

Standout: the off-peak schedule is a real lever, not a marketing line. If your agent work is batchable, shifting it outside those windows halves the bill with no change to the model.

Honest limitation: the peak and off-peak structure means your costs vary by when a job runs, which is awkward to forecast and worse to explain to a finance team. Provider listings also disagree about which rate is the headline figure, so confirm against your own first invoice rather than a comparison table — including this one.

Best for: high-volume agent loops, CI-triggered work, anything where attempt count is the cost driver.

GLM-5.3

Verdict: the balanced choice, and the easiest one to defend to someone else.

What it does: 88.2 on Terminal-Bench v2.1, two points off the top, at a flat rate with no time-of-day complication.

Pricing: $1.40 input and $4.40 output per million, from Z.AI's own pricing page. Cached input is $0.26, and cached-input storage is currently free as a limited-time offer — check whether that still holds before you build around it.

Standout: the cached-input rate is the detail to exploit. Agent loops re-send largely the same context every iteration, so a $0.26 cached rate against $1.40 cold does real work on a long-running session.

Honest limitation: GLM-5.2 and GLM-5.3 are priced identically at $1.40/$4.40, which means the older model is strictly worse value and you should check which one your tooling actually calls. A default pinned to 5.2 costs the same and scores seven points lower.

Best for: teams that want one predictable rate, and anyone whose agent re-sends a large stable context.

Claude Opus 5.5

Verdict: pay for it when the task has to land first time, and understand that you are buying a reputation rather than a published number.

What it does: Anthropic's current flagship at $4 input and $20 output. The Opus line's practical strength has been holding a long codebase context across a large multi-file change without drifting from existing conventions.

Pricing: $4/$20 per million, down from Opus 5 at $5/$25. The Batch API halves both. Factor the tokenizer note above into any comparison.

Standout: Opus 5.5 is also the designated replacement for the Opus models GitHub is removing from Copilot on 16 November 2026, so for Copilot users it is the migration default rather than a free choice.

Honest limitation: no published Terminal-Bench v2.1 score, so you cannot put it on the same axis as the open models. At roughly 33 times the per-attempt cost of DeepSeek V4.1 Flash, the burden of proof sits with the expensive option, and right now that proof is anecdotal rather than numerical.

Best for: large refactors, unfamiliar codebases, and any change where a wrong answer costs more than the tokens.

Kimi K3

Verdict: an excellent model at a price its own benchmark does not support.

What it does: 88.3 on Terminal-Bench v2.1 — second-highest here, and 0.1 above GLM-5.3. 1M-token context.

Pricing: $3 input and $15 output per million from Moonshot, with cache-hit input at $0.30. Third-party hosts vary widely: Fireworks lists $4.50/$22.50, and at least one aggregator shows figures so inconsistent they are best ignored. Price it against Moonshot directly.

Standout: the 10x cache-hit discount on input is the most aggressive caching spread in this table.

Honest limitation: it scores level with GLM-5.3 and costs 3.3 times as much per attempt. Unless the cache-hit rate transforms your specific workload, that is hard to justify on these numbers.

Best for: workloads dominated by repeated identical input where the cache hit does the heavy lifting.

Reflection Beam

Verdict: the self-hosting option, and the only Apache 2.0 licence in the group.

What it does: 501B total parameters with 23B active, 1M-token effective context, 80.1 on Terminal-Bench v2.1. Also 80.9 on SWE-Bench Verified and 65.5 on SWE-Bench Pro v1.

Pricing: no API rate — you run it. Reflection claims reasoning comparable to GLM-5.2 at three to four times less inference compute, roughly 25,000 tokens per Terminal-Bench attempt against GLM-5.2's 80,000.

Standout: Apache 2.0 permits commercial use, modification and redistribution with attribution. For an enterprise legal review that is the cleanest answer on this page.

Honest limitation: it is the lowest scorer in the table, and the efficiency figures are Reflection's own, computed as 2 x active parameters x mean generated tokens, excluding prefill, attention and serving overhead. Nobody has reproduced them independently. You also need to hold 501B parameters in memory, so this is a cluster deployment, not a workstation one.

Best for: teams that must self-host for data-residency or licensing reasons.

The cheap tier: GPT-6 Luna and Claude Haiku 5.5

Both sit at $0.10 input and $0.50 output per million — identical pricing, from competing labs. Neither publishes a Terminal-Bench v2.1 score, so treat them as unmeasured on agentic coding specifically.

They are the right tool for the high-volume, low-stakes half of a coding workflow: commit messages, docstrings, test scaffolds, first-pass triage of a lint report. Haiku 5.5 has one wrinkle worth knowing — its $0.10/$0.50 rate applies to prompts up to 100,000 tokens and steps up to $0.50/$2.50 above that, so a long-context call costs five times as much as the headline suggests.

Decision framework

• If you run agent loops at volume → DeepSeek V4.1 Flash, off-peak where you can schedule it. Top score, lowest cost, and attempt count is your bill.
• If you want one predictable rate → GLM-5.3. Two points off the top, flat pricing, strong cached-input rate.
• If a wrong answer costs more than the tokens → Claude Opus 5.5. Large refactors and unfamiliar codebases.
• If you are migrating off Copilot models before 16 November → Opus 5.5 for the Opus line, GPT-6.1 Sol or GPT-6 Luna if you were on GPT-5.6 Terra.
• If legal requires self-hosting → Reflection Beam, Apache 2.0.
• If the task is commit messages and docstrings → GPT-6 Luna or Claude Haiku 5.5 at $0.10/$0.50.
• If you have not measured your tokens per completed task → measure that first for one week. Every row above changes meaning once you know the number, and almost nobody has it.

The workflow stack that actually works

Nobody serious runs one model for everything, because the cost curve punishes it. The pattern that holds up:

1. Triage and boilerplate on GPT-6 Luna or Haiku 5.5 ($0.10/$0.50). Commit messages, docstrings, test stubs, reading a lint report. High volume, low stakes, and at these rates the cost rounds to nothing.
2. The main agent loop on DeepSeek V4.1 Flash or GLM-5.3. This is where attempt count lives, so it is where price per attempt matters. 1,000 attempts costs $16.50 to $124 here instead of $540.
3. Escalate to Claude Opus 5.5 on failure. When the loop has failed twice on the same task, hand it up. You pay the expensive rate on the small fraction of work that needs it rather than on everything.
4. Keep one open-weight model deployable. Beam under Apache 2.0, or GLM weights. Not for daily use — as insurance. GitHub removing three models from Copilot on 16 November, with four weeks notice, is the argument for it.

The escalation step in point 3 is where the saving comes from, and it is the step most teams skip. Running every task on your most capable model is the single most common way to turn a $120 month into a $540 one.

FAQ

What is the best AI model for coding in 2026?

On verified benchmarks, DeepSeek V4.1 Flash — 90.6 on Terminal-Bench v2.1, the highest score among models that publish on it, at $0.30 input and $1.20 output per million tokens ($0.15/$0.60 off-peak). Claude Opus 5.5 is the common choice for high-stakes work at $4/$20, but Anthropic does not publish a Terminal-Bench score, so that preference rests on practitioner experience rather than a comparable number.

Why do Claude and GPT models have no benchmark score here?

Because neither Anthropic nor OpenAI publishes results on Terminal-Bench v2.1. Pages that show a single leaderboard spanning both open and closed models are either using a different benchmark for each row or filling gaps with estimates. Leaving the cells blank is less satisfying and more accurate.

What is the cheapest AI coding model?

GPT-6 Luna and Claude Haiku 5.5 tie at $0.10 input and $0.50 output per million, but neither publishes an agentic coding score. The cheapest model with a verified top-tier score is DeepSeek V4.1 Flash at $0.15/$0.60 off-peak — about $16.50 per 1,000 agent attempts on the assumptions above, against $540 for Claude Opus 5.5.

Is Claude Opus 5.5 worth $20 per million output tokens?

It depends entirely on what a wrong answer costs you. At roughly 33 times DeepSeek V4.1 Flash per attempt, it needs to save you more than 33 attempts' worth of your own time to break even. On a large refactor of an unfamiliar codebase that is an easy yes. On a loop that runs on every commit it is an easy no. Note also that Anthropic's documentation states Claude 4.7 and later tokenize the same text into about 30% more tokens, so the effective rate is nearer $5.20/$26.

Which models is GitHub Copilot removing, and when?

Claude Opus 4.8, Claude Opus 5 and GPT-5.6 Terra leave Copilot on 16 November 2026. Opus 4.8 remains for individual annual subscribers only. The suggested replacements are Claude Opus 5.5, and GPT-6.1 Sol or GPT-6 Luna for Terra. The models are not deprecated — Opus 5 stays on Anthropic's own API — so if a pipeline needs that specific model, move the call rather than changing the model.

Can I use these models commercially?

Reflection Beam is Apache 2.0, which permits commercial use, modification and redistribution with attribution. The API models are governed by each vendor's terms. For the other open-weight models, check the current licence text directly rather than relying on the word "open" — open weights and an open licence are not the same thing.

How often does this pricing change?

Often enough that you should check before committing. Every figure on this page was verified against vendor pricing pages on 17 October 2026, and Claude Opus 5 dropped from $5/$25 to Opus 5.5 at $4/$20 within this product cycle. Treat any per-token table older than a month as a starting point, not a quote.

Pricing sources, all checked 17 October 2026: Claude Platform pricing · Z.AI pricing · OpenAI rates · Moonshot rates · Qwen 3.8 Max · DeepSeek V4.1 Flash · Reflection Beam

Related: Copilot retires three models on 16 November · Reflection opens Beam under Apache 2.0 · Beam vs DeepSeek V4.1 Flash