Google made Gemini 4 Argon generally available on October 13, 2026. For teams building coding tools, AI agents or AI features inside web and mobile apps, it is now the most capable Gemini model you can call in production. Two details deserve more attention than the launch headlines: the introductory price ends on November 30 and then doubles, and moving from Gemini 3.x is a real code change, not a model-name swap. Here is our read on what changed and what to do this quarter.

What Google shipped on October 13

Argon was first announced on September 30, but only for a vetted group of cyber defenders through Google's Fairwind Program. Two weeks later it opened up. According to Google's announcement, it is now available globally:

  • to developers and enterprises through the API in AI Studio and the Gemini platform;
  • in Google Antigravity for Google AI Ultra subscribers, and for businesses on eligible Gemini Enterprise subscriptions;
  • in the Gemini app and AI Mode in Search for AI Ultra and Pro subscribers;
  • client-side in mobile and web apps through Firebase AI Logic, for developers on the paid tier of the Gemini API.

The API model ID is gemini-4-argon. Google positions it for complex software engineering, deep mathematical and scientific problems, autonomous multi-step agents and long decoding. One access caveat: Argon is not available on the API's Free tier or on the Google AI Pro plan in AI Studio, so prototyping on a free key is not an option. Pro subscribers do get it in the Gemini app.

The price that matters is the December price

Google's API documentation lists two sets of rates:

Per 1M tokens Through Nov 30, 2026 From Dec 1, 2026
Input $2.00 $4.00
Cached input (implicit) $0.10 $0.20
Output $10.00 $20.00

Every line doubles. If you build a business case, a pricing tier or a client quote on the October numbers, the margin disappears seven weeks later.

Two things make the output line heavier than it first looks:

  • Thinking tokens are billed as output. An agent reasoning hard pays for that reasoning at the output rate, even though users never see the text.
  • The default isn't the cheapest setting. MEDIUM is the default thinking level on Argon, so requests you never tune will reason more than they would at LOW.

Our advice: model costs at $4 / $20 per million from day one, log input, output and thinking tokens separately per feature, and treat the November invoice as a discount rather than a baseline. Implicit caching helps. It is on by default for prompts of at least 4,096 tokens and cuts cached input cost by 95%, so keep large, stable content (system prompts, tool definitions, reference documents) at the start of your prompts, where the cache can match it.

Gemini 4 Argon migration: what breaks when you switch from 3.x

Google's migration docs list several changes. Some fail loudly; the riskier ones fail silently.

Change What happens on Argon What to do
temperature, top_p, top_k, candidate_count Ignored, with only a deprecation warning Remove them and re-test behavior that relied on them
Explicit caching (cachedContents / caches.create) Returns an error Remove it and rely on implicit caching
thinking_budget Gemini API: deprecation warning, mapped to the nearest level; Google Cloud: HTTP 400 Use thinking levels: LOW, MEDIUM, HIGH
MINIMAL thinking level Returns an error Use LOW
Non-streaming responses Max 32,768 tokens (65,536 on 3.x) Stream long outputs (up to 65,536 per request)
HTTP timeouts Long calls are expected Set client timeouts to at least 20 minutes
Multi-turn and function calling Needs thought signatures Send the full history, including thought signatures

The ignored sampling parameters are the real trap. If a 3.x feature depended on a low temperature for consistent output, such as classification, extraction or structured replies, nothing will error (you only get a deprecation warning), but behavior can drift. You will only catch that with evaluation tests.

There are SDK floors too: google-genai 2.30.1 for Python, @google/genai 2.29.1 for JavaScript, and minimums for Go (1.74.0), Java (1.77.0), .NET (1.26.0) and Kotlin (1.6.0). Older SDKs and the OpenAI compatibility layer cannot retrieve long completions using continuation tokens, which matters if you reach Gemini through an OpenAI-style client today.

Finally, input and output share a single 1,048,576-token limit, and output includes thinking, function calls and the final response. A very large prompt leaves less room for reasoning and answers.

