Gemini 4 Argon coding test: eight tasks, hidden tests

Our Gemini 4 Argon coding test put Gemini 4 Argon and Claude Opus 5.5 on the same eight tasks, one call each, with hidden tests neither model could see. Both passed 105/105 checks on Python 3.14. Argon took 139.6 seconds in total against Opus 5.5's 57.2, and cost $0.042 against $0.112 at each vendor's list price.

Eight tasks, one run each, so read this as behaviour rather than a benchmark. Neither model won on correctness. The differences are time, cost, and one answer that needs a newer Python. Google lists Argon as generally available since October 13, 2026, and its introductory price of $2 per million input tokens and $10 per million output tokens runs through November 30; from December 1 it doubles to $4 and $20 (Google's pricing page, checked November 4, 2026).

How we tested

On November 4, 2026 we sent each task to gemini-4-argon and claude-opus-5-5, one call per task per model, with no system prompt and no reasoning setting. Both ran at their own default level: medium for Argon (Google's thinking docs, checked November 4, 2026) and medium for Opus 5.5 (Anthropic's effort docs, same day). Each task produced one scored answer per model.

Time is the provider's own latency for each call, added up; it leaves out our scoring runs. Cost is each vendor's list price applied to the token counts the API returned. OmniaKey sells access to both models, so we ran the test through it with one key; every price here is Google's or Anthropic's own rate, not ours.

A script pulled the code block out of each reply and ran it against a hidden unittest file that neither model saw, in an isolated Python process with a timeout. The first pass used the machine's system Python 3.9.6; we then scored the same stored replies again on Python 3.14.3, adding no calls and no cost.

The eight tasks

All eight are small Python jobs of the kind that turn up in a normal day: one bug fix, two small classes, a refactor, a parser, a duration formatter, a scheduling helper and a graph search. Each prompt described the required behaviour in plain prose; none of them included the tests.

Task 1: fix an interval merge bug

merge_intervals sorted and merged ranges but left touching pairs such as (1, 3) and (3, 5) separate. One comparison fixes it.

• Gemini 4 Argon (5.6 s): 12 of 12.
• Claude Opus 5.5 (2.9 s): 12 of 12.

Verdict: Tie on checks. Opus answered in about half the time.

Task 2: build a token bucket rate limiter

TokenBucket(rate_per_second, capacity) had to refill continuously, stay at or under capacity, and cope with now values that move backwards.

• Gemini 4 Argon (6.6 s): 10 of 10.
• Claude Opus 5.5 (4.8 s): 10 of 10.

Verdict: Tie. Both handled backward clocks.

Task 3: an LRU cache with hit and miss counters

LRUCache needed eviction order, update-in-place, stats() counts, and a list of keys from least to most recently used.

• Gemini 4 Argon (7.1 s): 10 of 10.
• Claude Opus 5.5 (4.1 s): 10 of 10.

Verdict: Tie. Opus was 3 s faster.

Task 4: refactor without changing behaviour

The module worked. The answer had to keep slugify and slug_counts and behave the same on Unicode letters, punctuation and repeated separators.

• Gemini 4 Argon (15.9 s): 12 of 12.
• Claude Opus 5.5 (8.7 s): 12 of 12.

Verdict: Tie. Both kept every pinned case.

Task 5: parse a log line into a dict

One key=value parser with quoted values, escaped quotes and backslashes, a UTC timestamp, and ValueError for duplicate keys, a bare key= and junk.

• Gemini 4 Argon (16.1 s): 13 of 13.
• Claude Opus 5.5 (10.9 s): 13 of 13.

Verdict: Tie. Both got the escaping right on the first try.

Task 6: format and parse durations

format_duration and parse_duration had to round half away from zero, drop empty parts (3601 becomes 1h1s), reject bad forms, and round-trip every value. Days are not printed: 90000 becomes 25h.

• Gemini 4 Argon (60.9 s): 0 of 14 on Python 3.9, 14 of 14 on 3.14.
• Claude Opus 5.5 (14.0 s): 14 of 14 on both.

Verdict: Tie on 3.14. On 3.9 the Argon answer never imported, which is the next section.

Task 7: free meeting-room slots

free_slots had to clip bookings to the working day, merge bookings that touch, drop gaps under 15 minutes, and reject bad input.

• Gemini 4 Argon (18.9 s): 17 of 17.
• Claude Opus 5.5 (5.0 s): 17 of 17.

Verdict: Tie on checks. Argon took almost four times as long.

Task 8: shortest path with a tie-break

shortest_path needed Dijkstra with the lexicographically smallest path among equal-length paths, plus parallel edges, self-loops and a no-path answer.

• Gemini 4 Argon (8.5 s): 17 of 17.
• Claude Opus 5.5 (6.8 s): 17 of 17.

Verdict: Tie. The closest call of the eight.

Results: passes, time and cost

On Python 3.14 both models passed all 105 checks. On Python 3.9.6 Argon passed 91, because one answer did not import.

Opus 5.5 answered every task faster. The gap was smallest on the graph task (8.5 s against 6.8 s) and widest on the duration task (60.9 s against 14.0 s).

At list price the eight tasks cost $0.042 on Argon and $0.112 on Opus 5.5, about 2.7 times as much. Argon's replies used 3,346 input and 3,525 output tokens in total; Opus 5.5's used 4,419 and 4,692. Both APIs reported 0 thinking tokens on every call, so thinking added nothing to the bill.

Google's list price is $2 per million input tokens and $10 per million output tokens until November 30, 2026, then $4 and $20 (Gemini API pricing, checked November 4, 2026). Anthropic's list price for Opus 5.5 is $4 and $20 (Anthropic pricing, same day). From December 1 the same tokens cost twice as much on Argon, bringing the two closer. Rates for both models are on the pricing page.

Eight tasks cannot separate two frontier models on quality. Pick on speed, price and the Python version your tests run.

What people using it say

The split shows up in public comments too. On Hacker News, October 31, A_D_E_P_T wrote: "Gemini 4-Argon is very good at coding. I prefer Opus 5.5 -- in large part because I've grown accustomed to Claude Code -- but Argon is undeniably strong." On October 28, seizethecheese wrote of local coding agents: "Argon is really bad. Literally the worst model in our initial ranking", with Opus 5.5 on top. On October 13, ariwilson reported that Argon "solved 10 of 11" small bug fixes from their own projects.

Those are user opinions about their own setups, not controlled tests. The negative comment came from someone testing an agent harness, not a raw API call like ours.

The one failure: Python 3.9 cannot import Argon's answer

Argon's duration answer added a type annotation of float | int | Decimal to a helper. Python 3.9 cannot evaluate that at import time, so the module raised TypeError: unsupported operand type(s) for |: 'type' and 'type' and all 14 tests failed before running.

Nothing in the logic was wrong. The same file imported and passed 14 of 14 on Python 3.14.3. The union syntax needs Python 3.10 or newer.

The scoreboard depends on the interpreter: on the machine's system Python 3.9.6, Argon finished 91 of 105 checks and Opus 5.5 finished 105. On 3.14 both finished 105.

If a server image or CI box still ships 3.9, that is the trap. Two habits cover it: name the Python version in the prompt, and score on the oldest version you support. For a 3.9 target, ask for Union[float, int] or for from __future__ import annotations at the top of the file.

What Google's own benchmarks say

Google's model card for Argon (checked November 4, 2026) lists five tests from its coding and security sections with an Opus 5.5 number. Argon leads three and trails two.

Those numbers are dated October 2026; the Notes column is empty for these rows, so thinking level, harness and attempts are not stated. The tests are also more agentic than our small functions.

Google's October 13 launch post claims the top spot on the Vals Index, which includes coding, and reports a rise of more than 35% in agentic code submissions inside Antigravity. Both are Google's own figures.

Our earlier October 23 three-task comparison with GPT-6 Astra had Argon passing all 12 hidden tests on a billing bug fix. Argon passed every check there and in task 1 here, and none of the new results contradict that.

How to run the same test yourself

One prompt file per task, sent unchanged to both models, is the whole setup. The endpoint we used is https://api.omniakey.com/v1; both models are on the Gemini 4 Argon and Claude Opus 5.5 model pages.

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.omniakey.com/v1",
    api_key=os.environ["OMNIAKEY_API_KEY"],
)
prompt = open("task6-duration.md").read()

