Back to blog

Gemini 4 Argon Coding Test: What the Benchmarks Actually Show

Gemini 4 Argon coding test data, honestly framed: the Artificial Analysis score, a 49-second first token, cost per task, and a 5-task test for your own repo.

Nov 1, 2026AINovaTools Team
Gemini 4 Argon Coding Test: What the Benchmarks Actually Show

Search for a Gemini 4 Argon coding test and you'll find plenty of launch-day enthusiasm and very few numbers you can check. Google's newest frontier model reached general availability on October 13, 2026. Nearly three weeks later, the most useful independent data comes from Artificial Analysis — and it says more about how Argon behaves than about how well it codes.

So this post does two things. First, it sorts out which results exist, which don't, and what the real ones mean in practice: wait times, verbosity, cost. Second, it gives you a five-task coding test with pass/fail rubrics to run on your own repository, because your codebase is the only benchmark that settles anything for you.

What coding test results actually exist

Three kinds of evidence are circulating, and they're not equally useful:

  • Google's launch benchmark table. Vendor-run, and not a clean sweep: as our guide to using Gemini 4 Argon notes, Google's own table still has Claude Opus 5.5 ahead on Terminal-Bench 4.0.
  • Creator demos. Launch-day videos built games and ran security reviews. Good for a feel of the model; impossible to compare run to run.
  • Independent measurement. Artificial Analysis is the closest thing to a neutral scorecard, so the rest of this section is about its numbers.

On the Artificial Analysis Intelligence Index v5.0, Gemini 4 Argon scores 50. That ranks it 13th of 58 models, well above the index median of 37.

Two of the index's components are squarely about code: Terminal-Bench 4.0 (agentic coding and terminal use) and FrontierCode 2.0 (agentic software engineering in open-source repositories). The others — AA-Briefcase, AutomationBench, AA-Omniscience, GDP.pdf, HLE-Diamond, CritPt v2 Hard and Terminal-Bench-Science — widen the lens beyond software engineering. So 50 is a composite, not a coding grade.

Here's the gap: the Artificial Analysis model page doesn't publish Argon's per-benchmark scores. There is no public Argon-on-FrontierCode number to quote, and if you see one in a thread, ask where it came from.

The numbers at a glance

Metric (Artificial Analysis)Gemini 4 ArgonFor context
Intelligence Index v5.050#13 of 58 models; median 37
Cost per Intelligence Index task$7.68Price and verbosity in one number
Output speed82.9 tokens/sSteady once it starts
Time to first token49.13 sMedian across models: 3.71 s
Output tokens used on the indexAbout 110MMedian: about 70M
Measured API price, per 1M tokens$4.00 in / $20.00 outBlended: $2.94

What the numbers mean in practice

Fast stream, slow start

At 82.9 tokens per second, a 1,000-token answer streams in about 12 seconds. The catch is the wait before it: a 49.13-second time to first token in Artificial Analysis's measurement, against a 3.71-second median. Argon thinks for a long time before it says anything, so that 1,000-token answer takes about a minute end to end.

That makes it a poor fit for tab completion or rapid back-and-forth chat, and a reasonable one for delegated work you'd walk away from anyway: agentic runs, code reviews, migrations.

Verbose by design

