Bottom line first: if you use Claude Code / Codex for everyday coding, you should no longer treat “#1 on SWE-bench” as the only yardstick for choosing your main model. In 2026, the more reliable public stack is Terminal-Bench + SWE-rebench/DeepSWE + a cost dashboard; the final verdict still has to come from tasks in your own repositories.

What you’re evaluating is not “can it write a function,” but “can it act like an engineer over time”

If your workflow looks like this:

• Open Claude Code / Codex / OpenCode
• Give it a real repository
• Let it read the code, modify multiple files, run tests, inspect errors, and iterate
• Have it touch Docker, Git, Linux, and deployment along the way

Then what you’re evaluating is no longer a traditional coding model, but a Software Engineering Agent.

Benchmarks like HumanEval, where the model “writes a function from a docstring,” can still test the edges of intelligence, but they are almost a different sport from your daily workflow.

What changed in the 2026 leaderboard landscape

At a high level, the evolution looks like this:

Can chat → can write code → can act as a coding agent → wants to be an automated software engineer

The corresponding benchmarks are also changing:

1. Function-generation leaderboards (HumanEval / MBPP) — most are already saturated and no longer separate frontier models well.
2. Repository issue leaderboards (the SWE-bench family) — once the default answer; by 2026, the Verified subset has been shown to suffer from contamination, test-quality issues, and saturation all at once. OpenAI even publicly wrote about why they no longer use SWE-bench Verified to evaluate frontier coding.
3. Terminal and long-horizon agent leaderboards (Terminal-Bench, DeepSWE, SWE-rebench) — these are closer to a real agentic closed loop, and they have started to seriously report cost per task / tokens / steps.

In one sentence: the center of evaluation has moved from “does it write the right code?” to “can it close the loop inside an environment, and how much does that loop cost?”

Three public leaderboards are enough

First priority: Terminal-Bench

Official site: tbench.ai

It tests an agent’s ability to install dependencies, modify files, run commands, and complete tasks in a terminal. In form, it is the closest thing to the Claude Code / Codex session you actually use every day.

As of 2026-08, the rough slice I saw on the 2.1 leaderboard was:

• Claude Code + Fable 5: around 83.8%
• Codex + GPT-5.5: around 83.1%
• Swap the agent while keeping the same model, and both ranking and cost can move

How you read it matters: don’t just look at the overall #1. First look at the row for the harness you actually use.

Second priority: SWE-rebench, viewed alongside DeepSWE

• SWE-rebench: rolls fresh GitHub issues by time window to resist “memorized problems”; the leaderboard directly reports success rate, Pass@5, dollars per task, and tokens per task.
• DeepSWE: leans toward original long-horizon engineering tasks, while also reporting cost, output tokens, and agent steps.

These two are better suited for horizontal screening in 2026 than “SWE-bench Verified, already squeezed above 90%.”

For example, in one SWE-rebench window, top models may all hover around a 60% success rate, but the cost per task can differ by several times — that is the part that really hurts when choosing a daily driver. DeepSWE often shows the same pattern: some models are just over 70% but expensive, while others are slightly lower yet an order of magnitude cheaper.

When you need a harder, more contamination-resistant static ceiling, add SWE-bench Pro as a supplement (Scale, copyleft public set + private-repository design).

Third priority: Artificial Analysis Coding Agent Index

Entry point: Coding Agents dashboard

It combines DeepSWE, Terminal-Bench v2, SWE-Atlas-QnA, and others with equal weighting, while emphasizing cost per task. It is good as a “quick dashboard,” not as the sole source of truth.

If you can only track one

Terminal-Bench, and fix your attention on your own harness.

The reason is simple: 80% of your time lives inside the “terminal agent loop.” If a model is unstable in that form, a high score on an old SWE leaderboard will not save the day-to-day experience.

Why #1 on a leaderboard does not mean best to use

Common mismatches:

• Very high Verified score: may reflect old-problem exposure, harness specialization, or “passes the tests but is not mergeable.”
• Very high contest score: strong at algorithms, weak at modifying large repositories.
• Slightly higher absolute score: doubles token usage, making daily spend unbearable.
• #1 under one official scaffold: drops when moved to Claude Code’s tool protocol.

