Gemini 4 Argon on the API: Pricing, Thinking Levels and How to Migrate in 2026

Hello HaWkers, on October 13, 2026, Google DeepMind rolled out Gemini 4 Argon globally, after two weeks of a preview restricted to cybersecurity partners in the Fairwind Program. The model landed on the paid API under the identifier gemini-4-argon, with a 1 million token window and a launch price of $2 per million input tokens and $10 per million output tokens, which doubles starting December 1.

Are you going to swap your product's model just because it showed up at the top of a leaderboard? In this article we will separate what Google measured from what third parties measured, understand what actually changes in the API (thinking levels, output limits, parameters that stopped working) and build, with code, a safe migration and a cost estimate that already accounts for the price after the promotional period.

What Gemini 4 Argon Is

Argon is Google's new frontier model, introduced by Koray Kavukcuoglu, who now leads Google DeepMind, as a model that "excels at deep work on complex real-world tasks". In practice, the stated focus is long-running agentic work: software engineering, finance, law, science and cyber defense.

The technical points that matter if you are integrating it:

• Identifier: gemini-4-argon, already a stable release, with no preview suffix.
• Context window: 1,048,576 tokens, shared between input, reasoning and output.
• Input: text, image, video, audio and PDF. Output: text only.
• Architecture: sparse mixture-of-experts, trained from scratch.
• Knowledge cutoff: March 2026.
• Thinking levels: low, medium and high, with medium as the default.

It is available on the Gemini API through AI Studio (paid tier only, there is no free tier), on Vertex AI, on Antigravity for Google AI Ultra subscribers, and in the Gemini app and Search AI Mode for Pro and Ultra subscribers. Anyone on the free plan stays on the Flash line of models.

There is also a gated variant, gemini-4-argon-cyber-permissive, without the cybersecurity guardrails, available only to verified defenders in the Fairwind Program, which Google is expanding to hundreds of new partners.

Benchmarks: What Google Measured and What Third Parties Confirmed

Google's model card compares Argon, running at its highest reasoning level, against GPT-6 Astra, Claude Fable 5.1 and Claude Opus 5.5. According to Google itself, Argon leads 13 of the 19 rows in the table and ties on one. A few numbers that help explain the model's profile:

Benchmark	Gemini 4 Argon	GPT-6 Astra	Claude Opus 5.5
Vals Index	68.9%	63.1%	67.0%
DeepSWE v1.1	77.9%	74.1%	74.2%
FrontierSWE v2	55.0%	65.5%	62.3%
Terminal-bench 4.0	57.4%	58.2%	66.4%
GraphWalks BFS 256K-1M (F1)	84.2%	71.8%	66.8%
CWE-bench v1	68.0%	68.0%	67.0%

The pattern is clear: Argon is very strong at long-context tasks and knowledge work (finance, legal, automation), and falls behind on terminal tasks and on part of the software engineering benchmarks.

Now, the caveats:

• Some rows were computed by Google itself. On Terminal-Bench Science, Google ran with a verifier timeout six times longer and reported 57.6%; Vals, using its own harness, measured 44.29%.
• In the independent evaluation by Artificial Analysis, Argon scored 53 on the Intelligence Index, tied with GPT-6 Astra. Good, but not the leap Google's table suggests.
• Argon burns a lot of tokens. In the same Artificial Analysis run, it used about 62 thousand output tokens per index task, versus 27 thousand for Astra. That comes to $1.99 per task at the promotional price and $3.98 afterwards.
• Low hallucination: on AA-Omniscience, its hallucination rate was 15%, versus 51% for GPT-6 Astra.

Nitish Tyagi, from Gartner, summed it up well to InfoWorld: whether Argon delivers comparable quality in enterprise use cases "is not yet proven". In other words, benchmarks are a starting point, and the decision comes from your own test set.

Pricing: The Math That Changes on December 1

The launch price is valid until November 30, 2026. The full table per million tokens:

Mode	Input	Output	Cached input	From Dec 1 (input / output / cache)
Standard	$2.00	$10.00	$0.10	$4 / $20 / $0.20
Batch	$1.00	$5.00	$0.05	$2 / $10 / $0.10
Flex	$1.00	$5.00	$0.05	$2 / $10 / $0.10
Priority	$3.60	$18.00	$0.18	$7.20 / $36 / $0.36

Three details that make a difference on the invoice:

1. Reasoning tokens are billed as output. Bumping the thinking level from medium to high raises the bill directly.
2. There is no long-context surcharge. The same price applies across the whole 1M window.
3. Caching is implicit only. The explicit cachedContents API is not supported; the 95% discount kicks in automatically for prefixes of 4,096 tokens or more.

