Gemini 4 Argon for Agentic Coding: When It Beats Opus 5.5

Gemini 4 Argon is Google's frontier model, generally available since October 13, 2026. For agentic coding it leads on long-horizon tasks (77.9% DeepSWE v1.1) but trails Claude Opus 5.5 on terminal work (57.4% vs 66.4% Terminal-Bench 4.0). It costs $2/$10 per million tokens until November 30, then $4/$20, which matches Opus 5.5.

What is Gemini 4 Argon?

Gemini 4 Argon is Google DeepMind's top model, with the API ID gemini-4-argon. Google moved it from limited preview to general availability on October 13, 2026, across the Gemini API, AI Studio, the Antigravity desktop app and CLI, the Gemini app, and Gemini Enterprise (Google's launch post).

The context window is 1,048,576 tokens, shared between input and output. That shared part matters. Thinking tokens, function calls and the answer all come out of the same pool. A single request caps output at 32,768 tokens without streaming and 65,536 with it, and a feature Google calls long decode hands back a continuation_token so the SDK can keep going past that cap (Gemini API docs). The model card gives a knowledge cutoff of March 2026. Inputs can be text, images, video, audio or PDF. Output is text only.

Google's own coding claims are big, and they're Google's: a Chrome refactor across hundreds of files finished in weeks instead of months, agentic code submissions in Antigravity up more than 35%, and "shortcut attempts" down to 2%. Nobody outside Google can check those. The benchmarks below are at least on a shared scoreboard.

Gemini 4 Argon coding benchmarks vs Claude Opus 5.5

Argon wins the long-horizon and long-context rows. Opus 5.5 wins terminal work and the harder software-engineering set. These numbers are all from Google's model card, so read them as vendor-reported:

The nine-point Terminal-Bench gap is the one I'd weigh most. That benchmark is closest to what Claude Code does all day: run a command, read the output, decide the next command. Argon is effectively tied with Fable 5.1 there. The GraphWalks gap points the other way. At 256k to 1M tokens, Argon keeps its footing (84.2%) while Opus drops to 66.8%, so for "read this whole service and tell me where X happens" Argon has a real edge.

Independent scores are less flattering. Artificial Analysis puts Argon at 53 on its Intelligence Index against 58 for Opus 5.5, and Argon sits 8th on Code Arena WebDev, according to a DEV roundup. That same roundup quotes a different Astra Terminal-Bench number (62.1%) from the model card, so I've kept the model card's figures in the table.

The one real-repo test so far

The most useful data point isn't a benchmark. paddo.dev replayed six merged changes from a production monorepo (11 to 26 files each) against Argon, Opus 5.5, Sonnet 5.5 and GPT-6.1 Sol, 20 runs per model, graded by the tests that shipped with the original fix. Argon ran inside Claude Code via OpenRouter.

So on real code, the vendor ranking reversed: Argon passed more runs than Opus. It also took about 2.2x as long on the change both were timed on (991 seconds per run vs 455). One codebase and small samples, as the author says. Still, "more accurate, slower and wordier" is a more useful summary than any table above.

Gemini 4 Argon pricing and the November 30 price cliff

Argon costs $2 per million input tokens and $10 per million output tokens through November 30, 2026, then doubles. Output includes thinking tokens. There is no free tier and no explicit caching, only implicit caching on prompts of 4,096 tokens or more (Gemini API pricing).

Now put the Anthropic list next to it (Claude pricing). Opus 5.5 is $4/$20. Sonnet 5.5 is $2/$10. Fable 5.1 is $10/$50, and third-party trackers list GPT-6 Astra at the same $10/$50 (I couldn't load OpenAI's own page to confirm). Most launch coverage repeats "half the price of Opus." That's true for six weeks. On December 1 Argon lands at exactly Opus 5.5's per-token price, and during the intro window it costs the same as Sonnet 5.5.

The per-token price was never the whole story anyway, because Argon writes more. In the paddo.dev runs above, Argon cost 1.26x Opus at the intro price, and the author estimates about $115 for the same 20 runs after the increase, roughly 2.5x Opus. The DEV roundup cites around 62,000 output tokens per task for Argon against 27,000 for Astra. If output volume drives your bill, the cliff makes Argon more expensive per fix than Opus, not equal.

How to set thinking_level for coding

