Gemini 4 Argon Pricing and Access: What You Can Use Today

Gemini 4 Argon is Google DeepMind's newest frontier model, announced on September 30, 2026. Google built it for long, multi-step work: real-world software engineering, enterprise knowledge work in law and finance, and defensive cybersecurity. Two numbers define it. The output token limit is 1M tokens, up from 64K on earlier Gemini models. And the introductory price is $2 per million input tokens and $10 per million output tokens, with cached input tokens at 95% off the input price.

The catch is access. As of mid-October 2026, Argon is only rolling out to a set of trusted cyber defenders through Google's Fairwind Program. Google says the wider release will start with paid API customers and Google AI Ultra subscribers, but it hasn't published a date. If you're a developer waiting for a model ID to drop into your API calls, you're still waiting.

What Gemini 4 Argon is#

Argon is the first model Google has announced under the Gemini 4 name, and the company positions it as a model for 'long-horizon' tasks. That phrase shows up again and again in the announcement, and it's the key to the design. Earlier Gemini models could reason well, but a 64K output ceiling meant any agentic run that needed to think, write code, read results and keep going had to be split into many calls with state handed between them. Argon's 1M output limit is meant to let a single trajectory run for hundreds of thousands of tokens without that scaffolding.

Google lists four areas where it trained for frontier-level results: coding, knowledge work (legal, finance, tax), cybersecurity defense, and creative writing. The announcement also calls out multimodal strength, specifically professional chart analysis, picking details out of long videos, and taking action based on a series of documents.

A few things the announcement does not say, which matters because people search for them:

• No input context window size is stated. Only the output limit is given.
• No API model ID string is published.
• No head-to-head numbers against other vendors' models are given.

When those details appear, they'll land on the Gemini API models page. Check there rather than trusting secondhand numbers.

Gemini 4 Argon pricing and the 95% cache discount#

Google published two price tiers: an introductory rate at launch, and the rate that applies once the introductory period ends. It did not say how long that period lasts.

The cache discount is the number worth paying attention to if you run agents. In agentic coding, most of what you send on each turn is the same repository context, system prompt and tool definitions you sent on the previous turn. A 95% discount on those tokens means the fresh part of each request dominates the bill, not the repeated context.

Here's a small calculator for a typical agent turn. It compares the introductory and standard tiers, with and without cache hits.

# Cost of one Gemini 4 Argon request at introductory vs standard pricing.
# Prices are USD per 1M tokens, from Google's Sep 30, 2026 announcement.
PRICING = {
    'introductory': {'input': 2.00, 'output': 10.00},
    'standard':     {'input': 4.00, 'output': 20.00},
}
CACHE_DISCOUNT = 0.95  # cached input tokens are 95% off the input price

def request_cost(tier, fresh_in, cached_in, out):
    p = PRICING[tier]
    cached_rate = p['input'] * (1 - CACHE_DISCOUNT)
    total = fresh_in * p['input'] + cached_in * cached_rate + out * p['output']
    return total / 1_000_000

# One agent turn: 20K fresh input, 180K cached context, 8K output tokens
for tier in PRICING:
    with_cache = request_cost(tier, 20_000, 180_000, 8_000)
    no_cache = request_cost(tier, 200_000, 0, 8_000)
    print(f'{tier:13s} with cache: {with_cache:.4f} USD   without cache: {no_cache:.4f} USD')

Two pieces of advice. First, build your budget on the standard rate and treat the introductory rate as a bonus, because Google hasn't said when it ends. Second, confirm the live numbers on the Gemini API pricing page before you ship, since the announcement is a launch post, not a price sheet, and it carries a footnote about the introductory period for a reason.

The 1M output token limit and what it changes#

The previous Gemini output limit was 64K tokens. Argon raises it to 1M. Google's framing is that when the model has headroom to think and generate hundreds of thousands of tokens in one go, it can solve harder problems in a single pass instead of being cut off mid-plan.

For developers, that changes two things. The first is architecture: tasks you currently chunk because of the output ceiling, like generating a large migration, a long structured report, or a full agent trajectory with intermediate reasoning, may fit in one call. The second is cost exposure. Output tokens are the expensive side of the price list, and the ceiling just grew a lot.

// How the output ceiling and worst-case response cost changed.
const OLD_LIMIT = 64_000;
const NEW_LIMIT = 1_000_000;
const outputPrice = { introductory: 10, standard: 20 }; // USD per 1M output tokens

console.log(`Output limit grew ${(NEW_LIMIT / OLD_LIMIT).toFixed(1)}x (${OLD_LIMIT} -> ${NEW_LIMIT} tokens)`);
for (const [tier, price] of Object.entries(outputPrice)) {
  const fullNow = (NEW_LIMIT / 1_000_000) * price;
  const fullBefore = (OLD_LIMIT / 1_000_000) * price;
  console.log(`${tier}: a max-length response costs ${fullNow.toFixed(2)} USD, versus ${fullBefore.toFixed(2)} USD at the old 64K limit`);
}

I'd keep an explicit output cap on every call and raise it only for the jobs that need it. A runaway loop that could cost you a few cents at 64K can cost real money at 1M.

Gemini 4 Argon benchmarks#

Every figure below comes from Google's own announcement. There are no third-party reproductions yet, and the model isn't publicly available to run your own. Read them as claims, not settled results.

