Gemini 4 Argon costs half as much per token as Opus 5.5. Per task, it doesn't

Google’s Gemini 4 Argon is listed at $2 per million input tokens and $10 per million output, exactly half of Claude Opus 5.5’s $4 and $20. Artificial Analysis then ran both at high effort and found Argon costs more per task: $1.99 against $1.82. The cheaper model spends more tokens to get there.

That gap matters because the price won’t stay put. Google’s pricing page says the $2 and $10 rates apply through 30 November 2026 and rise to $4 and $20 on 1 December, the same list price as Opus 5.5. Cached input goes from $0.10 to $0.20 over the same date. Anything you benchmark in October is being measured at half price.

What the per-task numbers say

Google announced the model for developers on 13 October, on the paid Gemini API tier in AI Studio and Android Studio, with its developer post positioning it for long-horizon work such as code migrations. The post carries no benchmark figures. Artificial Analysis publishes a head-to-head, so those are the numbers to look at (Argon vs Opus 5.5, both High ):

On agentic coding and terminal work they tie. The difference is what it takes to get there: Argon emits 62k output tokens per task, 36k of them reasoning, against 36k and 18k for Opus. Fewer dollars per token, more tokens, a slightly higher bill, and almost three times the wall-clock time per task.

Run the arithmetic forward. If the token counts hold, the December price doubles Argon’s per-task figure to roughly $4, against $1.82 for Opus. That’s this article’s calculation, not a published number, and it assumes your tasks behave like the benchmark’s. They might not. But it’s the reason to measure your own tasks now, while the discount is flattering the result.

The comparison isn’t one-sided. Artificial Analysis lists Argon ahead on AutomationBench-AA (78% against 63%) and slightly ahead on SciCode, and behind on AA-Briefcase v1.1 (1486 against 1686 Elo). Argon’s “Default Fallback” labelling for Opus on that page isn’t defined, so treat the exact settings as approximate.

If you reach Argon through GitHub Copilot, where it went generally available on 13 October, the changelog says it’s billed at provider list pricing under usage-based billing. The same December step applies there.

Four behaviours that bite a migration

The Gemini docs include an eight-step migration checklist. Four of its items change results rather than just syntax, and a short probe confirms them.

from google import genai
from google.genai import types

PROMPT = "Write a C# method that merges overlapping DateTimeOffset ranges. Return only the code."
client = genai.Client()

def run(level, cap):
    r = client.models.generate_content(
        model="gemini-4-argon",
        contents=PROMPT,
        config=types.GenerateContentConfig(
            max_output_tokens=cap,
            thinking_config=types.ThinkingConfig(thinking_level=level),
        ),
    )
    c, u = r.candidates[0], r.usage_metadata
    print(f"{level:6} cap={cap:6} finish={c.finish_reason} "
          f"thinking={u.thoughts_token_count} output={u.candidates_token_count} "
          f"text_chars={len(r.text or '')}")

for level, cap in [("low", 8192), ("medium", 8192), ("high", 8192), ("high", 1024)]:
    run(level, cap)

Run against the live API with google-genai 2.32.0, it prints:

low    cap=  8192 finish=FinishReason.STOP thinking=None output=300 text_chars=1131
medium cap=  8192 finish=FinishReason.STOP thinking=None output=319 text_chars=1191
high   cap=  8192 finish=FinishReason.STOP thinking=1129 output=282 text_chars=1119
high   cap=  1024 finish=FinishReason.MAX_TOKENS thinking=1021 output=3 text_chars=0

The last line is the first trap. max_output_tokens caps thinking and output together. Set it to 1,024, a value plenty of existing apps carry, ask for high thinking, and the model spends 1,021 tokens thinking and 3 on the answer. The response is empty, and the finish reason is MAX_TOKENS. The docs tell apps with limits under 32K to raise them to at least 32,768, and to lower the thinking level rather than the cap if cost is the worry.

The other three came from a second probe:

temperature=0.2: ok finish=FinishReason.STOP chars=251
minimal level: ClientError: 400 INVALID_ARGUMENT. Thinking level MINIMAL is not supported for this model.
level+budget: ClientError: 400 INVALID_ARGUMENT. You can only set only one of thinking budget and thinking level.
budget only: ok finish=FinishReason.STOP chars=136

(Error text trimmed.) A temperature is accepted and, per the docs, ignored along with top_p and top_k, so a pipeline that relied on temperature 0 for repeatable output has lost that control without any error. minimal, which other Gemini models accept, is rejected here: the levels are low, medium and high. Setting a level and a budget together fails. A budget on its own was accepted in this run, but the docs say to use levels, so don’t build on that.

Two more from the docs that the probe can’t show. Explicit caching (cachedContents) isn’t supported, so code that creates caches needs to drop them and lean on implicit caching, which applies from 4,096 tokens and gives a 95% discount on hits. And the cache expires after 15 to 20 minutes without use, so an agent that pauses for review pays full input price on the next turn.

Long decode is a separate switch

Argon can write past the 65,536-token single-response limit, up to the 1,048,576-token window shared by input, thinking and output. The long decode docs are explicit that changing the model ID alone doesn’t enable it. You need a recent SDK (Python google-genai 2.30.1 or later) and max_output_tokens above 65,536. The response then arrives in hops, each ending in a CONTINUATION finish reason and a token, and the latest SDKs follow them automatically.

You pay for every token in every hop, including hops that were all thinking and returned no text. The docs also say it’s a poor fit for chat, extraction or agents making many short turns, and that it isn’t available on the OpenAI compatibility endpoint. For a code migration that really needs one long coherent output, that’s the feature. For an agent loop with small edits, it’s an invoice.

What to do before 1 December

Pick five to ten real tasks from your own backlog, the kind an agent has already completed and a human accepted. Run each on Argon at low, medium and high, and on whatever model you use now. Record total tokens, wall-clock time and whether the result passed your tests, and compute cost at both the October and December rates. The Gemini docs themselves advise picking the lowest thinking level that meets your quality bar, and that advice is the cheapest lever here.

If Argon at low or medium passes your tasks, the December price may still beat what you pay now. If it only passes at high, take the 62k-token figure seriously and plan for the higher bill.