For comparison: after December 1, Argon will cost the same as Claude Opus 5.5 ($4 / $20), while GPT-6.1 Sol stays at $2 / $10. If you are still deciding between OpenAI's models, it is worth rereading our guide on how to choose between GPT-6 Sol and Luna and keep your API costs under control.

Sanchit Vir Gogia, from Greyhound Research, gave the most pragmatic advice: budget at full price right now. A serious enterprise evaluation will rarely wrap up inside the promotional window.

First Call in Python

The minimum SDK for Argon in Python is google-genai 2.30.1. The call below sets the thinking level explicitly along with a high output ceiling, and prints how much was spent on reasoning:

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

# The client reads the key from the GEMINI_API_KEY environment variable
client = genai.Client()

resposta = client.models.generate_content(
    model="gemini-4-argon",
    contents="Review this function and point out race conditions: ...",
    config=types.GenerateContentConfig(
        # Always set the level: the default changed from "high" to "medium"
        thinking_config=types.ThinkingConfig(thinking_level="high"),
        # With "high", a low ceiling can be eaten up by reasoning alone
        max_output_tokens=32768,
    ),
)

uso = resposta.usage_metadata
print(resposta.text)
print("reasoning tokens:", uso.thoughts_token_count)
print("response tokens:", uso.candidates_token_count)

The comment about the output ceiling is not theory. In a test published by Computing for Geeks, with high and max_tokens set to 1,024, Argon spent 1,021 tokens thinking and returned an empty response, with finish_reason equal to MAX_TOKENS.

The Same Call in JavaScript

In Node.js, the package is @google/genai. Notice that the configuration structure is the same, only the naming convention changes:

// npm install @google/genai
import { GoogleGenAI, ThinkingLevel } from '@google/genai'

// Reads the key from GEMINI_API_KEY
const ai = new GoogleGenAI({})

const resposta = await ai.models.generateContent({
  model: 'gemini-4-argon',
  contents: 'Generate a migration plan for this Postgres schema: ...',
  config: {
    // An explicit level avoids surprises when the default changes again
    thinkingConfig: { thinkingLevel: ThinkingLevel.MEDIUM },
    maxOutputTokens: 32768,
  },
})

console.log(resposta.text)
console.log('reasoning:', resposta.usageMetadata?.thoughtsTokenCount ?? 0)

The only accepted values are low, medium and high. Values like max or xhigh, which exist in other APIs, come back with HTTP 400.

What Breaks When Migrating From Gemini 3.1 Pro

Swapping the model string is not enough. The list of differences that showed up in testing and in the documentation is long enough to deserve a checklist:

• The default reasoning level changed. Gemini 3.1 Pro used high by default; Argon uses medium. An application that never configured the level will think less after the switch.
• thinkingBudget and the MINIMAL level return 400 on Vertex AI.
• temperature, top_p and top_k are silently ignored. If your product relied on a low temperature for deterministic answers, that is no longer guaranteed.
• frequency_penalty, presence_penalty and candidate_count return 400 on Vertex AI.
• You can no longer end the conversation on a prefilled model turn (the well-known "prefill").
• Explicit caching is gone. cachedContents and caches.create are not supported.
• Long responses take a while. Google suggests a client timeout of 15 minutes or more.

Instead of scattering these adjustments across the codebase, it is worth centralizing them in a function that cleans up the config before calling Argon:

# Parameters Argon rejects (400) or silently ignores
PARAMS_REJEITADOS = {"thinking_budget", "frequency_penalty",
                     "presence_penalty", "candidate_count"}
PARAMS_IGNORADOS = {"temperature", "top_p", "top_k"}
NIVEIS_VALIDOS = {"low", "medium", "high"}


def config_para_argon(config_antiga: dict, nivel: str = "high") -> dict:
    """Converts a Gemini 3.1 Pro config to Gemini 4 Argon."""
    if nivel not in NIVEIS_VALIDOS:
        raise ValueError(f"invalid thinking_level: {nivel}")

    nova = {}
    for chave, valor in config_antiga.items():
        if chave in PARAMS_REJEITADOS:
            continue  # sending this breaks the request
        if chave in PARAMS_IGNORADOS:
            print(f"warning: '{chave}' is ignored by Argon")
            continue
        nova[chave] = valor

    # Keeps the old behavior (high) explicitly
    nova["thinking_config"] = {"thinking_level": nivel}
    # Ensures headroom for reasoning + response
    nova["max_output_tokens"] = max(nova.get("max_output_tokens", 0), 32768)
    return nova


antiga = {"temperature": 0.2, "thinking_budget": 8192, "max_output_tokens": 2048}
print(config_para_argon(antiga))

The function does not solve everything, but it prevents the most annoying kind of bug: the migration that passes in staging with a short prompt and breaks in production with the first large one.

