Gemini 4 Argon GA: 1M Token Decoding and Thinking Guide
Google released Gemini 4 Argon with 1M unified tokens, tunable thinking, and server-side long decode. Learn migration steps and pricing details.
- Gemini 4 Argon is generally available as Google’s flagship reasoning model for coding, agents, math, and science.
- A single context window of 1,048,576 tokens unifies input, thinking, and output tokens.
- Background execution allows long decode runs beyond 65,536 tokens up to the full 1,048,576 limit.
- Explicit context caching and sampling parameters like temperature are no longer supported.
- Introductory pricing runs through November 30, 2026 at $2.00 per 1M input tokens and $10.00 per 1M output tokens.
Gemini 4 Argon: What Changed in the GA Release
On 2026-10-13, Google announced the general availability of Gemini 4 Argon (gemini-4-argon) in the Gemini API changelog. The model serves as Google’s flagship reasoning engine designed specifically for complex software engineering, advanced mathematics, scientific problem solving, and autonomous agentic workflows. It brings significant shifts to core API mechanics, including unified memory limits, background long decoding, and strict reasoning controls.
Unlike previous generations where input and output allocations were tracked through isolated ceilings, gemini-4-argon merges input, reasoning thoughts, and final outputs into a single unified window of 1,048,576 tokens. The model accepts multimodal inputs across text, audio, images, video, and PDF documents, while generating text responses. The stable model identifier is gemini-4-argon, and the release removes several legacy knobs in favor of automated parameter enforcement.
- Unified 1,048,576 token ceiling covering prompt contents, internal reasoning chains, and generation steps.
- Default synchronous response limit fixed at 65,536 tokens, expandable via server-side long decode.
- Native reasoning with three distinct thinking levels: low, medium, and high.
- Removal of explicit cache management in favor of automatic implicit caching.
- Deprecation of manual sampling controls such as temperature, top_p, and top_k.
Thinking Levels and Unified Context Limits
Gemini 4 Argon relies on adaptive reasoning before emitting user-facing text. Rather than letting developers adjust stochastic controls like temperature, top_p, or top_k—which are completely ignored if passed in generation configs—reasoning depth is modulated through the thinking_level setting. Developers can select among low, medium, and high, with medium configured as the default.
Because thinking tokens count against max_output_tokens, setting an overly restrictive output ceiling will cause thinking tokens to exhaust the budget before the model completes its final response. If an existing pipeline specifies an output cap below 32,768 tokens, that limit should be raised to at least 32,768 to prevent truncation on complex questions. To understand architectural differences in reasoning designs across providers, see our guide on extended thinking and reasoning.
| Thinking Level | Token Consumption | Primary Use Case |
|---|---|---|
| low | Lowest token volume and lowest time to first token | Light writing, straightforward text transformations, and cost-sensitive pipelines. |
| medium | Balanced token allocation (API default) | General software engineering, typical agentic execution, and nuanced analysis. |
| high | Highest token volume and extended latency | Rigorous mathematical proofs, scientific verification, and large multi-file codebases. |
from google import genai
client = genai.Client()
interaction = client.interactions.create(
model="gemini-4-argon",
input="Analyze this payment processing pipeline for race conditions during retry attempts and rewrite the transaction locks safely.",
generation_config={
"thinking_level": "medium"
}
)
print(interaction.output_text)
Implementing Long Decode and Background Execution
Standard synchronous API calls stop generating once they produce 65,536 tokens. For exhaustive tasks such as generating expansive codebases or complex proofs, Gemini 4 Argon introduces long decode, capable of reaching up to 1,048,576 tokens minus the input size. The model handles these massive completions in progressive server hops of up to 64K tokens each, continuing each hop seamlessly from where the preceding generation stopped.
To trigger long decode, developers set background: true alongside a max_output_tokens value higher than 65,536 (such as 131,072 or 262,144). The Google backend manages the continuation iterations automatically. Clients then poll the interaction status until it exits queued and in_progress. Because each continuation hop appends an independent model_output step to interaction.steps, your client code must iterate over all steps and concatenate the text parts.
import time
from google import genai
client = genai.Client()
interaction = client.interactions.create(
model="gemini-4-argon",
input="Write a complete, rigorous proof of the prime number theorem.",
background=True,
generation_config={
"max_output_tokens": 262144,
"thinking_level": "high",
},
)
while interaction.status in ("in_progress", "queued"):
time.sleep(5)
interaction = client.interactions.get(id=interaction.id)
text = "".join(
content.text
for step in interaction.steps
if step.type == "model_output"
for content in step.content
if content.type == "text"
)
print(text)
print("Status:", interaction.status)
print("Usage:", interaction.usage)
Note that passing background: true without defining max_output_tokens causes the server to halt output at 64K tokens. For applications running synchronous invocations without background processing, ensure client network sockets permit extended runtimes by setting connection timeouts to at least 15 minutes.
Supported Features, Implicit Caching, and Agents
Gemini 4 Argon expands agent capabilities while restructuring memory features. Agentic video understanding is now generally available, defaulting to static. The release also natively integrates with Gemini Managed Agents. Teams using the Antigravity agent (antigravity-preview-09-2026) can designate gemini-4-argon as the primary reasoning brain inside agent_config.
Context caching has been completely overhauled. Explicit cache definitions—previously managed through cachedContents and caches.create—are unsupported on gemini-4-argon. Instead, the API activates implicit caching automatically for any prompt containing at least 4,096 tokens. Cache hits receive a 95% discount on input token rates. For background on cache mechanics across ecosystems, explore prompt caching explained.
from google import genai
client = genai.Client()
interaction = client.interactions.create(
agent="antigravity-preview-09-2026",
input=(
"Audit https://web.dev for performance, Core Web Vitals, and SEO. "
"Query Google's PageSpeed Insights API for both Mobile and Desktop strategies. "
"Check search indexing with Google Search for site:web.dev. "
"Format the output as a side-by-side scorecard table with prioritized fixes."
),
environment="remote",
agent_config={
"type": "antigravity",
"model": "gemini-4-argon",
},
)
print(interaction.output_text)
Other active features supported on gemini-4-argon include Code execution, Computer use (Preview), File search, Function calling, Grounding with Google Maps, Search grounding, Structured outputs, and URL context. Consumption pathways include the Batch API, Flex inference, and Priority inference. However, Audio generation, Image generation, and the Live API are not supported.
Pricing, Token Economics, and Provider Comparison
Gemini 4 Argon does not offer a Free tier. Google has introduced promotional pricing running from launch through November 30, 2026. During this introductory window, base pricing is set to $2.00 per 1M input tokens ($2) and $10.00 per 1M output tokens ($10). Cached input tokens qualifying for the 95% implicit cache reduction are billed at $0.10 per 1M tokens.
Starting December 1, 2026, standard billing takes effect at $4.00 per 1M input tokens ($4) and $20.00 per 1M output tokens ($20), which lifts cached input pricing to $0.20 per 1M tokens. All generated thinking tokens are billed identically to regular output tokens. To model overall budget projections across model catalogs, consult the LLM API cost calculator and track live benchmarks on the pricing directory.
| Model Name | Model ID | Input ($/1M) | Cached Input ($/1M) | Output ($/1M) |
|---|---|---|---|---|
| Gemini 4 Argon (Introductory) | gemini-4-argon | $2.00 | $0.10 | $10.00 |
| Gemini 4 Argon (Standard) | gemini-4-argon | $4.00 | $0.20 | $20.00 |
| Gemini 3.1 Pro Preview | gemini-3.1-pro-preview | $2 | $0.2 | $12 |
| Gemini 2.5 Pro | gemini-2.5-pro | $1.25 | $0.125 | $10 |
| Claude Opus 5.5 | claude-opus-5.5 | $4 | $0.2 | $20 |
| GPT-6.1 Sol | gpt-6.1-sol | $2 | $0.1 | $10 |
Migration Checklist and Gotchas to Watch
Migrating production workflows to gemini-4-argon requires specific code and architecture updates. Teams using coding agents with tool abilities can install the gemini-api-dev skill and run /gemini-api-dev migrate my app to Gemini 4 Argon to automatically flag deprecated settings across repository files.
- Change the model parameter string to
gemini-4-argon. - Remove
temperature,top_p, andtop_kkeys from all payload configs to avoid silent parameter drops. - Delete manual caching logic using
cachedContentsorcaches.create, relying solely on automatic implicit caching for prompts at or above 4,096 tokens. - Inspect
max_output_tokensand raise existing values under 32K to at least 32,768 tokens so internal thinking does not crowd out the answer. - Implement
background: truewithmax_output_tokensgreater than 65,536 when outputs require long decode spans up to 1,048,576 tokens. - Concatenate text across all
model_outputentries ininteraction.stepswhen reading results from background runs. - Increase HTTP synchronous socket timeouts to a minimum of 15 minutes to tolerate extended thinking periods on complex queries.
- Track multi-turn chat sessions and tool returns on the server side using
previous_interaction_id.
For schemas involving programmatic output validation, confirm structured response payloads alongside our review of structured outputs to maintain schema adherence.