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.

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 Argon | For context |
|---|---|---|
| Intelligence Index v5.0 | 50 | #13 of 58 models; median 37 |
| Cost per Intelligence Index task | $7.68 | Price and verbosity in one number |
| Output speed | 82.9 tokens/s | Steady once it starts |
| Time to first token | 49.13 s | Median across models: 3.71 s |
| Output tokens used on the index | About 110M | Median: about 70M |
| Measured API price, per 1M tokens | $4.00 in / $20.00 out | Blended: $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 task | Why it matters for Argon |
|---|---|
| Passes out of 3 | Consistency beats one lucky run |
| Median wall-clock time | Includes the long first token |
| Median output tokens | Argon is verbose, and output drives cost |
| Cost per passed task | The 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.

