Best LLM for Coding: What Passed Our Terminal Test

Best LLM for coding right now: for agentic work in a terminal, Claude Sonnet 5.5 has the strongest published score of the models below, and it passed all three of our test runs. For large real-codebase work, look at Gemini 4 Argon and GPT-6.1 Sol, but know that our own test did not include them. Pick by the kind of task you do most, then check it on your own repo.

What's the best LLM for coding right now?

There is no clean single answer, because vendors report different benchmarks and rarely run the same ones.

Anthropic reports that Claude Sonnet 5.5 scores 70.6% on Terminal-Bench 4.0 (agentic terminal coding), 55.5% on CursorBench 4.0 (real Cursor session tasks), and 46.2% Max / 52.1% Xhigh on FrontierCode 1.1 (Claude Sonnet 5.5 announcement). Google DeepMind's model card for Gemini 4 Argon reports 57.4% on Terminal-Bench 4.0, but 77.9% on DeepSWE v1.1 (real-codebase software engineering) and 91.9% on Vibe Code Bench (Gemini 4 Argon model card).

Read that as a split in strengths. On the shared terminal benchmark, the Sonnet number is higher. Argon's own card puts its real-codebase and vibe-coding numbers well above its terminal score. These are vendor-reported figures from each vendor's own setup, so treat them as a starting point.

OpenAI states that on DeepSWE v1.1, GPT-6.1 Sol matches GPT-6 Astra's complex software-engineering performance at roughly one-fifth of Astra's token price (Introducing GPT-6.1 Sol). That makes Sol the one to try if cost on hard tasks is your constraint.

Which model is best for my language and tasks?

None of the figures above is split by programming language, and we did not test languages separately. Anyone claiming a clear per-language winner from this data is guessing. Match the benchmark to your task instead:

• Writing and fixing code through an agent in the terminal: Terminal-Bench is the closest published match. Among the models cited here, Sonnet 5.5 scores highest on it (70.6% against Argon's 57.4%, per the Claude Sonnet 5.5 announcement and the Gemini 4 Argon model card).
• Working inside an editor session: CursorBench uses real Cursor session tasks, and Anthropic publishes a Sonnet 5.5 result on it.
• Changes across a large, real codebase: DeepSWE is the relevant measure. Gemini 4 Argon and GPT-6.1 Sol both report on it, per the links above.
• Generating something new from a loose prompt: Vibe Code Bench is the nearest measure, and Argon reports a high score there.
• Debugging and refactoring: no benchmark above isolates these. Test them on a bug you already solved and a refactor you already did, and compare the results with what you know is right.

How do these models do on real coding tasks, not just benchmarks?

We ran a first-hand test. Imagera Code is a coding agent that runs in the terminal and lets you choose the model per session. We had it fix the same small project with eight models, three runs each. Here are the results:

How we tested

Task: a small JavaScript project with 3 bugs and 4 failing tests. Each model got the same instruction in Imagera Code 1.18.33 (run 2026-11-03): run the tests, fix the code, do not touch the tests. A run passes only if every test passes afterwards and the test file is unchanged. Tokens are input plus output over all of a run's model calls.

Here is the code change the agent made in the lead run:

--- src/cart.js (before)
+++ src/cart.js (after)
@@ -1,7 +1,7 @@
 // Checkout helpers for a small shop. Prices are whole cents.
 
 export function subtotal(items) {
-  return items.reduce((sum, item) => sum + item.price, 0);
+  return items.reduce((sum, item) => sum + item.price * item.qty, 0);
 }
 
 const CODES = { SAVE10: 10, SAVE25: 25 };
@@ -10,11 +10,11 @@
 export function applyDiscount(cents, code) {
   const percent = CODES[code];
   if (!percent) return cents;
-  return cents - percent;
+  return Math.round(cents * (100 - percent) / 100);
 }
 
 export function formatPrice(cents) {
-  return `$${Math.floor(cents / 100)}.${cents % 100}`;
+  return `$${Math.floor(cents / 100)}.${String(cents % 100).padStart(2, '0')}`;
 }
 
 export function total(items, code) {
Copy

What it shows. Every model passed 3 of 3. Token use was close across models, with medians from 42k to 67k. Speed was not close. DeepSeek V4.1 Flash 1017 was fastest at a median of 12.3 s, with DeepSeek V4.1 Flash at 13.2 s. The default, GLM 5.3 Flash, took 17.4 s. DeepSeek V4 Pro 0813 (24.1 s), Claude Sonnet 5.5 (26.4 s) and GLM 5.3 (32.5 s) sat in the middle. Claude Haiku 5.5 took 173.9 s and GPT-6 Luna took 339.4 s, at similar token counts. For a fix you wait on, that gap matters more than any difference in correctness we measured.

What it does not show. It is one small project, so it is not a benchmark. It says nothing about code quality beyond passing, large codebases, other languages, or ambiguous requirements. The table reports time and tokens only. We did not record a per-model cost comparison, so it has no cost column, and tokens are the only usage measure we can give you.

Gemini 4 Argon and GPT-6.1 Sol were not in this run. We tested the eight models listed, and we have no first-hand data on those two. Our large-codebase pointers to them rest on the vendor figures above, not on our own runs. Test them on your repo before relying on that.

One earlier result keeps us honest. In our 2026-09-30 benchmark of the same CLI, a different two-bug project with 3 runs, DeepSeek V4.1 Flash passed 0 of 3, and one vendor produced runaway output. The same model passed 3 of 3 here. Results swing by project, so a clean sweep on a small task is not a guarantee on yours.

What will each model cost, and what are the trade-offs?

We do not quote per-token prices, because they change and differ by plan. The trade-offs you can reason about are these:

• Speed: in our run the slowest models were not more accurate. Waiting minutes on a small fix adds up across a day.
• Token use: it was similar across models in our test, so on a small task token count did not separate them. On larger tasks, measure it yourself.
• Price on hard tasks: OpenAI's claim for GPT-6.1 Sol is about cost at matched DeepSWE performance, which is worth testing if you run many complex tasks.
• Usage limits and context size: both depend on the plan and the model version you are given. Read the current limits before committing, especially if you feed in whole repositories. Our test did not stress context size.

For Imagera Code, what each model costs you is on the plans page. Because you pick the model per session, you can use a fast model for routine fixes and a stronger one for hard problems.

Can I use it in my IDE or agent, and is it safe for company code?

Check that your editor or agent lists the exact model version before you plan around it. Anthropic's CursorBench result for Sonnet 5.5 comes from real Cursor session tasks, which is a good sign for editor use, but it is not a guarantee about your setup.

Before giving any model your company's code:

• Read the data-use and retention terms of the specific plan you would use, and prefer a business plan over a personal one.
• Keep secrets, keys and customer data out of the working directory.
• Get approval from your security team if your policy requires it.
• Run a terminal agent on a branch and review every diff. It executes commands on your machine, so treat its output like a contractor's pull request.

How do I try it?

Run it on a bug you have already fixed, with two or three models, and compare time and result.

npm i -g imagera-code
imagera-code login
cd your-project
imagera-code run -m imagera/z-ai/glm-5.3-flash "Run the tests and fix what fails"
Copy

Start with the default, then switch the model per session and see whether the extra wait buys you anything.