Argon takes thinking_level set to low, medium or high, and the default is medium. Google's advice is to evaluate all three with a high max_output_tokens and pick the lowest level that clears your quality bar. Since thinking is billed as output, that choice is most of your cost control.

Two details trip people coming from Gemini 3.5 Flash. First, Argon has no minimal level. I sent one straight to the API to check:

curl -s "https://generativelanguage.googleapis.com/v1beta/models/gemini-4-argon:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{"role": "user", "parts": [{"text": "Reply with the word ok."}]}],
    "generationConfig": {
      "maxOutputTokens": 256,
      "thinkingConfig": {"thinkingLevel": "minimal"}
    }
  }'

{
  "error": {
    "code": 400,
    "message": "Thinking level MINIMAL is not supported for this model. Please retry with other thinking level.",
    "status": "INVALID_ARGUMENT"
  }
}

Second, the old numeric thinkingBudget still works. A couple of third-party guides say it returns HTTP 400 on Argon. It didn't for me: {"thinkingBudget": 1024} came back 200 with a normal answer and no warning header over REST. Google's docs say it maps to the nearest level with a warning, which the SDK may surface. Either way, switch to thinking_level, which is what Google's docs now recommend. Here's the shape from Google's quickstart, with low as my starting point for coding:

# pip install -U "google-genai>=2.30.1"
from google import genai
from google.genai import types

client = genai.Client()  # reads GEMINI_API_KEY

response = client.models.generate_content(
    model="gemini-4-argon",
    contents="Refactor this function to remove the N+1 query: ...",
    config=types.GenerateContentConfig(
        max_output_tokens=65536,
        thinking_config=types.ThinkingConfig(thinking_level="low"),
    ),
)

print(response.text)
print(response.usage_metadata)  # check thoughts_token_count before raising the level

What I measured across the three levels

I gave Argon one coding task six times, twice per level: write a compare(a, b) function that follows Semantic Versioning 2.0.0 precedence, including pre-release ordering and rejecting invalid versions. A 13-case pytest suite I wrote separately graded each answer. Same 204-token prompt every time, via the REST API on October 20:

Every run passed. Low and medium reported no thinking tokens at all on this task, so the model decided it didn't need to think. High spent 3,472 to 4,272 thinking tokens, cost roughly 7-8x as much as low, took several times longer, and produced the same passing code. Costs are at the intro price. One task with six runs proves nothing about hard refactors, but it does show the thing worth checking on your own work: read thoughts_token_count in the usage metadata before you reach for high.

Latency was noisy in launch week. A one-word "ok" reply took 37 seconds at one point and 137 seconds at another. Google's own migration notes tell you to set HTTP timeouts to at least 20 minutes, and they also list the other changes from Gemini 3.x: sampling parameters like temperature are ignored, explicit caching calls error, and function-calling loops must send back the thought signatures from earlier turns. On hard tasks a request can spend its whole budget thinking and return empty text with a continuation_token. Google calls that normal. The current SDKs (Python 2.30.1+, JavaScript 2.29.1+) continue automatically.

How to run Gemini 4 Argon inside Claude Code

Claude Code only speaks the Anthropic Messages API, and I didn't find an Anthropic-compatible endpoint from Google. So Argon needs a gateway in front of it that translates. I used LiteLLM (version 1.106.0) running locally with Claude Code 2.1.303. This is the config I tested, not a sketch.

model_list:
  - model_name: gemini-4-argon
    litellm_params:
      model: gemini/gemini-4-argon
      api_key: os.environ/GEMINI_API_KEY

python3 -m venv .venv && source .venv/bin/activate
pip install 'litellm[proxy]'

export GEMINI_API_KEY="your-gemini-key"
export LITELLM_MASTER_KEY="sk-$(openssl rand -hex 16)"
litellm --config litellm.yaml --port 4000

The master key isn't optional anymore. Without it, LiteLLM 1.106 prints "proxy refused to start: no master key is set" and exits. Then point Claude Code at the proxy. The variable names come from Anthropic's LLM gateway docs, which also warn that some background sub-calls ask for built-in Claude model IDs regardless of your override. Setting every slot covers that.

export ANTHROPIC_BASE_URL="http://localhost:4000"
export ANTHROPIC_AUTH_TOKEN="$LITELLM_MASTER_KEY"
export ANTHROPIC_API_KEY=""

