Best model for coding? Which model fits which coding-agent job

Which models make up the top, mid and entry tiers at each provider?

When you choose a model for a coding agent, you choose two things at once: the model itself and how much it thinks. We covered the second, effort, in the previous post, and how to read benchmark scores in the SWE-bench post. This post looks at the model itself: how good each one is at coding, what it costs per task and how you choose it in five tools. We put each provider’s models in three tiers:

Source: the three providers’ model and pricing pages (Anthropic, OpenAI, Google), 20 October 2026. Prices are input / output per MTok, standard tier; at OpenAI for prompts up to 272K tokens, at Anthropic for Haiku 5.5 prompts up to 100K tokens. The second sentence in each cell is the provider’s own description.

Anthropic has one more model above Opus: Fable 5.1. Anthropic presents it as its most capable model open to all customers; its price is $10 input and $50 output per MTok. In the table we still put Opus 5.5 in Anthropic’s top tier, because Anthropic recommends starting most work with Opus.

The list prices show a match: Sonnet 5.5, GPT-6.1 Sol and Gemini 4 Argon all charge $2 input and $10 output per MTok today, and Haiku 5.5 and GPT-6 Luna share a price too. By contrast, each of Opus 5.5’s token prices is twice Sonnet 5.5’s, and Astra’s are five times Sol’s. But the same token price does not mean the same cost per task; one model can take more steps to finish the same job. We show this with measurements in the next section.

In long agent sessions, three thresholds change the price. On Haiku 5.5, every request whose prompt goes over 100K tokens costs 5 times as much ($0.50 / $2.50), and tokens read from the cache count toward that number too. At OpenAI, a request over 272K tokens costs twice as much for input and 1.5 times as much for output. At Google, the threshold is a date: Argon’s price doubles on 1 December, 3.8 Flash’s on 1 January 2027.

In an agent session, most of the bill is tokens read from the cache; Anthropic also writes that they make up most of the cost of agentic and coding work. For cache reads, Opus 5.5 charges $0.20 per MTok, Sonnet 5.5 $0.10 and Haiku 5.5 $0.01. Once the prompt goes over 100K tokens, Haiku’s becomes $0.05, and the gap to Sonnet shrinks from tenfold to twofold. That is why the entry tier’s price advantage melts away as a session grows.

How good is each model at coding, and what does it cost?

Price lists are written per token, but what matters to you is the cost of a finished job. Anthropic’s documentation also recommends comparing models by cost per completed task, not per token. So we looked at two kinds of measurement: an independent index that measures each model inside its own coding tool, and the vendors’ own measurements. Results a vendor reported are marked as such.

Artificial Analysis’s Coding Agent Index measures a model not on its own but inside a coding tool: Claude models run in Claude Code, OpenAI models in Codex, Gemini models in Antigravity. It has 303 tasks from three benchmarks, and each task is attempted 3 times. Cost is calculated at API prices, not on a subscription plan. From each family we picked the rows of the top-, mid- and entry-tier models; for Anthropic we also added Fable 5.1’s row:

The chart is not a ranking: the rows were measured at different effort levels, and the index measured some models at only one level. When you read it, look at three things:

• In two families the mid tier comes close to the top tier. In Codex, GPT-6.1 Sol scored 61.4 points at medium and GPT-6 Astra 61.6 at max; per task $0.70 and $7.47, taking 11 and 29 minutes. In Claude Code both models were measured at max: Sonnet 5.5 scored 68.4 points and Opus 5.5 66.0, at $14.19 and $13.04 per task. Fable 5.1, a step above Opus, did not get ahead of either of them at max either, with 62.2 points.
• Cheap tokens do not mean a cheap task. Sonnet 5.5’s token price is half of Opus’s, but at max it finished a task in 266 steps and 87 minutes on average; Opus took 155 steps and 64 minutes. It works the other way too: Fable 5.1’s input and output prices are two and a half times Opus’s, but at max it finished a task in 37 steps and 35 minutes on average, and at $12.39 per task came out slightly cheaper than Opus. Gemini 3.8 Flash took 188 steps per task on average; at $2.47 per task it cost more than Sonnet 5.5 running at high ($1.24).
• Effort makes a big difference within the same model too. At high, Sonnet 5.5 scored 55.0 points, at $1.24 and 12 minutes per task. We compared the levels one by one in the effort post. Anthropic’s documentation also says that tuning effort is often a better lever than switching models.

