AI Coding Model Leaderboard November 2026: SWE-bench Verified, Terminal-Bench, Aider Polyglot Scores and Price
The number most people quote when they ask “which model codes best” comes from a scoreboard that stopped moving in February. The official SWE-bench Verified board has no submission newer than 26 February 2026. The Aider Polyglot board was last updated in November 2025. Meanwhile Claude Opus 5.5, Claude Fable 5.2, GPT-6.2 Astra and Sol, and Gemini 4 Carbon all shipped. This AI coding model leaderboard rebuilds the picture from the sources that still move. Those are Terminal-Bench 4.1, SWE-bench Pro and vendor model cards, each with harness, date and cost attached.
It matters now because two frontier launches landed this week. OpenAI’s GPT-6.2 tier and GitHub’s Copilot Fusion router both appeared on the Terminal-Bench board on 17 November 2026. You will leave with current scores, a price-per-MTok table, measured cost per solved task, and a decision guide by workload.
What this covers: what each benchmark measures and why three of them have stalled, the November 2026 results tables with confidence intervals, list prices, cost-per-solved-task math, the traps in vendor-reported numbers, and which model to pick for agentic refactors, terminal work, autocomplete and self-hosting. This page is updated monthly.
Context and Background
Coding benchmarks went through three generations in about three years. The first generation, HumanEval and MBPP, asked a model to write one function from a docstring. Frontier models saturated those by 2024. The second generation, led by SWE-bench, gave the model a real GitHub issue and a repository snapshot. It then ran hidden unit tests against the patch. SWE-bench Verified, released by the SWE-bench team with OpenAI in August 2024, trimmed that set to 500 human-checked Python tasks. For about eighteen months it was the default headline number on every model card.
The third generation measures agents, not models. Terminal-Bench drops an agent into a container with a goal such as “build this kernel module” or “recover this database”. A verifier then checks the final state. The score depends on the model, the agent harness wrapped around it, the reasoning effort, the time limit and the number of trials. Our earlier explainer on AI agent benchmarks such as SWE-bench, GAIA and tau-bench covers the general mechanics. This AI coding model leaderboard tracks the coding slice of that world, month by month.
Two events in 2026 reshaped which numbers are worth trusting. First, on 23 February 2026, OpenAI published a post explaining why it no longer evaluates SWE-bench Verified. It cited flawed tests and training contamination, and recommended SWE-bench Pro instead. Second, Terminal-Bench turned into a “continuous benchmark” with semantic versions. It moved from 2.0 (November 2025) through 2.1, 3.0 and 4.0 to 4.1, released 9 November 2026. Each release fixes tasks, retires saturated ones and hardens verifiers against reward hacking.
The incumbents have also changed names. Anthropic now ships Opus 5.5, Sonnet 5.5 and Haiku 5.5, plus Fable 5.2, the generally available sibling of the restricted Mythos 5.2. OpenAI ships GPT-6.2 in Astra (top) and Sol (everyday) tiers. Google ships Gemini 4 Carbon, Argon and Hydrogen. The open-weight challengers are Kimi K3.1 Pro, GLM-5.3, DeepSeek V4.1 Flash and Tencent Hy4. For the broader open-weight picture, see our November 2026 open-weight LLM benchmark leaderboard.
How the AI Coding Model Leaderboard Is Built in November 2026
Direct answer: In November 2026 the most reliable AI coding model leaderboard is Terminal-Bench 4.1. GitHub’s Copilot Fusion router leads at 71.2%, then Claude Opus 5.5 and Fable 5.2 (65.8%), Gemini 4 Carbon (64.6%) and Sonnet 5.5 (63.9%). GPT-6.2 Sol scores 61.5% at about one-twelfth of Opus 5.5’s cost per solved task.
Every row in this ranking is a combination of four things, and you should read it that way. One is a model. Another is a harness, meaning the agent loop that turns model outputs into shell commands and file edits. The third is a reasoning-effort setting, from “low” to “max”. The last is a trial protocol: how many runs per task, with what time limit. Change any one and the score moves, sometimes by more than the gap between vendors.

