Gemini 4 Argon Explained: Long Decode, Thinking Levels & Specs

Short version: Gemini 4 Argon is Google's new flagship reasoning model, and its headline feature isn't a benchmark. It's long decode: one response can now run past the old 64K-token output ceiling, all the way up to 1M tokens, because input, thinking and output share a single 1,048,576-token window. Pair that with three thinking levels (low, medium and high, with medium as the default) and you get a model built to think for minutes, not seconds, on hard coding, math and science problems.

The catch is that long decode doesn't switch on by itself. You need background execution, a raised max_output_tokens and code that joins several output steps into one answer. This guide explains how each piece works, what Argon costs before and after the introductory price ends on 30 November 2026, and when it's worth using. Everything comes from Google's model page, developer guides, pricing page, launch post and model card, checked on 18 October 2026. We haven't run our own benchmarks, so every score below is Google's. For the head-to-head with Anthropic's flagship, read our Gemini 4 Argon vs Claude Opus 5.5 comparison.

Gemini 4 Argon at a Glance

Two rows matter most for developers. The context row is new: on earlier Gemini models the input limit and the output limit were separate numbers, and on Argon they come out of the same 1,048,576-token pool. If your prompt plus max_output_tokens goes over that, the API quietly caps the output to whatever space is left. The caching row is the one most likely to break existing code, because calls that create or reference explicit caches don't work on Argon.

What's New in Gemini 4 Argon

A unified 1M-token window

Google describes Argon's limit as an "industry-leading 1M unified input-output token limit". In practice, think of the window as a budget. A 300,000-token codebase leaves roughly 748,000 tokens for thinking and output. A 1,000-token question leaves almost the full million. Google's own long-context results back up the window size: on the GraphWalks test the model card reports 99.7% up to 128K tokens and 84.2% between 256K and 1M tokens.

Long decode past 64K tokens

This is the feature in the title, and it gets its own section below. The short version: a single Argon call still writes up to 64K tokens, but with background execution Google's servers chain those calls together, so one answer can grow to hundreds of thousands of tokens of thinking and output.

Thinking levels with a medium default

Argon supports three thinking levels and starts at medium. There is no minimal setting, and you can't switch thinking off. Google calls the thinking level "your main control over quality, latency, and token use", and it replaces the sampling knobs you may be used to: temperature, top_p and top_k are now ignored if you send them.

Agentic video understanding is generally available

Agentic video understanding is now generally available, and on Argon it defaults to static mode. Native video and audio input is a clear gap with Claude Opus 5.5, which only takes text and images: Argon reads the media directly, without frames and transcripts extracted first.

Argon inside Antigravity and Managed Agents

The Antigravity agent in Gemini Managed Agents now runs on Argon, set through agent_config. Google says Argon in Antigravity raised agentic code submissions inside Google by more than 35% while cutting code rollbacks by nearly a third. That is Google measuring itself, so treat it as a claim, not an independent result. If you followed the previous release, our Gemini 3.8 Flash explainer shows how much has changed in a few weeks.

A new model, not a fine-tune

The model card says Argon is "not a modification or a fine-tune of a prior model". It's a large sparse mixture-of-experts transformer with native support for text, vision and audio, trained on Google's TPUs. Google also says it follows style instructions better than any previous Gemini model and answers more directly, with less hedging and fewer clichés.

Long Decode Explained: How Argon Writes Past 64K Tokens

Every Argon call still generates at most 64K tokens. Long decode works around that limit with hops. When an answer needs more room, the server generates the first 64K tokens, then starts a new hop from exactly where the last one stopped, and repeats until the model finishes or uses up your max_output_tokens. Each hop lands as a separate model_output step on the same interaction, and your code joins those steps to read the full answer.

To turn it on, you need three things on the Interactions API: background: true, store: true (background interactions require it) and a max_output_tokens above 65,536. Here's the shape of the request, adapted from Google's guide:

interaction = client.interactions.create(
    model="gemini-4-argon",
    input="[YOUR HARD PROBLEM]",
    background=True,
    generation_config={
        "max_output_tokens": 262144,
        "thinking_level": "high",
    },
)
# Poll client.interactions.get(id=interaction.id) until the status
# is no longer "in_progress" or "queued", then join the text of
# every step where step.type == "model_output".

The settings interact in ways that are easy to get wrong, so here is how each combination behaves:

Background execution vs client-side continuation