The chart has two limits. The index measured Opus 5.5 and Fable 5.1 only at max; there is no independent measurement at medium, Opus’s default in Claude Code. Also, when a model refuses for safety reasons, another model can finish the attempt, and the attempt still counts: of 909 attempts, another model finished 78 in the Opus 5.5 max row, 74 in the Fable 5.1 max row and 45 in the Sonnet 5.5 max row. The index also marks Fable’s row with the note “with fallback”.

A gap of a few points may also be noise. On Terminal-Bench 4.0’s own leaderboard, Opus 5.5 (max) in Claude Code scores 64.85% ± 3.11 and Sonnet 5.5 (max) 61.82% ± 2.94; each row comes from 330 trials. In the component Artificial Analysis takes from the same benchmark, the order is reversed: Sonnet 5.5 66.2, Opus 5.5 63.1. So a three-point gap between these two models does not tell you which one is better. Anthropic also writes that at this level of capability, benchmark margins are a less reliable guide to real-world differences; Epoch AI, for its part, rated Terminal-Bench 4.0 as flawed. We covered how to read a score in the SWE-bench post.

When is a top-tier model worth the money?

The question is the same in all three families: when does the top-tier model earn back its higher token price? In the measurements we have, the mid tier at a slightly higher setting catches up with the top tier in two families, and not in the third. For each family we put the two closest measurements of the top and mid tier side by side:

Anthropic’s measurement is the clearest example. According to the document, each of Opus 5.5’s token prices is twice Sonnet 5.5’s, yet Opus at low solves tasks at the same rate as Sonnet at its default setting and costs only 7% more per solved task. Run Opus at its own default, medium, and the solve rate becomes 92.8% and the cost $0.22: for about five extra points you pay twice as much per solved task. This is the vendor’s measurement on a subset of SWE-bench Pro, and it cannot be compared with the public leaderboard.

Going one step above Opus brought no extra points in this table. At Fable 5.1’s own default, high, its solve rate in a single run is 92.3% and its cost per solved task $1.19. Anthropic counts this as the same result as Opus at medium, within run-to-run variation; so on this set Fable did not beat Opus, and it cost about five times as much per solved task. The document also says that both models largely hit the ceiling on this set.

Where does Opus earn its five extra points? Anthropic and Google give the same answer: on complex, long, multi-step work. Anthropic recommends Opus 5.5 for autonomous coding that runs for hours and for large refactors, and Sonnet 5.5 for everyday coding; the Sonnet 5.5 announcement also writes that Opus remains clearly stronger at open-ended work that needs sustained judgment. The path Anthropic recommends for Fable 5.1 also starts with Opus: if Opus falls short even at xhigh or max on demanding reasoning or long-horizon agentic work, you move to Fable. Google recommends Gemini 4 Argon for complex software engineering and reasoning tasks, and its pricing page says it is built for autonomous multi-step agents. OpenAI draws the line elsewhere: it presents GPT-6.1 Sol as the model that gives close to Astra’s performance at a lower cost, and Codex’s documentation recommends starting with Sol even for ambiguous, multi-step work; it leaves Astra for when cost and latency don’t matter. Anthropic’s cost document also gives a yardstick: compare models on the hardest tenth of your work, not on its typical task, because the bill is decided by the tasks the cheaper model fails.

The Google family looks different. In the independent index, 3.8 Flash did not come close to Argon’s score; but the two models were measured in different tools (Argon in Antigravity CLI, Flash in the Antigravity SDK). GitHub Copilot also puts 3.8 Flash in the same group as Haiku 5.5 and GPT-6 Luna, for fast help with simple or repetitive tasks. Taken together, these two sources place Google’s mid tier closer to the entry tier in a coding agent.

The tools’ defaults do not always match this advice:

• Claude Code has started with Opus 5.5 on the Pro, Max, Team and Enterprise plans since 22 September (version 2.1.280), and on the API it starts with Opus 5.5 too. Yet its own costs page says Sonnet handles most coding tasks well and to keep Opus for complex architectural decisions and multi-step reasoning; it also traces unexpectedly high bills mostly to Opus left as the default. One more detail: in Claude Code, Opus 5.5, Sonnet 5.5 and Haiku 5.5 start at medium effort, whereas in Anthropic’s measurement above, Sonnet’s default is high. When you switch to Sonnet, raise effort to high as well.
• In Codex, the default model is the mid-tier GPT-6.1 Sol.
• In GitHub Copilot you choose the model from the picker or with Auto; we cover Auto below.
• In Cursor, the Plus plan gives you only Cursor’s own models. You use Claude, GPT and Gemini models on Premium and above, paying the API list price from credit you load in advance.
• In Antigravity, the free plan and Google AI Plus have only 3.8 Flash among the Gemini models; Gemini 4 Argon, Claude Sonnet 5.5 and Opus 5.5 need a Google AI Pro subscription that is not a trial, or a higher one.