Figure 1: How a coding-agent leaderboard row is produced, from task source through harness, verifier and repeated trials.
The figure traces one evaluation. A real task source, such as a GitHub issue or an Exercism exercise, is frozen into a container. The harness feeds the task to the model at a chosen effort level. The model acts through shell and editor tools, and a verifier the agent cannot see grades the final state. Terminal-Bench 4.1 repeats this five times per task and publishes the pass rate, a 95% confidence interval and the total API cost of the run.
Rule 1: Trust boards that publish harness, trials and cost
A leaderboard row without a harness name is close to meaningless for agentic coding. The Terminal-Bench 4.1 board lists the agent next to every model: Claude Code for Anthropic models, Codex for OpenAI, Antigravity CLI for Gemini, Grok Build for xAI, Muse Code for Meta. Open-weight models usually appear under Claude Code or mini-SWE-agent. Each row also records 330 trials, pass@2 to pass@5, total tokens and total cost.
The 330-trial figure is worth decoding, because the board does not state the task count directly. Terminal-Bench 3.0 launched with 74 tasks. Version 4.0 removed eight: two saturated, two that drew refusals, two with public solutions and two with unresolved quality issues. That leaves 66 tasks, and 66 tasks times five trials gives 330. The 4.1 release notes report 11,550 trials across 35 agents, which is also 330 per agent. The 66-task count is our derivation from those published numbers, not a figure stated on the board.
Rule 2: Treat a stalled board as history, not ranking
The official SWE-bench Verified board still renders, and its top entries look impressive. The newest submission in its data is dated 26 February 2026, though. The best “bash-only” row, which uses a common mini-SWE-agent v2 harness for every model, is Claude Opus 4.5 at high effort with 76.8%. None of the models released since March appear. If you pick a model from that table today, you are choosing among models one or two generations old.
The Aider Polyglot leaderboard has the same problem with a longer delay. Its page reads “last updated November 20, 2025,” and its newest data row is DeepSeek-V3.2-Exp from 3 October 2025. GPT-5 at high reasoning effort still sits on top at 88.0%. Those results are still a fair way to compare 2025 models on whole-file and diff-format editing. They say nothing about GPT-6.2 or Opus 5.5.
Rule 3: Separate vendor-reported from independently run
Vendor model cards now carry most of the fresh numbers, but on benchmarks and settings the vendor picks. Anthropic’s Sonnet 5.5 page reports 70.6% on Terminal-Bench 4.0. The official 4.0 leaderboard row for Sonnet 5.5 in Claude Code at max effort is 61.82%, revised to 63.94% in 4.1. Kimi’s K3.1 Pro post reports 65.7% on Terminal-Bench 4.0 with a Claude Code harness. The official 4.1 row is 59.7%, with a wide ±4.2-point interval.
None of this implies bad faith. Vendors tune timeouts, effort and tool configuration, and Anthropic says Opus 5.5’s 66.4% was run at “xhigh” effort, not the leaderboard’s “max”. The practical rule is simple. Use the independent board to rank, and use vendor numbers only to compare a vendor’s models against each other.
November 2026 Results: Terminal-Bench, SWE-bench Verified, SWE-bench Pro and Aider Polyglot
All figures in this AI coding model leaderboard were retrieved on 19 November 2026 from the primary sources linked in the References. Percentages are pass rates as published. “Not reported” means the benchmark owner or vendor has published no figure we could find this run.