Background execution is the easy route: Google's servers run the hops, a single interaction can run for up to 24 hours, and the result is stored server-side. If you'd rather control retries yourself, or don't want anything stored, the GenerateContent API offers client-side continuation, where the SDK or your code starts each hop. That route is limited to 64K tokens per stream (32K per non-streaming request) and 20 minutes per request. Google says client-side continuation is coming to the Interactions API too.

When long decode is worth it

Honest answer: most people won't need long decode at all. It earns its keep on the small set of problems where the model's thinking alone can fill 64K tokens. A high max_output_tokens only gives the model room; it still decides how much to write. If you're designing long-running agents around this, the same discipline applies as in any context engineering setup: give the model only what the task needs, because every token you send shrinks the room left for thinking.

What long decode costs

You pay for every token in every hop, including hops that contain only thinking, and cancelled or failed runs are billed for the work done. The input side is where it gets confusing. Each hop sends your prompt plus everything generated so far back to the model, so the same tokens are counted again in every later hop. Google's example: a 1,000-token prompt that produces 200,000 tokens of thinking and output takes four hops, and total_input_tokens reports 397,216 even though the real context is only about 201,000 tokens. Implicit caching discounts those repeated inputs by 95%.

Our arithmetic on that example, at the introductory price: the 200,000 output tokens cost $2.00. The 397,216 input tokens cost somewhere between about $0.04 (if nearly all hit the cache) and $0.79 (if none did), so the whole run lands between roughly $2.04 and $2.79. From 1 December 2026, when prices double, the same run costs roughly $4.08 to $5.59. That's cheap for an answer that needed 200,000 tokens of reasoning, but it's real money if you send every request down the long-decode path.

Pro tip: Don't let your agent framework read total_input_tokens to decide when to compact the conversation. On long decode it counts repeated hop inputs, so compaction fires far too early. Estimate context size as your prompt plus total_output_tokens and total_thought_tokens instead.

Long-context models are only as good as what you feed them. If you're filling Argon's window with documentation or web pages, clean markdown wastes far fewer tokens than raw HTML, which leaves more of the shared million for thinking.

Thinking Levels: Low, Medium and High

The thinking level decides how deeply Argon reasons before it answers. You set it with thinking_level in generation_config, and Google's guidance is short:

Thinking level vs max_output_tokens

These two settings do different jobs, and mixing them up is the most common way to get empty answers. max_output_tokens is a hard cutoff on thinking plus output combined. It doesn't make the model think more concisely; it just stops the response when the limit is hit. If that happens mid-thought, the status comes back incomplete, the text can be empty, and you're still billed for the thinking. To spend less, lower the thinking level instead of shrinking the limit.

Google's starting points for max_output_tokens: keep the 65,536 default for standard tasks; raise any existing limit below 32K to at least 32,768, because Argon spends more of its limit on thinking than earlier models; and for complex reasoning and coding, switch on background execution and try 131,072 or 262,144. Thinking tokens are billed as output tokens, and the usage object reports them separately as total_thought_tokens.

How it compares with Claude's effort setting

Anthropic made the same move with Claude Opus 5.5: thinking is always on, and one setting controls depth. The difference is range. Claude offers five effort levels up to max, while Argon has three, with long decode providing the extra headroom at the top. Our Claude Opus 5.5 explainer covers the five effort levels if you're tuning both models.

Google's own advice is to run your evaluations at all three levels and pick the lowest one that meets your quality bar. This prompt turns that into a plan you can run:

Gemini 4 Argon Specs and Capabilities

The gaps are deliberate. Argon is a reasoning model with text output, so image work still goes to Nano Banana and real-time voice still goes to the Live models. Google's model card also lists the usual limits: hallucinations remain possible, and the card warns of "occasional slowness or timeout issues". Google recommends HTTP client timeouts of at least 15 minutes for hard prompts, or background execution so timeouts don't matter.

Gemini 4 Argon Pricing

Two things stand out. First, the introductory price is exactly half the list price, and Google states the end date plainly, so budget for December now rather than building a cost model on today's numbers. Second, there's no explicit cache to pay storage on. Implicit caching is on by default for prompts of at least 4,096 tokens and takes 95% off cache hits, which makes stable system prompts and long shared documents much cheaper on repeat calls. Argon isn't on the free API tier, so you need a paid Gemini API project to call it.