On a subscription, the top tier uses up your limit faster. Codex is the only tool that writes this as a message count per model: according to its pricing page, the estimated number of local messages in a five-hour window on the Plus plan is 5–45 with GPT-6 Astra, 15–160 with GPT-6.1 Sol and 350–3,000 with GPT-6 Luna. In the other tools:

• Claude: the plans page says that how much you can use depends on the model you pick, but gives no ratio. Claude Code shows separate limit messages for Opus and Sonnet; when you hit one, you can switch to the other family and keep working.
• GitHub Copilot: since 1 June 2026, usage is calculated per token at each model’s API price. A model whose price is twice as high also uses up your AI credits twice as fast for the same number of tokens.
• Cursor: the weekly pool covers Cursor’s own models, and each model draws from the pool at a different rate; you pay for third-party models from credit, not from the pool.
• Antigravity: Gemini models and Claude and GPT models draw from separate five-hour and weekly limits.

Can you write code with entry-tier models?

As the main agent, the evidence says no; as a helper, yes. Anthropic’s Haiku 5.5 announcement says so itself: for complex agentic coding, Sonnet 5.5 and Opus 5.5 are the better choice; Haiku 5.5 pairs well with them as a subagent on coding work and reliably handles jobs like summaries, compaction and classification. In the table in the same announcement, Haiku 5.5 scores 39.2% on Terminal-Bench 4.0, Sonnet 5.5 70.6% and GPT-6 Luna 16.4% (as reported by Anthropic).

The independent index also shows where the gap is. On the DeepSWE tasks, which have the model write code in Claude Code, Haiku 5.5 stayed between 45.4 and 49.0 at every effort level, and Sonnet 5.5 between 61.9 and 72.0; raising effort did not close that gap. On SWE-Atlas-QnA, which has the model answer questions about a codebase, the gap is small: Haiku 5.5 scored 51.6 at xhigh and Sonnet 5.5 44.9 at medium. The entry tier falls furthest behind when writing code, and least when reading code and answering questions about it.

Being cheap per task is also only half true. At medium, Haiku 5.5 cost $0.23 per task, but it finished a task in 14 minutes and 44 steps on average; Sonnet 5.5 at low: $0.48, 6 minutes and 19 steps. Haiku’s score is lower too: 33.6 against 42.1. Anthropic’s fastest model came out slower per task.

The other two families put their entry tier in the same place. Codex’s documentation recommends GPT-6 Luna for fast, narrowly scoped agents that handle clear, repeatable or high-volume work; on Terminal-Bench 4.0’s leaderboard, Luna running at max in Codex scores 16.36% ± 2.72. Google presents Gemini 3.5 Flash-Lite as a low-latency, low-cost model for subagent tasks and document parsing.

In Claude Code, the built-in Explore subagent, which searches the codebase, arrived with version 2.0.17 (15 October 2025) running on Haiku; since version 2.1.198 (1 July) it runs on the main session’s model. So if you want an entry-tier model to do the searching, you set that up yourself. Here is how in five tools:

Source: each tool’s documentation and release notes, 20 October 2026.

Here is an example definition for Claude Code. When the name field is Explore, it takes the place of the built-in agent; limiting its tools to reading also keeps its job narrow:

---
name: Explore
description: Searches and reads the codebase, does not change files
tools: Read, Glob, Grep
model: haiku
---
Find the requested code. Write a short report:
file path, line and a one-sentence description.

One caution: as a searching subagent reads large files, its prompt grows. On Haiku 5.5, every request over 100K tokens costs 5 times as much, so keep the subagent’s report short and the set of files it reads narrow. We covered how subagents work in the subagents post.

Does Auto mode or using two models together help?

There are ways to let the tool pick the model, or to run two models together. The rule that comes out of Anthropic’s measurements is short: before you add a second model, tune the single model’s effort, because most work ends there; build a two-model setup only if it beats the single model’s curve of score against cost across all its effort levels.

GitHub Copilot’s Auto is available on all plans. In VS Code, Copilot CLI and the Copilot app it has three tiers: Efficiency, Balance and Intelligence. The tier changes which model a request goes to; you still pay the price of the model Auto picked, with a 10% discount on paid plans. Copilot shows which model each answer came from, and the CLI prints it in the terminal. On plans for individuals, Auto can also use models that are under evaluation; you can turn this off.