The coding number is the one most readers care about. DeepSWE v1.1 is a long-horizon task suite, which fits the model's design goal, but note the version suffix. Scores on one version of a benchmark don't transfer to another, and the same goes for CWE-bench, where Google separately notes its earlier 3.8 Flash Cyber model's results were on v0.

On the security side, Google says Argon can autonomously find, validate and patch critical vulnerabilities. On its internal vulnerability benchmark it found exposures across codebases in 20 programming languages, and on Wiz's black-box penetration testing benchmark it outperformed 3.8 Flash Cyber at mapping attack surface, finding vulnerabilities and producing proof-of-concept evidence.

Gemini 4 Argon vs Opus 5.5, GPT 6.1 Sol and GPT 6 Astra#

People search for these comparisons, so here's the honest answer: Google's announcement doesn't name a single competing model or publish a head-to-head table. Any 'Argon vs Opus 5.5' or 'Argon vs GPT 6 Astra' scorecard you find right now was assembled by someone else from separately published numbers.

If you want to do that comparison yourself, keep it fair:

• Match benchmark versions exactly. DeepSWE v1.1 against DeepSWE v1.1, not v1.0.
• Match the harness. Agentic coding scores depend heavily on the scaffold, tool set and retry policy around the model.
• Compare cost per completed task, not cost per token. A model that finishes in one 300K-token trajectory can be cheaper than one that needs ten 40K calls with orchestration overhead, or more expensive. The token price alone won't tell you.
• Wait for public access. A vendor-reported score on a model you can't run is a hypothesis.

My own recommendation is to not switch anything until you can run Argon on your own eval set. The 1M output limit is a real architectural difference, but whether it beats your current model on your workload is unknowable from a launch post.

Who can use Gemini 4 Argon today#

As of this writing, access is limited to trusted cyber defenders in Google's Fairwind Program. Google frames this as a phased release: it's gathering feedback from early testers and iterating on guardrails before opening up. It's also participating in the U.S. government's voluntary pre-release model access process.

For those defenders and for Google's internal teams, Argon ships without cyber guardrails so they can use its full vulnerability-finding capability. Wiz is already using it through its Scan for Good initiative, which looks for high-risk exposures in critical public infrastructure for free. Google says the model found a critical vulnerability exposing personal information in healthcare software used by hospitals worldwide, one that earlier frontier models had missed.

The public rollout order Google gave is:

1. Paid API customers
2. Google AI Ultra subscribers
3. Enterprises and consumers after that

No dates are attached to any of these. When it does reach the API, the Gemini API quickstart is where the first working example will show up, and the models page will list the model ID and limits.

What Google says it's doing with Argon internally#

The announcement includes several internal case studies. They're useful less as proof and more as a picture of what 'long-horizon' means in practice:

• Quantum algorithm optimization. Argon helped researchers reduce the spacetime resources (qubits times gates) of bottleneck subroutines, beating a published baseline by 40% in minutes.
• Data center memory. A team of Argon agents read fleet-wide profiling telemetry and applied memory optimizations on their own, freeing over 300 TiB, with an estimated 500 TiB to 1 PiB in total savings.
• C/C++ to Rust migrations. Agents are migrating codebases from tens of thousands of lines (re2, libgav1) up to 800K+ lines for the Fuchsia Zircon kernel. Google notes these go through automated and manual auditing, emulation testing and review before production.
• libgav1 SIMD rewrite. Starting from an existing Rust port, agents replaced 32K lines of SIMD code with safe Rust the compiler auto-vectorizes, using rounds of profile-guided experiments. The result runs 2.7x faster than the Rust port with identical video output.

The pattern across all of these is the same: many rounds of experiment, measurement and revision inside one task, which is exactly what a large output budget is for.

Gotchas and common mistakes#

• Assuming it's in the API now. It isn't. Fairwind Program participants only. Don't build a launch plan around a model ID that doesn't exist yet.
• Budgeting on the introductory price. The standard rate is $4 input and $20 output per 1M tokens, double the intro rate. Google hasn't said when the switch happens.
• Expecting the cache discount on output. The 95% discount is on cached input tokens. Output is full price.
• Setting the output cap to 1M everywhere. The limit is a ceiling, not a default you want. Cap each call to what the task needs.
• Reading 'no cyber guardrails' as the public product. That applies to trusted defenders and Google's internal teams. The public version is explicitly designed to refuse harmful cyber and CBRN requests.
• Mixing benchmark versions. DeepSWE v1.1 and CWE-bench v1 are not interchangeable with earlier versions when you compare against other models.
• Treating the chain-of-thought as hidden. Google says it monitors Argon's reasoning and actions and will stop execution when a run goes beyond the user's intent. If you build agents on it, plan for the possibility that a trajectory is halted.

Quick reference#

• Announced: September 30, 2026, by Google DeepMind.
• Output limit: 1M tokens, up from 64K.
• Intro price: $2 per 1M input, $10 per 1M output, cached input at 95% off.
• Standard price: $4 per 1M input, $20 per 1M output.
• Headline coding score: 77.9% on DeepSWE v1.1.
• Other claims: 51.3% on AutomationBench, 91.7% on LVBench, 68% on CWE-bench v1.
• Access now: Trusted cyber defenders via the Fairwind Program.
• Access next: Paid API customers, then Google AI Ultra subscribers. No date given.
• Before you build: check the models and pricing pages on ai.google.dev, cap output tokens, budget on the standard rate.

Quick answers