On the index, Argon generated about 110M output tokens against a 70M median — roughly 1.6 times as many. Output is the expensive side of the price sheet ($10 versus $2 per million at Google's intro rate), so that verbosity lands on your bill, not just your screen.

Cost per task beats cost per token

The number that captures both effects is cost per Intelligence Index task: $7.68. Token prices tell you the rate; cost per task tells you what a unit of finished work costs. For your own budget, measure cost per completed task on your workload — the test below records exactly that.

How to run your own Gemini 4 Argon coding test

Public benchmarks run on someone else's code. These five tasks run on yours. A few rules keep the result honest:

  • Use a repository you know, pinned to one commit, with a test suite that passes.
  • Hold the harness constant. Same agent tool, instructions, time and token limits, and reasoning-effort setting for every model you compare.
  • Run each task three times. One pass is an anecdote; three tell you about consistency.
  • Log four numbers per run: pass or fail, wall-clock time (including that long first token), output tokens, and cost.
  • Grade blind where you can. Have a teammate score the diffs without knowing which model wrote them.

Task 1: Fix a flaky bug

Setup: a test that fails intermittently, or a bug report with a reliable reproduction. Prompt: "This test fails roughly one run in five. Find the root cause and fix it. Do not add retries or sleeps. Explain the cause in three sentences."

  • Pass: the test passes 20 consecutive runs, the diff fixes a real cause (a race, shared state, a time dependency), and the explanation matches the change.
  • Fail: retries, longer timeouts, a skipped test, or an explanation that doesn't match the diff.

Task 2: Build a feature from a spec

Setup: a one-page spec for a small feature that touches at least three layers — say an API route, a service function and the UI or CLI. Include two acceptance criteria and one explicit non-goal.

  • Pass: both criteria met, existing tests still green, new tests cover the criteria, and nothing on the non-goal list got built.
  • Fail: scope creep, hardcoded values where the spec asked for configuration, or a missing layer.

Task 3: Write tests for tricky logic

Setup: a function with genuinely nasty edges — time-zone math, money rounding, a hand-written parser. Ask for a test suite and no changes to the code under test.

  • Pass: the suite covers the edges you know about (DST transitions, negative amounts, empty input), passes against current code, and catches a bug you plant afterward — flip one comparison operator and rerun.
  • Fail: tests that restate the implementation, edits to the code under test, or a suite that stays green after your planted bug.

Task 4: Refactor under constraints

Setup: a real refactor — split an oversized module, or replace a deprecated API — with hard constraints: public interface unchanged, no new dependencies, diff under 300 lines.

  • Pass: all tests green, public signatures identical, every constraint respected, and a diff a reviewer can read in one sitting.
  • Fail: a changed public signature, a new dependency, or a "refactor" that quietly changes behavior.

Task 5: Review a diff for bugs

Setup: take a real merged pull request and plant three bugs of known type — an off-by-one, a missing null check, a secret written to a log line. Ask for a review.

  • Pass: all three found, each with the correct file and line and a workable fix, and not buried under style nits.
  • Fail: a missed plant, an invented bug that isn't there, or a wall of formatting comments.

Score it

Record per taskWhy it matters for Argon
Passes out of 3Consistency beats one lucky run
Median wall-clock timeIncludes the long first token
Median output tokensArgon is verbose, and output drives cost
Cost per passed taskThe only cost figure that compares fairly

Run the same sheet against whatever you use today. The comparison is the point; a standalone Argon score tells you little.

Where Argon fits against Claude and GPT-6

Without public per-benchmark coding scores, we won't rank Argon against its rivals. What the available evidence does support:

  • Versus Claude: Google's own launch table shows Claude Opus 5.5 still leading Terminal-Bench 4.0. If your work is mostly agentic terminal coding, test both before switching.
  • Versus GPT-6: our GPT-6 vs Gemini 3 comparison breaks down how OpenAI's flagship trades capability for cost. GPT-6 Astra lists at $10 in and $50 out per million tokens, well above Argon's intro rate.
  • Where Argon makes sense: long, delegated tasks where a minute of thinking before the first token costs you nothing because you've already switched windows.
  • Where it doesn't: latency-sensitive loops — autocomplete, inline edits, quick chat — where you sit and wait.

Access is broad: the Gemini API paid tier, Google AI Studio, Vertex AI, Gemini Enterprise and the Antigravity coding surface, with a gradual rollout to Google AI Ultra subscribers. Our how-to-use guide maps each plan to its entry point, and the Gemini tool page covers pricing and plans.

Pricing recap: mind November 30

Google's launch-window pricing is $2 per million input tokens and $10 per million output tokens, running through November 30, 2026. Artificial Analysis currently measures the API at $4.00 in and $20.00 out, with a blended price of $2.94. We're reporting both figures as their sources publish them; check your own billing console before you budget.

Either way, the intro rate ends after November 30. If you plan to run your own Gemini 4 Argon coding test, the rest of November is the cheapest window you'll get.

FAQ

Is Gemini 4 Argon good at coding?

The independent evidence is a composite: Artificial Analysis gives it 50 on Intelligence Index v5.0, 13th of 58 and well above the median of 37, with two agentic coding benchmarks in the mix. Per-benchmark scores aren't on AA's model page, and Google's own table has Claude Opus 5.5 ahead on Terminal-Bench 4.0. Strong, then — but test it on your own repo before switching.

Why is Gemini 4 Argon so slow to respond?

It reasons before it answers. Artificial Analysis measures a 49.13-second time to first token, against a 3.71-second median across models, then a steady 82.9 tokens per second once output starts. Budget about a minute for a 1,000-token answer.

How much does a Gemini 4 Argon coding task cost?

It depends on the task, so measure it. Google's intro pricing is $2 per million input and $10 per million output tokens through November 30, 2026; Artificial Analysis currently measures $4.00 and $20.00 (blended $2.94) and puts cost per Intelligence Index task at $7.68. Because Argon is verbose, track cost per completed task, not per token.

How do I run my own Gemini 4 Argon coding test?

Run the five tasks above — flaky bug, feature from spec, tests for tricky logic, constrained refactor, diff review — three times each on a pinned commit, through the same harness you use for your current model. Log passes, wall-clock time, output tokens and cost per passed task.

Where can I use Gemini 4 Argon for coding?

Through the Gemini API paid tier, Google AI Studio, Vertex AI, Gemini Enterprise, and Antigravity, Google's coding surface. It's also rolling out to Google AI Ultra subscribers; our how-to-use guide walks through each route.

Tools mentioned in this article