Cursor’s Auto depends on the plan. According to the pricing page, the Plus plan has no Auto; the other individual plans have only Cost mode, and whichever model answers, the request draws from the weekly pool like a Cursor model. Balance and Intelligence modes are on Teams and Enterprise; there a request is paid at the list price of the model it was routed to, and which model answered is hidden by default. Cursor’s Router page, however, says that all Auto modes are paid at the routed model’s list price; on 20 October 2026 the two pages did not agree.

The model documentation of Claude Code, Codex and Antigravity does not describe an Auto that picks a model per request. Gemini CLI has Auto, which picks the model by the complexity of the task; on 18 June 2026, Google replaced Gemini CLI with Antigravity CLI for free-tier and Google One users, and it recommends Antigravity for Gemini 4 Argon.

opusplan is a model setting in Claude Code that splits the work between two models: it uses Opus in plan mode and Sonnet for execution. Because each model keeps its own cache, every time you enter or leave plan mode counts as a model switch and the cache starts over; in a long session this shows up on the bill.

Advisor lets the model in Claude Code consult a stronger second model at key moments: before it commits to an approach, when it is stuck on the same error, and before it finishes the job. It works on a subscription and on the API. In Anthropic’s measurement with current models, the one pairing that consulted often scored 1.7 points higher than the single model on a coding benchmark; that gap is at the edge of run-to-run variation, and the cost is about 2.1 times as much. When the model consulted rarely, the pairing scored the same as the single model or lower.

Can a local model replace these models?

With today’s evidence, no measurement shows that it can as the main agent. Independent leaderboards also measure open-weight models, but those whose size is known are server-class: GLM-5.3-Flash, for example, has 320 billion parameters (18 billion of them active for each token) and, on Terminal-Bench 4.0 inside Claude Code, scores 35.76% ± 3.54. We found no independent coding-agent measurement of a model that clearly fits on a laptop.

Hardware sets a limit too. Ollama sets the context window by VRAM: below 24 GiB the default context is 4K tokens. For coding tools, though, it recommends at least 64,000 tokens, and memory needs grow with the context. Google, for its part, recommends for Gemma 4 26B A4B at least 24 GB of VRAM or unified memory. This is how a local model connects in five tools:

Source: the documentation of the tools and of Ollama, 20 October 2026. Ollama also asks for at least 64K of context for Claude Code and Codex.

Choosing a local model does not mean your code will not leave the machine. GitHub’s note says it plainly: choosing a local model does not turn on offline mode or turn off GitHub telemetry; in the CLI you turn on offline mode separately with COPILOT_OFFLINE=true. In Cursor, requests go through Cursor’s servers so the final prompt can be built. If your code must not leave the machine, check the tool’s whole path, not just the model.

The most sensible place to try a local model is the work entry-tier models do: jobs like searching a codebase, summaries and classification, which rest on reading and whose output can be checked. Do that by measuring on your own tasks too; the independent measurements above do not cover models of this size.

Which model should you pick for which job?

What the evidence has in common: the mid tier is enough for most work, the top tier makes a difference on long, ambiguous work, and the entry tier stays cheap as a helper. For common jobs, here are the matching models in the three families:

The reasons behind the cards are above. The mid tier for everyday work, because in Anthropic’s measurement Sonnet at its default solved tasks at the same rate as Opus at low, and in the independent index Sol at medium caught up with Astra’s score at max. In the Google family, Argon for everyday work too, because in the independent measurement 3.8 Flash did not come close to it. For long, ambiguous work, the top tier at Anthropic and Google, because both recommend it for that work and the extra points are won on hard tasks; at OpenAI, Codex’s advice is to stay with Sol and raise effort. At Anthropic, if Opus falls short even at xhigh or max, the next step is Fable 5.1. The entry tier goes in subagents, because it falls behind at writing code but comes close at reading code and answering questions about it.

For your own work, the most reliable path is a measurement. The vendors’ advice is similar: Anthropic recommends comparing models on your own work, by cost per solved task and with your hardest tasks, and OpenAI recommends trying the same inputs and keeping the lightest setting that meets your quality bar. In practice, pick a handful of tasks from your work, run each model several times in its own tool, and write down the cost per solved task and the time. If you have tests, run at a cheap setting first and repeat only the failures at a higher one; we explained why that is cheap in the effort post.