There is also one severely underestimated variable behind all this: harness dependence.

Princeton’s HAL decomposes performance into “model × scaffold × benchmark.” With the same model and a different scaffold, the gap can reach dozens of percentage points. So:

• To compare models, you must fix the harness
• To compare harnesses, you must fix the model
• If a vendor does not clearly disclose scaffold / retries / best-of-N, treat the score as marketing

How to decide when rankings conflict

Suppose:

• A is #1 on SWE
• B is #1 on Terminal-Bench
• C is #1 on LiveCodeBench

Use this order:

1. Terminal-Bench on your fixed harness
2. Success cost on SWE-rebench / DeepSWE (money and tokens)
3. Final review on your own private task set
4. LiveCodeBench gets no default vote unless you write a lot of contest-style algorithms

Which leaderboards you can safely skip

• HumanEval / MBPP: saturated + mismatched with the workflow
• Treating SWE-bench Verified as the sole main decision basis in 2026
• Launch-event numbers that do not disclose the harness
• OSWorld / GAIA / browser-agent leaderboards: unless your core job is computer-use

LiveCodeBench can serve as supporting evidence for “is it still smart?”, but not as the main evidence for choosing a Claude Code daily driver.

The KPIs you should actually optimize

Stop optimizing only for Accuracy. For a daily driver, you should care more about:

• Final task success rate (repository end state, not the last reply)
• Cost per successful task
• Tokens burned per successful task
• Latency per successful task
• Whether it drifts off course during long tasks
• Regression rate and number of human interventions

In one sentence:

In my Claude Code workflow, how much money, how much time, and how many human rescues does it take to complete one real software engineering task successfully?

Public leaderboards are filters; your private suite is the verdict

No single public leaderboard can fully represent your repository distribution, permission boundaries, and engineering taste. A more honest process is:

1. Use Terminal-Bench + SWE-rebench/DeepSWE + cost dashboards to screen 4–6 candidates
2. Fix Claude Code, or whichever agent you mainly use
3. Run a final review on 20–30 of your own tasks: bug fixes, feature additions, refactors, Docker, Git, APIs, long tasks
4. Route models into Primary / Reasoning / Fast tiers based on “success rate × cost × long-horizon stability”

Yes, I recommend model routing more than blindly believing one absolute main model can dominate everything.

The four candidates you want to evaluate: Grok 4.6 / Qwen3.8-Max / DeepSeek-V4 Pro / GLM-5.2

Everything above is about the yardstick. Once the yardstick is set, we can talk about the four daily-driver candidates you named.
The data below is based on official pages accessible as of 2026-08-13; if DeepSeek-V4 Pro 0813 is a hotfix after that window, public rolling leaderboards may not have included it yet, and I will flag that below.

First, DeepSWE: long-horizon engineering + cost per task

Source: deepswe.datacurve.ai (v1.1, page marked as updated to 2026-08-13)

Reference anchors from the same page: Claude Opus 5 max is around 74% / $11.84; GPT-5.6 Sol max is around 73% / $8.39.
In other words: among these four, none crushes the first-tier closed models on DeepSWE; but DeepSeek-V4 Pro’s $/success looks extremely attractive.

Next, SWE-rebench: fresh repository issues + $/task

Source: swe-rebench.com
Page window slice: 2026-05-15 → 2026-07-01 (111 problems / 65 repos)

How to read this:

• GLM-5.2 looks more like a daily-driver candidate that is stable on “fresh real issue fixing.”
• DeepSeek-V4 Pro has an average success rate on this leaderboard but is extremely cheap — more like a high-ROI / sub-agent / large-scale trial-and-error option.
• Grok 4.6 and Qwen3.8-Max cannot be judged from this window alone; a missing row ≠ bad, it only means the public rolling window does not yet give you comparable data.
• DeepSeek-V4 Pro 0813: if it was a mid-August hot update, the rebench window above naturally cannot cover it; treat 0813-related claims, especially Terminal-Bench claims, as vendor/secondhand signals until they are re-run under the official harness.