A Python call that respects these rules looks roughly like this (check field names against your SDK version):

from google import genai
from google.genai import types

# Long agentic calls: allow at least 20 minutes (value in milliseconds)
client = genai.Client(http_options=types.HttpOptions(timeout=20 * 60 * 1000))

stream = client.models.generate_content_stream(
    model="gemini-4-argon",
    contents=history,  # full history, including thought signatures
    config=types.GenerateContentConfig(
        thinking_config=types.ThinkingConfig(thinking_level="LOW"),
        # Removed: temperature, top_p, top_k, candidate_count (ignored)
        # Removed: thinking_budget (deprecated), cached_content (error)
    ),
)
for chunk in stream:
    handle(chunk)

We recommend running this kind of migration on a branch, behind a feature flag, with an eval suite that compares 3.x and Argon outputs on the same inputs before any production traffic moves.

Test it on your own work, not Google's benchmarks

Google says Argon sets a new state of the art on DeepSWE v1.1 with 77.9%, a benchmark for long-horizon software engineering. These are Google's own measurements, and there is no independent verification yet.

That doesn't make Argon weak. It means a leaderboard can't tell you whether it is better for your codebase, your agent's tools or your users' language. A practical evaluation:

  1. Collect a few dozen real tasks from your product: tickets, prompts, agent runs that previously failed.
  2. Run them on your current model and on Argon at LOW, MEDIUM and HIGH.
  3. Score quality, latency and total cost, including thinking tokens, at December prices.
  4. Decide per feature, not per company. Argon may win for code review and lose on cost for chat.

Mix models instead of running Argon everywhere

Google's developer guide notes that its own developers often pair Argon with Gemini 3.8 Flash subagents as high-speed implementation workers. It is a common pattern in agent design: an expensive model plans and reviews, cheaper models execute.

A typical split looks like this:

  • Argon: breaking a task into steps, writing the plan, reviewing the final diff or answer, handling the cases where cheaper models fail.
  • A faster model: file edits, summaries, data extraction and tool calls with clear instructions.
  • Per-role thinking levels: HIGH only where review quality pays for itself, LOW for routine planning.

If you expose Argon client-side through Firebase AI Logic, remember that every user action can turn into billable output and thinking tokens. Put per-user limits and usage monitoring in place before launch, not after the first invoice.

If your stack is Azure-first

Much of Loop's client work runs on Microsoft Azure. We have not been able to confirm that Argon is offered in Microsoft Foundry, so for now we plan as if using it means calling Google's API directly, which adds a second AI provider. That brings practical work: reviewing Google's data-processing terms for your UK or Türkiye clients, separate keys and billing, and separate monitoring.

The durable fix is to keep model choice behind your own abstraction layer, so provider-specific options stay out of business logic:

type Effort = "low" | "medium" | "high";

interface ModelClient {
  complete(input: Message[], opts: { effort: Effort; stream?: boolean }): Promise<Completion>;
}

// Each adapter maps "effort" to its provider's settings:
// Argon -> thinking level; other models -> their own reasoning or sampling options.

With routing driven by configuration, trying Argon for one feature, or rolling it back, becomes a config change instead of a refactor.

Key takeaways

  • Gemini 4 Argon is generally available via the Gemini API, AI Studio, the Gemini platform, Antigravity and Firebase AI Logic, but not on the Free tier.
  • Budget at $4 input / $20 output per million tokens; the launch rates end November 30, and thinking tokens bill as output.
  • Migrating from 3.x is a code change: sampling parameters are ignored, thinking_budget is deprecated (HTTP 400 on Google Cloud), explicit caching errors, non-streaming output is capped at 32,768 tokens, and timeouts need to be at least 20 minutes.
  • Google's benchmarks are self-reported; evaluate Argon on your own tasks before switching.
  • Use Argon for planning and review, cheaper models for routine work, and keep providers behind your own abstraction layer.