The September 2026 agentic-coding benchmark landscape
Claude Opus 5.5 leads the big three terminal-agent benchmarks, GPT-6 Astra answers on science and automation — and every number below comes from the vendor that published it. Here's the landscape, attributed and caveated.
Benchmarks matter — and benchmarks lie
If you run coding agents in production, the model you pick determines your completion rate, your failure modes, and your bill. Agentic benchmarks like Terminal-Bench, FrontierCode, and CursorBench are the closest thing the industry has to a neutral playing field — tasks executed in a real terminal, judged by whether the work actually got done. But they are not neutral measurements. The numbers on this page were published by the vendors competing in them, each choosing its own harness configuration, effort budget, and prompting. Read them as directional evidence, not lab-certified truth, and always confirm on your own workload.
Every score below is attributed to the vendor that published it. "Anthropic reports…" means Anthropic ran the harness. No score on this page comes from an independent third-party audit.
The headline race: terminal agents
Terminal-Bench 4.0 puts models inside a real shell with a task, a deadline, and no hand-holding. On the September 2026 leaderboard, Anthropic reports:
| Model | Terminal-Bench 4.0 | Source |
|---|---|---|
| Claude Opus 5.5 | 66.4% | Anthropic |
| GPT-6 Astra | 57.9% | Anthropic |
| GPT-5.6 Sol | 37.3% | Anthropic |
An 8.5-point gap between the top two is meaningful at this level of the leaderboard — it separates "usually completes multi-step terminal work" from "usually gets stuck halfway." The drop to GPT-5.6 Sol at 37.3% shows how much agentic capability lives in the frontier tier versus the previous generation. OpenAI's counter-territory: Anthropic's own numbers credit Astra with the lead on Terminal-Bench-Science 0.1 at 64.6% versus Opus 5.5's 58.7% — science-flavored terminal work, where Astra's training evidently pays off.
The close one: FrontierCode
FrontierCode v1.1 tests full-repo software-engineering tasks — the kind of work where an agent reads a codebase, makes a change, runs the tests, and iterates. Anthropic reports Claude Opus 5.5 at 54.4% against GPT-6 Astra at 53.3%. A 1.1-point margin is close enough that harness noise could flip it; treat this as a statistical tie with a slight Opus edge. The interesting part isn't the winner — it's the price attached to each score. Anthropic reports that Opus 5.5 beats Astra's top FrontierCode score at roughly one-fifth the cost per task, because Opus 5.5's input pricing is $4 per million tokens against Astra's $10. That cost-per-task framing is the subject of our cost-per-task explainer, and it changes the read of nearly every benchmark table.
Editor work and automation: the split verdict
CursorBench 4.0 measures in-editor agent work — the "fix this bug in my repo" loop. Anthropic reports Claude Opus 5.5 at 57.8% versus GPT-5.6 Sol at 41.7%, a 16-point gap that suggests the frontier Claude models are meaningfully better at sustained, tool-using editor sessions than the previous OpenAI generation. On the automation side, the verdict flips: Astra leads AutomationBench at 41.4% versus Opus 5.5's 40.0% — a narrow lead, but a lead, and consistent with Astra's Terminal-Bench-Science strength. The pattern is coherent: Anthropic's Opus 5.5 dominates general software-engineering agent work; OpenAI's Astra is strongest where automation and science-flavored tasks are concerned.
Grok 4.7 does not appear in the vendor-published tables above — neither vendor included it in their reported runs. It did appear in our own independent evaluation, covered below.
Our own 3-model run: Claude won 4–0
Vendor tables tell you how models do on vendor tasks. So we ran our own check: an independent three-model evaluation — GPT-5.6 Sol vs. Claude Opus 5.5 vs. Grok 4.7 — on four tasks drawn from our production TypeScript codebase, the same kind of real-repo work our missions execute. Claude Opus 5.5 won all four. This is a small, internal evaluation, not a published benchmark: n=1 per task, all models ran on Cursor's default variants (Grok's default is the 2× Fast tier, which inflates its measured cost against the others), and the eval-only draft PRs (#473–484) remain unmerged. We're not claiming statistical significance — but the result agreed with the vendor-published direction (Opus 5.5 on top for repo-level TypeScript work), which is exactly what an independent check is for — confirming direction, not decimal points. A full writeup of the methodology and task set is planned; it isn't published yet, so we're not linking to it.
How to actually use these scores
✅ Do
Use scores to shortlist 2–3 candidate models. Then run your own tasks — the same prompts, repos, and success criteria your agents will face — and measure completion rate and cost per completed task. Keep a dated record; leaderboards move monthly.
🚫 Don't
Don't pick a model on a single percentage. A 1-point lead on FrontierCode is harness noise; a 16-point lead on CursorBench is signal. Don't ignore price: a cheaper model with a slightly lower score often wins on cost per completed task.
For governed missions specifically, scores are only half the selection problem. The other half is determinism of cost: a mission contract bounds acceptable cost, so the model that completes tasks cheapest — not the one with the highest benchmark — is usually the right default, with stronger models reserved for stages where failure is expensive. Our Astra vs. Opus 5.5 head-to-head works through that trade-off in detail, and the cost-per-task explainer shows the math.
Frequently asked questions
Which model leads the agentic coding benchmarks in September 2026?
Anthropic-published numbers put Claude Opus 5.5 ahead on Terminal-Bench 4.0 (66.4%), FrontierCode v1.1 (54.4%), and CursorBench 4.0 (57.8%). GPT-6 Astra leads on Terminal-Bench-Science (64.6% vs. 58.7%) and AutomationBench (41.4% vs. 40.0%). All figures are vendor-published and harness-dependent.
Can I trust vendor-published benchmark scores?
Treat them as directional evidence, not neutral measurements. The publisher chooses the harness, the effort budget, and the prompting. Scores are most useful for shortlisting candidates; your own tasks are the real benchmark.
Why does GPT-6 Astra win some benchmarks but not others?
Benchmarks measure different skills. Astra's reported strengths cluster around science-flavored terminal work and automation; Opus 5.5's reported strengths cluster around general software-engineering and in-editor agent work. Match the benchmark to your workload, not to a single "best model" headline.
Did MasterEngine run its own benchmark?
Yes — an independent three-model evaluation (GPT-5.6 Sol, Claude Opus 5.5, Grok 4.7) on four tasks from our production TypeScript codebase. Claude Opus 5.5 won all four. Caveats: n=1 per task, Cursor default variants (Grok's 2× Fast tier inflated its cost), and the eval-only draft PRs (#473–484) are unmerged. It's a small internal evaluation, not a published benchmark, and a full writeup is planned.
How should scores inform model choice for agent missions?
Combine scores with cost per task. A model that scores slightly higher but costs 2.5× more per token can easily lose on cost per completed task. For governed missions, bound cost in the contract and pick the cheapest model that clears your completion-rate bar — our cost-per-task explainer walks through the arithmetic.
From scores to decisions
⚖️ Astra vs. Opus 5.5
The head-to-head: pricing, where each model wins, and a verdict by use case.
💰 Cost per task
Why token price is the wrong metric — and the break-even math that matters.
📖 Execution chain
How governed missions specify, authorize, and verify work — regardless of model.