for model in ("gemini-4-argon", "claude-opus-5-5"):
    reply = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}],
        max_tokens=8000,
    )
    open(f"{model}.md", "w").write(reply.choices[0].message.content)

1. Save each task as its own prompt file and send it unchanged, with no system prompt, so both models get the same words.
2. Send each prompt once per model at its default thinking level, and note the model ID, the time and the token counts.
3. Cut the code block out of each reply and save it as the module your tests import.
4. Run your hidden tests in a separate process with a timeout, and print passes next to the total.
5. Repeat the scoring on the oldest Python you support. The 3.9 run is where Argon's single miss appeared.
6. Work out cost from the returned token counts and each vendor's list price.

Frequently asked questions

Is Gemini 4 Argon good for coding?

On our eight tasks it passed all 105 hidden tests on Python 3.14, as did Opus 5.5. Google's own table has Argon ahead on three of five rows and behind on two.

How much does Gemini 4 Argon cost for coding?

Google charges $2 per million input tokens and $10 per million output tokens through November 30, 2026, then $4 and $20. Our eight tasks came to $0.042 at the introductory price. Opus 5.5 came to $0.112 at Anthropic's $4 and $20.

Is Gemini 4 Argon faster than Claude Opus 5.5?

No. Opus 5.5 was faster on all eight tasks in our run: 57.2 seconds in total against 139.6 seconds for Argon. The widest gap was the duration task, at 14.0 seconds against 60.9.

Why did Argon fail one task?

It did not fail the logic. Its duration answer used a float | int | Decimal annotation, which Python 3.9 cannot evaluate at import, so all 14 tests failed before running. The same file passed 14 of 14 on Python 3.14.

Sources checked

• Gemini 4 Argon model page
• Gemini API pricing
• Gemini API thinking levels
• Gemini 4 Argon model card
• Gemini 4 Argon launch post
• Gemini 4 Argon on Vertex AI
• Anthropic API pricing
• Claude Opus 5.5 overview
• Anthropic effort settings

All checked on November 4, 2026.

Update log

• November 4, 2026: First published. Tests run on November 4, scored on Python 3.9.6 and again on 3.14.3.