Gemini 4 Argon and Claude Code are not the same kind of thing, and that is the first thing to get straight. Gemini 4 Argon is a model: one endpoint, `gemini-4-argon`, released on October 13, 2026 and described by Google as its flagship reasoning model. Claude Code is an agent: a program that reads your repository, edits files, runs commands and manages its own context. Comparing them head to head is like comparing an engine to a car.
The comparison that decides your week is still worth making, because both sides changed this month. Google shipped Argon at an introductory price with a token budget unlike anything Anthropic publishes, and Anthropic's current line runs from $0.10 to $50 per million output tokens depending on which model your agent picks. Below is the table work with the numbers each vendor publishes, the parts that genuinely differ, and the routing that stops you paying frontier prices for retrieval.
Everything here was read from Google's and Anthropic's own pages on October 15, 2026. Where the two vendors publish different benchmarks, the post says so rather than picking a winner across them.
The short version of the price story: Argon's introductory input price matches Claude Sonnet 5.5 exactly at $2 per million tokens, and its output price matches Sonnet at $10. Argon's promo ends November 30, 2026, when both numbers double. That date is the single most useful fact on this page.
Anthropic's pricing page and Google's Gemini API pricing page are the sources. No figure below is calculated.
Two things fall out of that table immediately. Argon today costs the same as Claude Sonnet 5.5 and half of Claude Opus 5.5, and after December 1 it costs the same as Opus 5.5. If Argon is on your roadmap for next quarter, the December date is a planning input rather than a footnote. Batch pricing is the other lever: Google publishes it at half the standard rate, and Anthropic publishes batch discounts on its own pricing page.
Haiku 5.5 inverts the ranking at the low end. For prompts under 100,000 tokens it is twenty times cheaper on input than either frontier model, which is why routing is a pricing decision before it is a quality decision.
This is the part that has no equivalent on the Anthropic side, and it is the reason to care about Argon beyond its price.
Google documents a unified limit of 1,048,576 tokens that covers input and output together, with output including thinking, function calls and the final response. Anthropic publishes a 1M token context window with a 128K maximum output for every current model. Those are different shapes of budget: Anthropic gives you a 1M window and a fixed 128K ceiling to write into it, while Argon gives you one pool that your input eats into.
Two practical consequences. First, a long generation on Argon needs `max_output_tokens` raised on purpose, because the default single request stops at 65,536 tokens for streaming and 32,768 for non-streaming direct HTTP calls. Second, because input and output share one budget, a huge input reduces the output you can produce in the same request by the same amount. That is arithmetic, not a benchmark.
Recipe 2 below shows the configuration that makes long decodes work and the one that silently truncates instead.
Google's launch post states that Argon sets a new state of the art on DeepSWE v1.1 at 77.9%, ranks first on the Vals Index, and scores 91.7% on LVBench for long video understanding. It also reports internal results: in Antigravity, agentic code submissions increased by more than 35% while code rollbacks fell by nearly a third, and a Chrome team refactor separated core page handling from a roughly 6 million line legacy folder inside a 40 million line codebase.
Anthropic publishes Terminal-Bench 4.0 and FrontierCode 1.1 numbers in its own model announcements instead. The two vendors do not publish a shared benchmark suite for this generation, so a table that places Argon's DeepSWE score next to a Claude Terminal-Bench score would be a comparison of two different exams. This post does not do that, and any page that does should be read with that in mind.
What can be compared, because both vendors publish it: price per token, context window, maximum output, cache pricing and the availability tiers that decide whether you can use the model at all.
Note what the last row means for a migration: the cutoff date is published, so you can check it against your own codebase before you blame the model for not knowing a framework that shipped last month.
Both providers work in opencode, which is the cheapest honest way to compare them: same repository, same prompt, two model IDs, one credentials file.
# one-time provider setup opencode auth login --provider google opencode auth login --provider anthropic # confirm what your credentials can actually reach opencode auth list opencode models | grep -E 'gemini-4-argon|claude-(opus|sonnet)-5-5'
Then run the identical task twice, with the output going to files you can diff:
opencode run -m google/gemini-4-argon \ "Read the billing module and write a refactor plan as a markdown file. Do not edit source." \ > /tmp/argon-plan.md opencode run -m anthropic/claude-opus-5-5 \ "Read the billing module and write a refactor plan as a markdown file. Do not edit source." \ > /tmp/opus-plan.md diff --stat /tmp/argon-plan.md /tmp/opus-plan.md opencode stats
`opencode stats` is the part people skip. A comparison that ignores token usage is a comparison of two outputs, not two costs, and the price table above only becomes a decision once you know what each model actually consumed on your task.
Argon's headline capability for code work is generating far more than a normal response in one request. The default is what gets people: a single request stops at 65,536 output tokens, or 32,768 for a non-streaming direct HTTP request. Raising the ceiling is explicit.
from google import genai from google.genai import types client = genai.Client() response = client.models.generate_content( model="gemini-4-argon", contents="Read this 200,000 line module and return a complete refactor plan with a patch per file.", config=types.GenerateContentConfig( max_output_tokens=200_000, thinking_config=types.ThinkingConfig(thinking_level="HIGH"), ), ) print(response.text)
The same idea over HTTP, where the non-streaming cap is the trap:
curl -sS -X POST \ "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": [{"parts": [{"text": "Summarise this module and list every unsafe assumption."}]}], "generationConfig": {"maxOutputTokens": 200000} }' | head -c 400
If you are making the call without streaming, keep the request at or below 32,768 output tokens or move to streaming for anything longer. Google's model guide states the single-request limit plainly and the SDK handles the continuation token across requests, so the streaming path is the one to automate.
For the routing side rather than the raw call, the configuration lives in `opencode.json`:
{ "$schema": "https://opencode.ai/config.json", "model": "google/gemini-4-argon", "provider": { "google": { "models": { "gemini-4-argon": { "limit": { "context": 1048576, "output": 200000 } } } } } }
The `limit.output` value matters more than it looks. The models.dev registry, which opencode reads for provider metadata, lists this model with an output limit of 32,768 tokens for the `google` provider. Leaving that in place caps your long decodes before the API ever sees them, which is a bug that looks like a model limitation.
These responses were produced against the live endpoint on October 15, 2026, with no valid key, which is the state most people hit first.
Calling the API with no credential at all:
{ "error": { "code": 403, "message": "Method doesn't allow unregistered callers (callers without established identity). Please use API Key or other form of API consumer identity to call this API.", "status": "PERMISSION_DENIED" } }
Calling it with a key that is present but wrong:
{ "error": { "code": 400, "message": "API key not valid. Please pass a valid API key.", "status": "INVALID_ARGUMENT", "details": [ { "@type": "type.googleapis.com/google.rpc.ErrorInfo", "reason": "API_KEY_INVALID", "domain": "googleapis.com" } ] } }
The first means no identity was sent. The second means one was sent and rejected. They look similar in a log and have completely different fixes, which is why the `status` field is worth reading rather than skimming.
Two more failures come from the tool rather than the API. opencode documents `ProviderModelNotFoundError` for a model referenced with the wrong path, and the fix is the `/` form:
ProviderModelNotFoundError
Its documentation gives the shape that works, `openrouter/google/gemini-2.5-flash` style, and reports a bad provider configuration as `ProviderInitError`. If your provider is fine and the call still fails, the third documented class is `AI_APICallError`, which is the layer where the two JSON bodies above actually surface.
The last trap is not an error at all: Anthropic supports explicit prompt caching and Argon does not, only implicit caching for shared prefixes of 6,144 tokens or more. A pipeline that was written to pre-warm an explicit cache for cost reasons will still run on Argon, still cost more, and print nothing to tell you why.
The choice is rarely between Argon and Claude Code, and it is usually about which layer you are buying. If you are buying an agent that works inside a repository with review gates, the harness is the decision and the model is a setting. If you are buying one long generation over a large body of code, the model's output budget is the decision and the harness is a wrapper.
Both models run in opencode, which means the migration cost between them is a line in `opencode.json` rather than a rewrite. That is the practical reason to keep the model choice reversible, and reversibility is worth more than any benchmark lead that lasts a quarter.
That framing is the same one behind model and skill routing and how to install Jev, where the routing rules matter more than any single model. The opencode guide covers the harness setup in detail, the complete Jev guide indexes the cluster, and bounded permissions and human approval covers what to put around whichever model you pick.
If you are standing up this decision for a team and want the routing, the model tiering and the review gates designed before the first workflow runs, that is the work we do: we embed AI engineers inside your existing engineering team, spec first, with the exit written down. Send a written intake or see what we do.
Can I use Gemini 4 Argon inside Claude Code?
Claude Code runs Claude models and resolves `opus`, `sonnet` and `haiku` aliases. The portable option is opencode, which supports both providers from one credentials file and one config.
Is Argon cheaper than Claude Opus 5.5?
Until November 30, 2026, yes: $2 against $4 per million input tokens and $10 against $20 for output. From December 1, 2026 the two are the same on both numbers according to the published pages.
Which model should run my cheap background tasks?
Claude Haiku 5.5 at $0.10 per million input tokens for prompts under 100,000 tokens, or Gemini 3.8 Flash on the Google side. Frontier models in either family are the wrong tool for classification and extraction.
Why did my long Argon response get cut off?
Check `max_output_tokens` and whether you are streaming. The documented default is 65,536 output tokens for streaming and 32,768 for non-streaming direct HTTP, and in opencode the registry's 32,768 output limit applies until you override it.
Do the two vendors publish comparable benchmarks?
Not for this generation. Google publishes DeepSWE v1.1 and the Vals Index, Anthropic publishes Terminal-Bench 4.0 and FrontierCode 1.1. Only price, context, output limits and availability can be compared directly.
[1] Google, Gemini 4 Argon: Built to solve your hardest problems, October 13, 2026. Availability across the API, Antigravity and the Gemini app, the introductory price of $2 and $10 per million tokens with cached input at 95% off, the DeepSWE v1.1 77.9%, Vals Index and LVBench 91.7% claims, and the internal Antigravity figures.
[2] Google, Gemini Developer API pricing, read October 15, 2026. The introductory and December 1, 2026 rates, batch pricing, and the note that Argon is not available on the free tier or on the Google AI Pro plan.
[3] Google, Gemini 4 Argon model guide, read October 15, 2026. The unified 1,048,576-token limit, the 65,536 and 32,768 default output ceilings, long decodes, thinking levels, implicit caching for prefixes of 6,144 tokens or more, the absence of explicit caching, regions, and the SDK versions.
[4] Anthropic, Pricing, read October 15, 2026. Claude Fable 5.1, Opus 5.5, Sonnet 5.5 and Haiku 5.5 input, output and cache pricing, including the 100,000 token split on Haiku 5.5.
[5] Anthropic, Models overview, read October 15, 2026. The 1M token context window, 128K maximum output and June 2026 knowledge cutoff shared across current Claude models.
[6] Claude Code, Create custom subagents, read October 15, 2026. The subagent model field and resolution order used in the routing discussion.
[7] Google, Optimizing a 200,000-line Python codebase overnight with Gemini 4 Argon, October 13, 2026. The ADK case study behind the long-decode use case.
[8] Google Cloud, Gemini 4 Argon available on Google Cloud, October 14, 2026. Enterprise availability and the Vertex AI route.
Maxpertise is an AI-native engineering company. We embed native AI engineers inside your team, live in about 10 days. Please enable JavaScript to view the site, or email contact@maxpertise.net.