# Every slot, including background calls, goes to Argon
export ANTHROPIC_MODEL="gemini-4-argon"
export ANTHROPIC_DEFAULT_OPUS_MODEL="gemini-4-argon"
export ANTHROPIC_DEFAULT_SONNET_MODEL="gemini-4-argon"
export ANTHROPIC_DEFAULT_HAIKU_MODEL="gemini-4-argon"
export CLAUDE_CODE_SUBAGENT_MODEL="gemini-4-argon"

# Without this, Argon rejects every request (see below)
export DISABLE_PROMPT_CACHING=1

claude

The caching error you'll hit first

My first run didn't include DISABLE_PROMPT_CACHING. It failed on the first request:

API Error: 400 litellm.BadRequestError: GeminiException BadRequestError - {
  "error": {
    "code": 400,
    "message": "Explicit caching is not supported for models/gemini-4-argon.",
    "status": "INVALID_ARGUMENT"
  }
}

Here's the chain. Claude Code tags its system prompt and conversation with Anthropic cache_control breakpoints. LiteLLM translates those into Gemini explicit caching. Argon doesn't support explicit caching, so it rejects the whole request. DISABLE_PROMPT_CACHING=1 stops Claude Code sending the markers. You don't lose caching: Gemini's implicit cache still kicks in on its own.

With that set, I gave headless Claude Code a small job in a scratch folder: fix a broken add() in calc.py and report the Next.js version in package.json. It finished in 6 turns and 75 seconds, made the right one-line edit, and answered correctly. The usage report showed 36,391 uncached input tokens, 83,880 cached input tokens and 2,465 output tokens. At the intro price that's about $0.11.

Two things in that report are wrong, and you should know which. Claude Code put the cost at $0.29, because it doesn't know Argon's prices (the model entry says costBasis: "unknown"). Use your gateway's spend log or the Google Cloud billing page instead, as I covered in Claude Code cost tracking. It also listed the context window as 200,000 tokens, so Claude Code will compact long sessions long before Argon's 1M limit. OpenRouter's Claude Code guide says a [1m] suffix on the model name lifts that assumption. I haven't tested that with LiteLLM.

If you'd rather use OpenRouter, the same guide sets ANTHROPIC_BASE_URL=https://openrouter.ai/api, your OpenRouter key in ANTHROPIC_AUTH_TOKEN, and an explicitly empty ANTHROPIC_API_KEY, with google/gemini-4-argon as the model. Watch the cache on the first run. paddo.dev saw one OpenRouter run cache only 59k of 8.4M input tokens ($17.60), because the way system messages were moved into Gemini's prompt broke the prefix match. A local proxy fixed it: same run, $2.62, 94% cache hits. In my LiteLLM run, 70% of input came from cache.

Argon in Antigravity vs Claude Code

Antigravity is Google's own agent harness and the zero-setup way to use Argon, if your account qualifies. That part is unclear. Google's launch post lists Antigravity access for AI Ultra subscribers. The Antigravity blog says Pro and Ultra, plus eligible Gemini Enterprise plans. paddo.dev reports a Workspace account being refused. Check your own account before planning around it.

The harness itself drew most of the complaints in the Hacker News launch thread (1,705 points and 1,199 comments when I checked): no skills or subagents, weak permission controls, tool calls that hang, and forced compaction around 250k tokens. paddo.dev timed the same task at 1.75x slower in Antigravity than in Claude Code, with the same pass result in both. If you already live in Claude Code, the gateway route above keeps your hooks, skills and CLAUDE.md. My Gemini CLI to Antigravity CLI guide covers the agy side if you want both.

When to route coding work to Argon vs Opus 5.5

Send Argon the work where its benchmark lead is large and the task tolerates a slow, wordy model. Keep Opus 5.5 on the tight loop. This is how I'd split it today:

The date changes the math. Until November 30, Argon is worth a trial on any task in the first two rows, because it's cheap to be wrong. After December 1 it only earns a place where it beats Opus on pass rate, since it no longer beats it on price. For the Claude side of the routing setup, see Claude Code model routing with Fable 5. If you're comparing Google's cheaper tier, I measured the trade-offs in Gemini 3.5 Flash for agentic coding.

FAQ