A quick worked example at intro pricing: an agent step that reads 200,000 tokens and writes 20,000 costs $0.60 ($0.40 input plus $0.20 output). If 180,000 of those input tokens hit the implicit cache, it drops to about $0.26. From December, the same two calls cost $1.20 and about $0.52. For how token prices turn into a monthly bill on a real coding workflow, our Claude Code API pricing guide walks through the same math for Anthropic's models.

Benchmarks: What Google Reports

Source: Gemini 4 Argon model card, results as of October 2026. All figures as reported by Google.

My take: the pattern is clearer than any single row. Argon leads on knowledge work, long context and video, which lines up with its unified window and native multimodal input. It trails on the terminal-style coding benchmarks, where Claude Opus 5.5 leads Terminal-bench 4.0 by nine points in Google's own table. So "best model" depends on the job. Anthropic's and OpenAI's own numbers for some of these benchmarks differ from Google's, and we break those disagreements down in the Argon vs Opus 5.5 comparison linked above. For OpenAI's side of the story, see our GPT-6 Astra explainer.

Migrating to Gemini 4 Argon: The Checklist

Changing the model string is one line. These are the other changes from Google's migration guide that existing Gemini code usually needs:

1. Update the model ID to gemini-4-argon.
2. Raise low output limits. Anything under 32K should go to at least 32,768, because Argon spends more of the limit on thinking.
3. Pick a thinking level and test your workload at all three.
4. Remove explicit caching. Calls to caches.create or requests that reference cached_content must go; implicit caching takes over.
5. Drop sampling parameters. temperature, top_p and top_k are ignored.
6. Use background execution for long outputs and set max_output_tokens above 65,536 when one answer needs more than 64K tokens.
7. Raise client timeouts to at least 15 minutes, or use background execution.
8. Keep conversation state on the server with previous_interaction_id for multi-turn and function-calling flows. If you manage history yourself, resend every thought block exactly as received, because the signatures inside carry the model's reasoning state.

Gemini 4 Argon vs Gemini 3.8 Flash: Which One to Use

The rule of thumb is simple. Run high-volume work (chat, extraction, routing, short agent turns) on 3.8 Flash, which costs a fraction of Argon even at intro pricing and keeps explicit caching. Move a task to Argon when Flash at high thinking still misses your quality bar, or when one answer genuinely needs more than 64K tokens. If price per token is what decides it, an open-weight coding model is worth testing too; our GLM-5.3 vs Opus 5 coding comparison shows where a cheaper model holds up.

Where You Can Use Gemini 4 Argon

• Developers: the Gemini API paid tier, Google AI Studio and Android Studio. Google AI Ultra subscribers can also use it in Google Antigravity.
• Enterprises: Gemini for business, the API and Google Antigravity.
• Everyday users: the Gemini app and AI Mode in Search for Google AI Pro and Ultra subscribers.
• Researchers: Google is offering 10,000 scientists Antigravity's highest usage tier free for six months, subject to eligibility and selection.
• Security teams: cyber defenders can apply to Google's Fairwind Program for access without the cyber guardrails.

Google calls Argon "just the beginning" of the Gemini 4 family, so more Gemini 4 models are coming. The launch post gives no details on them yet.

Pro tip: Default to medium and a 65,536-token limit, and treat long decode as an escalation path, not a setting. Route a request to high plus background execution only when a medium run comes back incomplete or fails your checks.

Our Verdict on Gemini 4 Argon

My take: Argon is the most interesting Gemini release in a while because it changes how you call the model, not just how well it scores. The unified 1M window and long decode let one answer spend hundreds of thousands of tokens without you building the continuation loop yourself. Google's own table shows it leading on knowledge work, long context and video, while Claude Opus 5.5 still leads on terminal-style coding.

For most teams, the decision comes down to migration and cost, not quality. Budget an afternoon to remove explicit caching and sampling parameters, raise low output limits, and run a thinking-level sweep starting at medium. Then lean on the introductory price while it lasts, and plan for the doubled rates from 1 December. When you're ready to put a frontier model to work on code, our 25 best Claude Opus 5.5 coding prompts transfer well to Argon, since the spec-first, checklist style suits any thinking model.

Keep Reading

• Gemini 3.8 Flash vs Opus 5 vs GPT 5.6 compared
• GPT-6 Astra vs Claude Fable 5.1 comparison
• 100+ Gemini 3.5 Flash prompts cheat sheet