What about these four on Terminal-Bench?

The current Terminal-Bench 2.1 verified leaderboard shows rows for Claude Code / Codex / Cursor / Terminus and so on, but does not place Grok 4.6, Qwen3.8-Max, DeepSeek-V4 Pro 0813, and GLM-5.2 together in one complete verified main table.
The 2.0 historical leaderboard contains more older GLM/DeepSeek/Qwen/Grok versions, but you cannot use it to represent today’s feel for 4.6 / 3.8-max / V4 Pro / 5.2.

So for these four candidates, the correct way to use Terminal-Bench is not to “check the existing rank,” but:

Run each of the four models yourself through Claude Code, or Codex, according to the official harbor protocol.
That is exactly what TB is designed for: evaluating agent × model together.

Practical ranking of the four candidates under “public data + your usage”

This is not a final ranking. It is a shortlist recommendation — the final call still has to pass your Claude Code private tasks.

1. GLM-5.2 — the strongest public signal for a “daily main agent”
   Its rebench success rate is top-tier; its average DeepSWE result suggests it is more aligned with the “issue/repository repair” distribution, while original long-horizon engineering is not its strong suit. Suitable as the first Primary candidate.

2. DeepSeek-V4 Pro, including the 0813 version you mentioned — the best fit for “cheap but capable engineering labor”
   DeepSWE success is decent and its $ cost is extremely low; rebench success is average. Suitable for large-scale subtasks / initial screening / brute-force repair, while whether 0813 truly lifts terminal-agent performance must be verified with your local TB/private suite.

3. Grok 4.6 — the highest-ceiling option among the four on DeepSWE
   Its long-horizon engineering success rate looks the best, but it is more expensive; rebench still lacks a 4.6 row. Suitable as a hard-task / Reasoning-tier candidate, not something to rush into replacing your entire daily workflow with.

4. Qwen3.8-Max — balanced mid-tier, with the least complete data
   Upper-middle on DeepSWE, medium unit price; insufficient public rows on rebench/TB. Worth sending into your private final review, but not currently qualified to be canonized or eliminated based only on public leaderboards.

How they compare with closed-model anchors, to avoid self-delusion

On DeepSWE that same day, Opus 5 / GPT-5.6 Sol were still around 70%+ and more expensive.
For your kind of “long-term agentic development”:

• If budget is tight and tasks can be parallelized: GLM-5.2 as main + DeepSeek-V4 Pro as sub-agent is reasonable
• If individual tasks are hard and you are willing to pay more: put Grok 4.6 into the hard-task route
• Treat Qwen3.8-Max as a control first, then decide whether it deserves a place in the main routing after running your own 20 tasks

Minimum acceptance checklist for these four models, more useful than refreshing leaderboards again

Fix Claude Code, and run the same task set for each model:

1. 3 real multi-file bugs
2. 2 feature additions + tests
3. 2 Docker/WSL/dependency traps
4. 1 90-minute long task
5. Record: success rate, $/success, whether it goes off track, and whether tool calls break formatting

Whoever wins becomes the main model. Public tables only tell you that all four are worth testing, and that you should no longer use HumanEval as the tiebreaker.

The executable answer

Track these first:

1. Terminal-Bench
2. SWE-rebench / DeepSWE
3. Artificial Analysis Coding Agent Index, with SWE-bench Pro added when necessary

Top priority: Terminal-Bench, specifically the row for your own harness.

For the four models you named, the current public signal leans toward: “GLM-5.2 for daily main use / DeepSeek-V4 Pro for cost-efficiency / Grok 4.6 for hard problems / Qwen3.8-Max pending more data.”

Stop treating HumanEval, MBPP, and the already-saturated SWE-bench Verified as your main decision basis.

Public leaderboards reduce noise; your own task set makes the decision.

Research timestamp: 2026-08-13. Specific leaderboard scores may update weekly; hotfixes such as DeepSeek-V4 Pro 0813 should be judged by your own local re-runs. The framework is more durable than any single ranking.