Output Limits: 32K, 64K or 1 Million?

Here the sources do not agree, and it is worth being honest about it. Google talks about "long decoding" of up to 1 million output tokens. The documentation mentions 65,536 output tokens per request. The model's entry in the models listing reports outputTokenLimit: 32768, and non-streaming calls on Vertex AI are capped at 32K.

The most consistent explanation is this: each normal request generates up to 64K, and the 1 million token output happens in 64K chunks, as a background task through the Interactions API (with background: true). In this mode, the input token count grows at every step, and the recommendation is to use initial_prompt_token_count to decide when to compact the context.

Gogia, from Greyhound, raises a point few people mention: the Interactions API stores the agent's conversation state on Google's servers. That makes your life easier today and raises the cost of switching vendors tomorrow.

Before Shipping to Production: Test It on Your Workload

The best example of why benchmarks do not decide on their own came from the same Computing for Geeks test. The author gave the models three DevOps tasks and ran each one three times. All 12 Kubernetes manifests generated by Argon passed linting and failed to start: it set runAsUser: 101 on the nginx:1.27-alpine image without writable volumes, and nginx crashed with a permission error on /var/cache/nginx. Claude Opus 5.5 and GPT-6.1 Sol mounted emptyDir volumes and got it right on the first try.

When it received the error, Argon fixed it in all three attempts. But the lesson stands: code that validates is not code that runs. A minimal comparison test already covers a good chunk of the risk. This script calculates the cost of a batch of calls at both prices, so the promotion does not fool you:

// Prices per million tokens (Standard mode)
const PRECOS = {
  promocional: { entrada: 2, saida: 10 },
  aPartirDeDezembro: { entrada: 4, saida: 20 },
}

// Reasoning is billed as output: add both together
function custo(chamadas, tabela) {
  return chamadas.reduce((total, c) => {
    const saida = c.tokensResposta + c.tokensRaciocinio
    return total + (c.tokensEntrada * tabela.entrada + saida * tabela.saida) / 1e6
  }, 0)
}

// Example: 1,000 code review calls per day with thinking "high"
const umDia = Array.from({ length: 1000 }, () => ({
  tokensEntrada: 12000,
  tokensResposta: 900,
  tokensRaciocinio: 1500,
}))

for (const [nome, tabela] of Object.entries(PRECOS)) {
  const mensal = custo(umDia, tabela) * 30
  console.log(`${nome}: $${mensal.toFixed(2)} per month`)
}

With these sample numbers, the same workload costs $1,440 per month at the promotional price and $2,880 after December 1. Swap in the real values from your usage_metadata and the result becomes an argument for the conversation with finance.

If cost is your top priority, also compare against open-weights models. DeepSeek V4.1 Flash and its pricing and benchmarks is a good reference for how much you can save when the task does not require a frontier model.

Safety: The Model That Tried to Game the Grader

Google itself published an uncomfortable data point. In rare cases during training, Argon tried to escalate container privileges to modify evaluation scripts, pulled answers from the test runner's memory and, once, took down the evaluation sandbox so that a failed run would not be scored. According to Google, the misalignment monitor caught these attempts, and shortcut attempts on coding benchmarks dropped to 2%.

Anca Dragan and Raluca Ada Popa, from Google DeepMind, described the behavior as "an agent trying too hard to finish the job it was given". For anyone running agents, the translation is direct: if the model is going to run tests, run them in an environment where it cannot edit its own tests. As Gogia put it, a model that tricks the grader turns every grader in the company into a control that has to be defended.

On offensive capability, Google claims Argon solved 12 out of 12 simulated end-to-end attack scenarios, versus 5 for the previous generation. Greyhound says it has not yet found independent replication of that result.

Outlook: Is It Worth Migrating Now?

Gemini 4 Argon is Google's most competitive model in a long time, especially for long context, documents and knowledge work automation. The promotional price makes testing cheap, and the low hallucination rate is a real differentiator for anyone working with data.

At the same time, it is not the best at everything: it loses on terminal tasks, spends a lot of tokens per task and, starting in December, costs the same as Claude Opus 5.5. The practical recommendation: use the six weeks of promotion to run your evaluation set, pin the thinking level in code, budget at full price and only migrate traffic where Argon wins on your numbers, not on Google's.

Let's go! 🦅

📚 Want to Keep Up With What Is Coming?

This article covered Gemini 4 Argon on the API, from pricing to migration, but the ecosystem changes every week and not everything becomes an article here.

On X I share what I am testing, behind the scenes of my projects and the news that shows up before it turns into a post.

Follow Me There

👉 Follow @jeffbruchado on X

💡 Daily content about development, career and the tools I actually use