Figure 2: Which coding benchmarks still track the frontier as of November 2026.
The diagram sorts the five main data sources by freshness. SWE-bench Verified and Aider Polyglot have stopped taking new frontier submissions. SWE-bench Pro is maintained but trails the newest releases by several months. Terminal-Bench 4.1 is the only independent board with entries from this week. Vendor model cards are fresh but self-reported, and they increasingly use their own benchmarks such as FrontierCode and CursorBench.
Terminal-Bench 4.1: the live board
Terminal-Bench 4.1 is the Terminal-Bench leaderboard we treat as the primary input to our AI coding model leaderboard this month. The table shows the best row for each model at its listed effort. Cost is the total API spend the board reports for all 330 trials. “Cost per solved task” is that total divided by successful trials, computed by us from the board’s own numbers.
| # | Model | Harness | Effort | Pass rate (±95% CI) | pass@5 | Board cost (330 trials) | Cost per solved task | Date |
|---|---|---|---|---|---|---|---|---|
| 1 | Copilot Fusion (router) | GitHub Copilot | max | 71.2% ± 2.9 | 83.3% | $1,987 | $8.46 | 2026-11-17 |
| 2 | Claude Opus 5.5 | Claude Code | max | 65.8% ± 3.1 | 80.3% | $4,719 | $21.74 | 2026-09-22 |
| 2 | Claude Fable 5.2 | Claude Code | max | 65.8% ± 2.9 | 78.8% | $16,493 | $76.00 | 2026-11-09 |
| 4 | Gemini 4 Carbon | Antigravity CLI | high | 64.6% ± 3.2 | 78.8% | $1,358 | $6.38 | 2026-10-28 |
| 5 | Claude Sonnet 5.5 | Claude Code | max | 63.9% ± 3.0 | 80.3% | $7,334 | $34.76 | 2026-09-28 |
| 6 | GPT-6.2 Astra | Codex | max | 62.1% ± 2.3 | 72.7% | $1,409 | $6.87 | 2026-11-17 |
| 7 | GPT-6.2 Sol | Codex | max | 61.5% ± 2.8 | 72.7% | $349 | $1.72 | 2026-11-17 |
| 8 | GPT-6.1 Sol | Codex | max | 60.9% ± 3.0 | 74.2% | $634 | $3.16 | 2026-09-29 |
| 9 | Kimi K3.1 Pro | Claude Code | max | 59.7% ± 4.2 | 84.8% | $1,087 | $5.52 | 2026-10-24 |
| 10 | Gemini 4 Hydrogen | Antigravity CLI | high | 56.4% ± 3.0 | 69.7% | $784 | $4.22 | 2026-11-12 |
| 11 | Gemini 4 Argon | Antigravity CLI | high | 55.5% ± 2.9 | 65.2% | $1,109 | $6.06 | 2026-09-30 |
| 12 | Meta Muse Wonder | Muse Code | xhigh | 47.0% ± 3.8 | 71.2% | $2,452 | $15.82 | 2026-10-12 |
| 13 | GLM-5.3 | Claude Code | max | 41.2% ± 3.3 | 57.6% | $2,728 | $20.06 | 2026-08-14 |
| 14 | Claude Haiku 5.5 | Claude Code | max | 40.0% ± 3.6 | 60.6% | $952 | $7.22 | 2026-10-07 |
| 15 | Grok 4.7 | Grok Build | xhigh | 38.8% ± 3.6 | 62.1% | $3,683 | $28.78 | 2026-09-21 |
| 16 | DeepSeek V4.1 Flash 1017 | Claude Code | max | 38.5% ± 3.8 | 65.2% | $185 | $1.46 | 2026-10-17 |
| 17 | Tencent Hy4 | Claude Code | max | 37.9% ± 3.5 | 59.1% | $348 | $2.78 | 2026-11-04 |
| 18 | Mistral Large 4 | Claude Code | max | 27.6% ± 3.9 | 57.6% | $718 | $7.89 | 2026-10-06 |
| 19 | Qwen3.8-Max-0902 | Claude Code | max | 27.0% ± 3.9 | 54.5% | $4,636 | $52.09 | 2026-09-02 |
Positions follow the board’s ordering among the models shown. We keep each model’s best row and drop superseded versions such as GPT-6 Astra, Fable 5.1 and Opus 5; ties share a position.
Three patterns stand out. First, the top entry is not a model. GitHub’s documentation describes Copilot Fusion as “an intelligent runtime model router and orchestrator”. It picks one model, cascades from a cheap draft to a stronger model, or has several models critique a draft. GitHub does not name the pool on that page. Its 71.2% is a result for a routing system, so it does not compare like-for-like with a single model.
Second, the single-model frontier of the AI coding model leaderboard is a statistical tie. Opus 5.5, Fable 5.2, Gemini 4 Carbon, Sonnet 5.5, GPT-6.2 Astra and GPT-6.2 Sol all fall within about four points, and their intervals overlap. Third, cost per solved task spans roughly 44x across that cluster, from $1.72 for GPT-6.2 Sol to $76.00 for Fable 5.2. That spread is the real news in this month’s board.
SWE-bench Verified: the frozen board
The SWE-bench Verified leaderboard is still the most searched coding benchmark, so here is what it currently shows. The default “Bash Only” view runs every model inside the same mini-SWE-agent environment. That makes it the fairest model-to-model comparison on the site. Its newest entries come from the mini-SWE-agent 2.0 runs of 17–26 February 2026.
| Model (bash-only, mini-SWE-agent 2.0) | Effort | % resolved | Avg cost per instance | Cost per resolved | Open weights |
|---|---|---|---|---|---|
| Claude Opus 4.5 | high | 76.8% | $0.75 | $0.98 | No |
| Gemini 3 Flash | high | 75.8% | $0.36 | $0.47 | No |
| MiniMax M2.5 | high | 75.8% | $0.07 | $0.10 | Yes |
| Claude Opus 4.6 | default | 75.6% | $0.55 | $0.73 | No |
| GLM-5 | high | 72.8% | $0.53 | $0.73 | Yes |
| GPT-5.2 | high | 72.8% | $0.47 | $0.65 | No |
| GPT-5.2 Codex | default | 72.8% | $0.45 | $0.62 | No |
| Claude Sonnet 4.5 | high | 71.4% | $0.66 | $0.92 | No |
| Kimi K2.5 | high | 70.8% | $0.15 | $0.21 | Yes |
| DeepSeek V3.2 | high | 70.0% | $0.45 | $0.64 | Yes |
| Gemini 3 Pro | high | 69.6% | $0.96 | $1.38 | No |
| Claude Haiku 4.5 | high | 66.6% | $0.33 | $0.50 | No |
The same data file holds agent-system submissions as well. These are not bash-only. The highest is 79.2%, shared by Sonar Foundation Agent and live-SWE-agent, both on Claude Opus 4.5. Those rows mix custom scaffolds, multiple attempts and in some cases several models, so they measure engineering effort as much as model quality.
The useful reading is narrow. On Python issue-fixing in a fixed harness, the early-2026 generation clustered between 70% and 77%. Open-weight MiniMax M2.5 matched Gemini 3 Flash at about one-fifth the cost. For any model released after February, the SWE-bench Verified column in this monthly ranking reads “not reported”. Anthropic’s Opus 5.5, Sonnet 5.5 and Fable 5.2 pages, Google’s Gemini 4 Carbon post and Kimi’s K3.1 Pro post do not report it. OpenAI’s GPT-6.2 model pages list no benchmarks at all.
SWE-bench Pro: maintained, but a step behind
Scale AI’s SWE-bench Pro has 1,865 tasks across 41 repositories. The public set has 731 instances, a private set of 276 comes from startup codebases, and a held-out set of 858 stays unpublished. Rows marked with an asterisk ran in mini-swe-agent. The page says most rows used uncapped cost and a 250-turn limit.
| Model (public set) | % resolved (± CI) |
|---|---|
| Meta Muse Spark 1.1 | 61.5 ± 3.1 |
| GPT-5.4 (xHigh) | 59.1 ± 3.6 |
| Meta Muse Spark | 55.0 ± 3.6 |
| Claude Opus 4.6 (thinking) | 51.9 ± 3.6 |
| Gemini 3.1 Pro (thinking) | 46.1 ± 3.6 |
| Claude Opus 4.5 | 45.9 ± 3.6 |
| Claude Sonnet 4.5 | 43.6 ± 3.6 |
| Gemini 3 Pro Preview | 43.3 ± 3.6 |
| GPT-5.2 Codex | 41.0 ± 3.6 |
| Qwen3-Coder-480B-A35B | 38.7 ± 3.6 |
SWE-bench Pro is harder than Verified and less contaminated, according to OpenAI’s February analysis. Its weakness this month is lag. Opus 5.5, Fable 5.2, GPT-6.x and Gemini 4 do not appear on the public board we retrieved, and it carries no visible update date. Treat it as the best guide to how 2026’s first-half models handle multi-file enterprise-style changes.
Aider Polyglot: a 2025 snapshot
The Aider Polyglot benchmark runs 225 hard Exercism exercises in C++, Go, Java, JavaScript, Python and Rust. It scores two attempts, the second after the model sees test failures. It also reports how often the model’s edits were well-formed for Aider’s diff format. That edit-format discipline matters for editor-integrated assistants more than for autonomous agents.
| Model | Pass rate (2 attempts) | Edit format | Well-formed edits | Total run cost | Date |
|---|---|---|---|---|---|
| GPT-5 (high) | 88.0% | diff | 91.6% | $29.08 | 2025-08-23 |
| GPT-5 (medium) | 86.7% | diff | 88.4% | $17.69 | 2025-08-25 |
| o3-pro (high) | 84.9% | diff | 97.8% | $146.32 | 2025-06-28 |
| Gemini 2.5 Pro 06-05 (32k think) | 83.1% | diff-fenced | 99.6% | $49.88 | 2025-06-06 |
| Grok 4 (high) | 79.6% | diff | 97.3% | $59.62 | 2025-07-11 |
| DeepSeek-V3.2-Exp (Reasoner) | 74.2% | diff | 97.3% | $1.30 | 2025-10-03 |
| Claude Opus 4 (32k thinking) | 72.0% | diff | 97.3% | $65.75 | 2025-05-25 |
The top of this board reached the high 80s in 2025, so it is close to saturated for frontier models. Its lasting value is the cost column. DeepSeek’s 74.2% for $1.30 versus GPT-5’s 88.0% for $29.08 was an early sign of the price spread now visible on Terminal-Bench.
Vendor-reported coding scores for current flagships
Because the independent boards lag, the newest capability claims live on vendor pages. The table collects what each vendor published for its current coding flagship. Treat every cell as self-reported, and note the effort level where the vendor gave one.
| Model | Terminal-Bench 4.0 (vendor) | Other coding benchmarks (vendor) | SWE-bench Verified | Source date |
|---|---|---|---|---|
| Claude Opus 5.5 | 66.4% (xhigh) | FrontierCode 1.1 54.4%; CursorBench 4.0 57.8% | Not reported | 2026-09-22 |
| Claude Sonnet 5.5 | 70.6% | FrontierCode 1.1 52.1% (xhigh); CursorBench 4.0 55.5% | Not reported | 2026-09-28 |
| Claude Haiku 5.5 | 39.2% | FrontierCode 1.1 46.4% | Not reported | 2026-10-07 |
| Claude Fable 5.2 | Not reported on launch page | FrontierCode 2.0 49.1%; FrontierSWE v2 69.9% | Not reported | 2026-11-09 |
| Kimi K3.1 Pro | 65.7% (Claude Code harness) | Kimi Code Bench 3.0 61.2% (internal) | Not reported | ~2026-10-23 |
| GLM-5.3 | Not reported (Terminal-Bench 3.0: 28.3) | DeepSWE v1.1 66.9 | Not reported | Not dated |
| Gemini 4 Carbon | No score given; cheating rate 0.0% | WebDev Arena 1768 Elo (#4) | Not reported | 2026-10-28 |
| Gemini 4 Hydrogen | Terminal-Bench 4.1: 57% | None numeric | Not reported | 2026-11-12 |
| GPT-6.2 Astra / Sol | Not listed on model pages | Not listed on model pages | Not reported | Knowledge cutoffs May / June 2026 |
Fable 5.2’s page also gives comparison figures on FrontierSWE v2: Opus 5.5 62.3%, GPT-6 Astra 65.5% and Gemini 4 Carbon 61.2%. On FrontierCode 2.0 it lists Opus 5.5 at 45.5%, GPT-6 Astra at 42.8% and Gemini 4 Carbon at 41.1% (medium effort). Microsoft’s Ignite coding model and Cognition’s SWE models had no scores we could retrieve from a primary source this run. They are marked not reported here. GitHub’s Fusion documentation does name “MAI Code 1.1 Flash” as a local routing option in public preview.
Methodology caveats for this month’s tables
Pass rates on Terminal-Bench carry 95% intervals of roughly ±2.3 to ±4.2 points. Any gap under about five points between two single rows should be read as a tie. Cost figures are what each run’s harness billed at list price. They reflect that harness’s token appetite, caching behaviour and effort setting, and they are not a property of the model alone. The SWE-bench Verified cost column comes from the board’s average instance cost divided by resolve rate. Aider costs are whole-run totals. We did not re-run any benchmark ourselves. LiveBench and LMArena’s WebDev Arena were not retrievable in machine-readable form this run, so apart from Google’s own WebDev claim for Carbon they are omitted rather than estimated.
Price per MTok and Cost per Solved Task
An AI coding model leaderboard tells you how often a model succeeds. Your invoice depends on how many tokens it burns per attempt and what those tokens cost. The table lists published list prices per million tokens (MTok) as of 19 November 2026. For a wider pricing survey, including non-coding models, see our LLM API pricing comparison for November 2026.
| Model | Input $/MTok | Cached input $/MTok | Output $/MTok | Notes |
|---|---|---|---|---|
| Claude Fable 5.2 | 8.00 | Not stated on launch page | 40.00 | Fast mode $16 / $80 |
| GPT-6.2 Astra | 8.00 | 0.40 | 40.00 | Context 1.05M; input above 272K billed at 2x input, 1.5x output |
| Claude Opus 5.5 | 4.00 | 0.20 (cache read) | 20.00 | Cache write $5; fast mode $8 / $40 |
| Gemini 4 Carbon | 2.00 intro, 4.00 later | 95% off input | 10.00 intro, 20.00 later | Limited availability at launch |
| Claude Sonnet 5.5 | 2.00 | 0.10 (cache read) | 10.00 | Cache write $2.50 |
| GPT-6.2 Sol | 2.00 | 0.10 | 10.00 | Context 1.05M, max output 128K |
| Gemini 4 Argon | 2.00 intro | Not stated in source | 10.00 intro | Intro price per Google’s Carbon post |
| Grok 4.7 | 2.00 | 0.50 | 6.00 | Context 500K |
| Gemini 4 Hydrogen | 1.50 | Not stated in source | 7.50 | Flat across 1M context |
| Claude Haiku 5.5 | 0.10 (prompts up to 100K) | Not stated | 0.50 (up to 100K) | $0.50 / $2.50 above 100K |
| DeepSeek V4.1 Flash 1017 | 0.035 | 0.0015 | 0.15 | OpenRouter headline listing; provider rates vary |
| Kimi K3.1 Pro | Not stated on launch post | — | Not stated | Open weights announced |
| GLM-5.3 | Not stated (coding-plan points) | — | — | 1M context |
| Copilot Fusion | Underlying model rates | — | — | 30% discount on paid plans to 30 Nov 2026 |
Why list price is the wrong number to compare
List price is per token, and coding agents vary enormously in tokens per attempt. The Terminal-Bench 4.1 rows make this concrete. GPT-6.2 Sol produced about 49,000 output tokens per trial. Opus 5.5 produced about 269,000, Sonnet 5.5 about 565,000 and Fable 5.2 about 491,000, all at max effort in their native harnesses. These per-trial averages are our arithmetic on the board’s totals.
That is why Sonnet 5.5, at the same list price as GPT-6.2 Sol, costs about 20x more per solved Terminal-Bench task ($34.76 against $1.72). Sonnet thinks longer, calls more tools and, in Anthropic’s own words about FrontierCode, sometimes fans out to many sub-agents at max effort. Effort level is therefore a cost dial as much as a quality dial. Anthropic’s Fable 5.2 page notes that at High effort Fable 5.2 scores 45.3% on FrontierCode 2.0. That roughly matches Opus 5.5’s best score “at about half the cost per task.”
The cost-per-solved-task formula
The model-only cost of one solved task is cost per attempt divided by pass rate. Cost per attempt is uncached input tokens times input price, plus cached tokens times cache price, plus output tokens times output price. The pass rate comes from the leaderboard that best matches your workload.

Figure 3: From list price to total cost per merged fix, including the human review that every attempt consumes.
The figure shows two terms that most price comparisons skip. Token appetite multiplies list price before the pass rate is applied. Human review cost is added per attempt, not per success, because someone has to read every failed patch too. Once review is priced, the pass rate becomes the dominant term for all but the cheapest workflows.
A worked example (illustrative)
The following numbers are illustrative, not measured. Assume one ticket-sized agent attempt uses 2,000,000 input tokens, 90% of them cached, and 60,000 output tokens. Assume each attempt also needs 15 minutes of engineer review at $100 per hour, or $25. Use the Terminal-Bench 4.1 pass rates as a stand-in for success on your tasks.
| Model (illustrative) | Model cost per attempt | Pass rate used | Model cost per solved | Total per solved incl. $25 review |
|---|---|---|---|---|
| GPT-6.2 Sol | $1.18 | 61.5% | $1.92 | $42.57 |
| Claude Opus 5.5 | $2.36 | 65.8% | $3.59 | $41.61 |
| GPT-6.2 Astra | $4.72 | 62.1% | $7.60 | $47.86 |
For Sol, the arithmetic is 200K uncached × $2, plus 1.8M cached × $0.10, plus 60K output × $10. That gives $0.40 + $0.18 + $0.60 = $1.18 per attempt. With an identical token budget, Opus 5.5 is cheaper per solved task than Astra and only slightly costlier than Sol. Once a $25 human review is added, Opus edges ahead on total cost because it succeeds more often.
The measured board numbers tell a different story because real token budgets are not identical. Opus 5.5 used about five times Sol’s output tokens on Terminal-Bench. The lesson is to measure your own token appetite per model before trusting either list price or a leaderboard’s cost column.
Decision Guide: the Best AI Model for Coding in November 2026, by Use Case
There is no single best AI model for coding in November 2026. There is a best model per job, per budget and per deployment constraint. The guide below maps the four common jobs to the evidence above.

Figure 4: Choosing a model tier by workload, then validating on your own tickets.
The flow starts from the job, not from the top row of an AI coding model leaderboard. Long multi-file refactors go to the frontier tier. Terminal and operations work goes to the value tier, where Terminal-Bench shows near-frontier pass rates at a fraction of the cost. Inline completion goes to small, fast models. Data-residency constraints point to open weights. Every branch ends in the same box, a private evaluation on 30 to 50 of your own tickets.
| Use case | First choice (evidence) | Value alternative | Avoid / caveat |
|---|---|---|---|
| Long agentic refactors, multi-file features | Claude Opus 5.5 in Claude Code (65.8% TB 4.1, highest pass@5 among single models at 80.3%) | GPT-6.2 Astra in Codex (62.1%, $6.87 per solved) | Fable 5.2 matches Opus on TB 4.1 at about 3.5x the cost per solved task |
| Terminal, build, infra and data-ops tasks | GPT-6.2 Sol in Codex (61.5%, $1.72 per solved) | Gemini 4 Carbon (64.6%, $6.38) once broadly available | Sonnet 5.5 at max effort: strong score, $34.76 per solved |
| Autocomplete, inline edits, chat-in-IDE | Small tier: Claude Haiku 5.5 or Gemini 4 Hydrogen | Copilot Fusion “Fast” in VS Code inline chat | Agentic benchmarks say little about latency-bound completion |
| Self-hosted or residency-constrained | Kimi K3.1 Pro (59.7%, open weights announced) | DeepSeek V4.1 Flash (38.5%, $1.46 per solved) or GLM-5.3 | Check the actual licence and serving hardware before committing |
| Mixed workload in GitHub | Copilot Fusion (71.2% as a routed system) | Pin one model per task class | Routed pool is not disclosed; reproducibility is harder |
Agentic refactors
For long-horizon work, the success rate across repeated attempts matters more than single-shot pass@1. Opus 5.5 and Sonnet 5.5 both reach 80.3% pass@5 on Terminal-Bench 4.1. GPT-6.2 Astra and Sol plateau at 72.7%. If your workflow lets an agent retry or run several attempts in parallel, Anthropic’s models gain more from the retries. If you run one attempt and hand it to a human, the gap narrows to a statistical tie.
Terminal operations
Terminal-Bench is the closest public proxy for CI fixes, environment setup, data wrangling and infrastructure scripts. On that proxy GPT-6.2 Sol is the price-performance leader of this month’s board by a wide margin. It also finished trials fastest on average among frontier rows, around 20 minutes per trial against 80 for Opus 5.5. Treat those durations as indicative, because several rows on the board report implausibly short averages.
Autocomplete
No benchmark in this AI coding model leaderboard measures time-to-first-token or acceptance rate for inline completion. Those are what matter in an editor. Choose from the small tier on latency and price, then measure acceptance in your own IDE telemetry. Our fact-check of whether AI coding agents make developers faster explains why acceptance rate is a weak proxy for productivity.
Self-hosted
Kimi K3.1 Pro is the strongest open-weight entry on Terminal-Bench 4.1 at 59.7%. Its pass@5 of 84.8% is the highest of any row on the board, which suggests high variance between attempts. Moonshot’s launch post describes it as “3T-class” with full weights due by 4 November 2026 and names no licence. Serving a model of that size is a multi-node job. DeepSeek V4.1 Flash and GLM-5.3-Flash are the practical self-host options for teams with a single GPU server.
Trade-offs, Gotchas, and What Goes Wrong
Every AI coding model leaderboard, including this one, inherits the weaknesses of the benchmarks underneath it. Six matter most this month.
Contamination is real and measured. OpenAI’s audit found that every frontier model it tested could reproduce gold patches or verbatim problem details for some SWE-bench Verified tasks. It also found that 59.4% of the 138 hard problems it audited had material test or specification flaws. That is why a 2026 model scoring 80% on Verified tells you little. Pro and Terminal-Bench reduce the problem but cannot remove it, because public tasks eventually leak into training data.
Harness dependence can exceed model differences. On SWE-bench Verified, the same Claude Opus 4.5 scores 76.8% in plain mini-SWE-agent and 79.2% inside two custom agent systems. On Terminal-Bench, open-weight models in Claude Code often beat the same models in mini-swe-agent. If your production harness is Cursor, Aider or an in-house agent, a Claude Code or Codex score is only a prior.
Reward hacking is a moving target. Terminal-Bench 4.1 exists largely to harden verifiers. Harbor now strips dangerous symlinks and permissions before artifacts reach the verifier, and runs submitted code as an untrusted user. The regrade changed 162 of 11,550 trials, about 1.4%, and 134 of those were verifier fixes. The maintainers report that all 35 agents’ 4.1 scores stayed within their 4.0 intervals. Google’s Carbon post claims a successful-cheating rate of 0.0% on Terminal-Bench 4.0, which tells you vendors now monitor this. For containment in your own pipeline, see our guide to sandboxing AI agent code execution.
Routers break reproducibility. Copilot Fusion tops the board, but its model pool and routing policy can change without a version bump. A routed result is a product benchmark, not a model benchmark. If you need stable behaviour for audits, pin a model. Our piece on LLM routing and model cascades covers the cost-quality maths behind cascades.
Version drift between benchmark releases. Vendors quote Terminal-Bench 4.0, Google quotes 4.1 for Hydrogen, Z.ai quotes 3.0 for GLM-5.3, and some posts still quote 2.0. Scores across versions are not comparable, even though 4.0 and 4.1 stay within each other’s intervals. Always check the version suffix.
Benchmarks are not your codebase. No public suite has your monorepo, internal frameworks, flaky tests or code-review norms. FrontierCode tries to approximate “would maintainers merge this”, but it is vendor-run. The only number that predicts your outcome is one you measure.
Practical Recommendations
Build your own AI coding model leaderboard on top of Terminal-Bench 4.1 for ranking, because it is the only independent coding board with entries from this month. It also publishes intervals and cost. Use SWE-bench Pro as a secondary check for repository-scale patching, keeping in mind it trails the newest releases. Read SWE-bench Verified and Aider Polyglot as history. Read vendor model cards only for comparisons within one vendor’s family.
Budget on cost per solved task, not on price per MTok. Pull token counts from your own agent traces, and add a realistic human review cost per attempt. With review priced in, the success rate usually dominates. That makes a modest pass-rate lead worth paying for on hard work, and the cheapest competent model the right call on routine tasks. Our guide to trajectory evals and pass@k reliability for LLM agents shows how to instrument that measurement.
Finally, re-run your shortlist every month, just as we refresh this AI coding model leaderboard. Three of the top seven single-model rows on this board did not exist at the start of October.
- Shortlist two or three models from the Terminal-Bench 4.1 table that fit your budget tier.
- Run each in your real harness on 30 to 50 resolved tickets from your own backlog, three trials each.
- Record pass@1, pass@3, tokens per attempt and wall-clock time per attempt.
- Compute total cost per merged fix, including review time.
- Set effort per task class, not globally; max effort is rarely worth it on routine tickets.
- Pin model versions in production and re-evaluate when this leaderboard updates next month.
Frequently Asked Questions
Which AI model is best for coding in November 2026?
On Terminal-Bench 4.1, the most current independent coding board, GitHub’s Copilot Fusion router leads at 71.2%. Among single models, Claude Opus 5.5 and Claude Fable 5.2 tie at 65.8%, followed by Gemini 4 Carbon at 64.6% and Claude Sonnet 5.5 at 63.9%. GPT-6.2 Astra (62.1%) and Sol (61.5%) sit close behind. These leaders overlap within their 95% confidence intervals, so “best” depends on cost and workload. GPT-6.2 Sol is the clear price-performance leader at about $1.72 per solved task.
What is the current SWE-bench Verified leaderboard top score?
The official SWE-bench Verified board’s highest entry is 79.2%. That score is shared by Sonar Foundation Agent and live-SWE-agent, both using Claude Opus 4.5 inside custom agent systems. In the standardized bash-only view, the top is Claude Opus 4.5 at high effort with 76.8%. The board’s newest submission dates from 26 February 2026, so no model released since March appears on it. OpenAI stopped reporting Verified in February 2026, citing flawed tests and contamination.
What does Terminal-Bench measure?
Terminal-Bench measures whether an AI agent can complete realistic command-line tasks end to end inside a container. Tasks span builds, debugging, data processing, systems administration and scientific workflows, and a hidden verifier checks the final state. Version 4.1, released on 9 November 2026, runs five trials per task. It publishes the pass rate with a 95% confidence interval, pass@k, token counts and total cost. Scores depend on the agent harness, such as Claude Code or Codex, as well as the model.
Is the Aider Polyglot benchmark still updated?
Not for current frontier models. The Aider leaderboard page says it was last updated on 20 November 2025, and its newest result is DeepSeek-V3.2-Exp from October 2025. GPT-5 at high reasoning effort leads at 88.0% on the 225-exercise polyglot set across six languages. It remains useful for comparing 2025-era models on code-editing format discipline. For November 2026 models, use Terminal-Bench 4.1, SWE-bench Pro or your own evaluation instead.
Why do vendor scores differ from an AI coding model leaderboard?
Vendors usually run benchmarks with their own harness settings, effort levels, timeouts and trial counts. For example, Anthropic reports 70.6% for Sonnet 5.5 on Terminal-Bench 4.0, while the official 4.0 row shows 61.82%. Kimi reports 65.7% for K3.1 Pro against an official 4.1 row of 59.7%. Version differences, sampling noise and configuration all contribute. Use an independent AI coding model leaderboard to compare across vendors, and vendor numbers to compare models within one vendor.
How do I calculate cost per solved coding task?
Divide the cost of one attempt by the pass rate. Cost per attempt is uncached input tokens times input price, plus cached tokens times cache price, plus output tokens times output price. Then add the human review cost per attempt, because failed patches also need reading. On Terminal-Bench 4.1’s own totals, cost per solved task ranges from about $1.46 for DeepSeek V4.1 Flash to $76 for Fable 5.2. Token appetite, not list price, drives most of that spread.
Further Reading
- AI agent benchmarks explained: SWE-bench, GAIA and tau-bench explains how agent benchmarks are built and scored.
- Open-weight LLM benchmark leaderboard for November 2026 covers Qwen, DeepSeek, GLM, Kimi and gpt-oss beyond coding.
- LLM API pricing in November 2026 across GPT, Claude, Gemini, Grok, DeepSeek and Mistral is the full price survey behind our MTok table.
- LLM evaluation harness architecture and benchmark contamination covers how to build your own private eval.
- Grok 4.7 explained and DeepSeek V4.1 Flash explained are model deep-dives for two rows in this table.
- External: the Terminal-Bench 4.1 release notes and Scale AI’s SWE-bench Pro public leaderboard.
References
All sources retrieved 19 November 2026.
- Terminal-Bench 4.1 official leaderboard — https://www.tbench.ai/
- Terminal-Bench 4.1 release notes — https://www.tbench.ai/news/terminal-bench-4-1
- Terminal-Bench 4.0 release notes — https://www.tbench.ai/news/terminal-bench-4-0
- Terminal-Bench 3.0 release notes — https://www.tbench.ai/news/terminal-bench-3-0
- SWE-bench leaderboards (Verified, bash-only) — https://www.swebench.com/
- OpenAI, “Why we no longer evaluate SWE-bench Verified” (23 Feb 2026) — https://openai.com/index/why-we-no-longer-evaluate-swe-bench-verified/
- Scale AI SWE-bench Pro public leaderboard — https://labs.scale.com/leaderboard/swe_bench_pro_public
- Aider LLM leaderboards — https://aider.chat/docs/leaderboards/
- Anthropic, Claude Opus 5.5 — https://www.anthropic.com/claude-opus-5-5
- Anthropic, Claude Sonnet 5.5 — https://www.anthropic.com/claude-sonnet-5-5
- Anthropic, Claude Haiku 5.5 — https://www.anthropic.com/claude-haiku-5-5
- Anthropic, Claude Fable and Mythos 5.2 — https://www.anthropic.com/claude-fable-and-mythos-5-2
- OpenAI API docs, GPT-6.2 Astra — https://developers.openai.com/api/docs/models/gpt-6.2-astra
- OpenAI API docs, GPT-6.2 Sol — https://developers.openai.com/api/docs/models/gpt-6.2-sol
- Google, Introducing Gemini 4 Carbon — https://blog.google/innovation-and-ai/models-and-research/gemini-models/introducing-gemini-4-carbon/
- Google, Introducing Gemini 4 Hydrogen — https://blog.google/innovation-and-ai/models-and-research/gemini-models/introducing-gemini-4-hydrogen/
- GitHub Docs, Copilot Fusion — https://docs.github.com/en/copilot/concepts/models/copilot-fusion
- Moonshot AI, Kimi K3.1 Pro — https://www.kimi.ai/blog/kimi-k3-1-pro
- xAI docs, Grok 4.7 — https://docs.x.ai/developers/models/grok-4.7
- Z.ai docs, GLM-5.3 — https://docs.z.ai/guides/llm/glm-5.3
- OpenRouter, DeepSeek V4.1 Flash 1017 — https://openrouter.ai/deepseek/deepseek-v4.1-flash-1017
By Riju — about
