Gemini 4 Argon: What Developers Need to Know Before Switching
Google's Gemini 4 Argon leads most of its own benchmarks, but its price doubles on December 1, its 1M output limit has conditions, and it is slow. Here is what matters before you migrate.
Gemini 4 Argon is Google's flagship model for developers right now, and the launch coverage mostly tells one story: better benchmarks at a lower price. For anyone actually building on it, three other details matter more. The price doubles on December 1. The "1M output" headline does not describe a normal API call. And some of your existing request parameters will now do nothing at all.
This is a practical read of Argon for developers, based on Google's docs, its model card, and independent measurements. These are published numbers, not my own benchmark run, and I have marked which results come from whom.
What Gemini 4 Argon is
Google announced Argon on September 30, 2026, first to trusted cyber defenders through its Fairwind Program. It then opened it up on October 13: developers and enterprises through the paid API, Google AI Ultra subscribers in Antigravity, and Ultra and Pro subscribers in the Gemini app and AI Mode in Search. It is not on the free API tier.
Google's model card describes a new sparse mixture-of-experts model, not a fine-tune of an earlier one, with a March 2026 knowledge cutoff. Google positions it for software engineering, professional knowledge work, and defensive cybersecurity.
Google has since announced Gemini 4 Carbon, but at the time of writing it is going to a subset of cyber defenders first, with no developer date. For anything you ship now, Argon is the Gemini 4 model you can actually use.
| Spec | Value |
|---|---|
| Model ID | gemini-4-argon |
| Context window | 1,048,576 tokens, shared by input, thinking and output |
| Max output | 65,536 by default, up to 1,048,576 with long decode |
| Inputs | Text, image, video, audio, PDF |
| Output | Text only |
| Thinking levels | Low, medium (default), high |
| Not supported | Live API, image generation, audio generation, explicit caching |
Specs from Google's Argon model page.
The price doubles on December 1
The $2 and $10 you see quoted everywhere is an introductory rate that runs through November 30, 2026. If you are modeling costs for anything that outlives this month, use the right-hand column.
| Per 1M tokens | Through Nov 30 | From Dec 1 |
|---|---|---|
| Standard input | $2.00 | $4.00 |
| Standard output, including thinking | $10.00 | $20.00 |
| Cached input | $0.10 | $0.20 |
| Batch or Flex input | $1.00 | $2.00 |
| Batch or Flex output | $5.00 | $10.00 |
| Priority input | $3.60 | $7.20 |
| Priority output | $18.00 | $36.00 |
Prices from Google's pricing page.
Thinking is billed as output, and that shapes the real bill. Take an illustrative agent run with 1M input tokens across all its turns, 90% of them cached, and 100K output tokens including thinking. Today that costs $1.29. After December 1 it costs $2.58. Roughly three quarters of that bill is output, so the thinking level you pick will move your costs more than your cache hit rate will.
What "1M output tokens" really means
Google's launch post described an output limit of 1M tokens, up from 64K. The docs are more specific, and the difference will catch people out:
- A normal synchronous request still tops out at 65,536 output tokens.
- Going higher needs long decode: a background request with
max_output_tokensset above that limit. Leave that field out and background runs still stop at 64K. - The 1M figure is a unified window. Input, thinking and output all draw from it, so a large prompt shrinks what is left.
max_output_tokensis a hard limit on thinking plus output combined, which means a low setting can burn its whole budget before writing an answer.
Long decode is genuinely useful for large code migrations or full document generation. It is a different execution model, though, not a bigger number on the same call.
Your migration checklist
Google's migration notes are short, but several items change behavior without raising an error:
- Remove
temperature,top_pandtop_k. They are ignored. Any tuning you relied on for determinism or creativity has quietly stopped working, so retest your evals. - Remove explicit caching.
cachedContentsandcaches.createare not supported. Only implicit caching applies, so keep your stable prefix at the start of the prompt and measure the hit rate you actually get. - Raise
max_output_tokens. Google recommends at least 32,768, because Argon can spend more of the limit on thinking than earlier models did. - Set HTTP client timeouts to at least 15 minutes. Many default clients and proxies will cut these requests off long before that.
- Move long outputs to background execution. Anything over 64K needs it.
- Pick a thinking level on purpose. The default is medium. Test low for high-volume, simpler routes rather than paying for depth you do not need.
What the benchmarks actually show
Argon leads most of the table on its model card, but not all of it. Every number below is from Google's own card, dated October 2026, so read it as vendor-reported.
| Benchmark | Argon | GPT-6 Astra | Claude Opus 5.5 | Claude Fable 5.1 |
|---|---|---|---|---|
| Vals Index | 68.9% | 63.1% | 67.0% | 65.8% |
| DeepSWE v1.1 | 77.9% | 74.1% | 74.2% | 67.4% |
| AutomationBench | 51.3% | 41.4% | 42.5% | 31.4% |
| GraphWalks BFS, 256K to 1M | 84.2% | 71.8% | 66.8% | 65.0% |
| FrontierSWE v2 | 55.0% | 65.5% | 62.3% | 56.3% |
| Terminal-bench 4.0 | 57.4% | 58.2% | 66.4% | 57.9% |
| CWE-bench v1 | 68.0% | 68.0% | 67.0% | 58.0% |
The pattern is more useful than any single row. Argon's clearest gaps are in long-context work and business automation, and the GraphWalks result suggests it holds up unusually well as context grows. On FrontierSWE v2 and Terminal-bench 4.0, it trails. "Best coding model" is not a safe conclusion from this table, so test it on your own repo.
Speed is the real trade-off
Independent numbers tell a story the launch posts do not. Artificial Analysis measured Argon at 26.2 minutes per Intelligence Index task against a 12.5-minute median, 40.39 seconds to first answer token against a 15.18-second median, and 74 tokens per second of output. It also used 113M output tokens on that index against a 72.5M median, and it calls the model notably slow and somewhat verbose.
On overall quality, the picture is less flattering than launch coverage suggested. The Artificial Analysis leaderboard currently scores Argon (high) at 50, against 57 for GPT-6 Astra (max) and 60 for Gemini 4 Carbon (high), at $9.95 per index task. My November model comparison puts those numbers in context.
For a background coding agent, slow is fine. For anything a user is watching, a 40-second wait for the first answer token is a product problem, so Argon needs streaming, progress states, or a faster model in front of it.
Safety findings worth reading
Google's model card is unusually blunt here. Under its Frontier Safety Framework, Google says it cannot rule out that Argon reached the critical capability level for cyberattacks or for biological information risk, and it built safety cases for both. On loss of control, Argon passed 14 of 15 stealth and situational awareness challenges.
The practical effects for developers are guardrails and monitoring. The public model ships with cyber guardrails, while vetted Fairwind members can get access without them, so legitimate security tooling may hit refusals on the public model. On the positive side, Google reports prompt injection attack success of 0.7% across 15 adaptive attempts on the Gray Swan benchmark. Treat that as a strong number, not a reason to give an agent unsupervised access to untrusted content.
Should you switch?
- Good fit: long-context analysis, large migrations, background coding agents, and automation where a task can run for minutes.
- Poor fit: realtime chat, voice (there is no Live API), image or audio generation, and high-volume simple tasks where a cheaper model does the job.
- Test first: anything using explicit caching or relying on sampling parameters, and any security workload that may trip the cyber guardrails.
The sensible approach is to route, not replace. Send the expensive, slow, context-heavy work to Argon, keep a faster model on interactive paths, and model your costs at the December price from day one. If the numbers only work at $2 and $10, they do not work.
Building AI features into a product and want a second opinion on model routing, cost, or architecture? I take on remote AI product work for startups in the US and UK.
