Gemini 4 Argon: Benchmarks, Real Cost and Access (2026)

Google's new frontier model is open to everyone who pays, scores level with GPT-6 Astra, and doubles in price on December 1. Here is what it does, what it really costs, and where you can use it.

$2 in, $10 out, until November 30. That is what Gemini 4 Argon (gemini-4-argon) costs per million tokens on the paid Gemini API since it became generally available on October 13, 2026 - Gemini API pricing. On December 1 the standard price becomes $4 input and $20 output, the same list price as Claude Opus 5.5 - Anthropic pricing. The launch was the week's biggest AI story on Hacker News, with 1,461 points and more than 1,000 comments - Hacker News.

The headline numbers point in different directions, which is why this model is confusing to evaluate. Google's own table has Argon leading 13 of 19 benchmarks against GPT-6 Astra, Claude Fable 5.1 and Claude Opus 5.5 - Google DeepMind. The independent Artificial Analysis Intelligence Index puts it at 53, level with GPT-6 Astra and five points behind Opus 5.5 - Artificial Analysis. It ranks first on the Vals Index of finance, legal, tax and coding work, yet sixth on Terminal-Bench 4.0 - Vals AI. And the token price only tells half the story, because Argon thinks for a long time and Google bills that thinking as output.

The practical problem: the cheap price lasts about seven weeks, but anything you build on Argon will run for much longer than that. If you pick it because of the launch price, or skip it because of the doubling, you are deciding on the wrong number.

This guide covers what Argon is, what the benchmarks show once you separate Google's claims from independent tests, the full rate card across every tier and cloud, the real cost per task, every way to get access (app, API, cloud and the restricted cyber program), the API changes that break existing code, and a clear framework for deciding where it fits next to Claude and GPT. Every number comes from a source you can check, linked inline.

Contents

1. What Gemini 4 Argon Is and What Changed
2. Google's Benchmarks: What It Claims and How It Measured
3. Independent Benchmarks: What Outside Testers Found
4. The Full Price List: Every Tier, Every Cloud
5. The Real Cost: Price per Task, Not per Token
6. Access: Every Way to Use Argon Today
7. Building on Argon: The API Changes That Break Code
8. Where Argon Wins and Where It Fails
9. Argon vs Opus 5.5 vs GPT-6 Astra vs GPT-6.1 Sol
10. Security, Safety and the Fairwind Program
11. The December 1 Price Change: What to Do Now
12. Future Outlook: What Comes After Argon
13. Conclusion: How to Decide

Scorecard: Argon Against the Models You Would Actually Choose Between

Most readers searching for Argon are deciding between it and four or five other frontier models, so the scorecard comes first. It ranks the models a team would realistically shortlist in October 2026 on five criteria, using independent measurements wherever they exist instead of each lab's own numbers. The intelligence column uses the Artificial Analysis Intelligence Index, the coding column uses Artificial Analysis' own Terminal-Bench 4.0 runs, the knowledge-work column uses Vals AI and hallucination testing, and the cost column uses Artificial Analysis' measured cost per task, which already accounts for how many tokens each model burns.

Two choices shape the result. First, Argon's cost is scored at the price that applies from December 1 ($3.98 per task), not the launch price, because that is the price your product will live with. Second, the table rewards breadth: a model that is excellent at one job but weak at agentic coding lands lower than one that is good everywhere. If your workload is narrow, read the column that matches it rather than the final score.

How the scores were built. Intelligence (25%) uses the Artificial Analysis leaderboard scores. Agentic coding (25%) uses Artificial Analysis' independent Terminal-Bench 4.0 runs, with Google's FrontierSWE v2 numbers as a tiebreaker. Knowledge work (20%) uses the Vals Index and AA-Omniscience hallucination rates. Cost per task (20%) uses each model's measured cost per Intelligence Index task from its Artificial Analysis page, for example Claude Opus 5.5 and GPT-6.1 Sol. Access (10%) reflects how many places you can buy the model and whether a free tier exists. Final scores are weighted averages rounded half up to one decimal; GPT-6 Astra and GPT-6.1 Sol tie at 7.4 and are listed alphabetically.

The table says something the launch coverage mostly missed. Argon is not the strongest model overall, and it is not the cheapest, but it is the only one that is near the top on intelligence while also leading on knowledge work and staying well below the Claude models on cost per task even after the price doubles. That combination is the reason to take it seriously. The rest of this guide explains each column in depth, so you can decide whether Argon's strengths line up with the work you actually need done.

1. What Gemini 4 Argon Is and What Changed

Argon is Google's first Gemini 4 model, and its launch happened in two steps. Google announced it on September 30, 2026, but only for trusted cyber defenders in its Fairwind Program and a small group of testers, promising a wider rollout that would start with paid API customers and Google AI Ultra subscribers - Google. Thirteen days later, on October 13, Google made it globally available: in the paid Gemini API and AI Studio, in Antigravity for Ultra subscribers, in the Gemini app for Pro and Ultra subscribers, and in AI Mode in Search - Google, October 13.

Google describes Argon as a model for long-horizon work: real software engineering, enterprise knowledge work in law and finance, science, and cybersecurity defense. The design choices back that up. It can reason for longer than earlier Gemini models, it can write far longer answers, and Google tuned its behavior for multi-step agent work rather than quick chat. The previous top Google model on the Artificial Analysis index, Gemini 3.1 Pro Preview, scored 30; Argon scores 53, a 23-point jump that took Google from a clear step behind to level with OpenAI's flagship - Artificial Analysis.

1.1 The specifications that matter

The model page lists one stable ID, gemini-4-argon, with no preview or dated variants, which simplifies pinning a version in production - Gemini API model page. It reads text, images, video, audio and PDFs, and it writes text only. It does not generate images or audio, and it does not support the Live API for real-time voice, so it is not a drop-in for voice agents.

The most unusual specification is the token window. Input, thinking and output share one 1,048,576-token window. A normal synchronous answer is capped at 65,536 tokens by default, but with long decode a single answer can run up to the full window minus your input - What's new in Gemini 4 Argon. Earlier Gemini models stopped at 64K output tokens. For comparison, Opus 5.5, Sonnet 5.5, GPT-6 Astra and GPT-6.1 Sol all list 128,000 output tokens as their maximum in their providers' model listings, so Argon's output ceiling is roughly eight times higher on paper.

Supported tools include code execution, function calling, file search, grounding with Google Search and Google Maps, URL context, structured outputs, and computer use (in preview). Argon can also be bought through the Batch, Flex and Priority tiers, which matter a lot for cost and are covered in section 4.

1.2 What actually changed for users

For people using the Gemini app, Google says Argon answers more directly, hedges less, repeats itself less, and reports progress more often on long jobs - Gemini app update. The same release added a Tasks mode, switched on with a toggle in the chat window, which lets Gemini keep working across your Google apps while you are away from the computer, plus connections to more than 40 apps including Instacart, OpenTable, Adobe and Shopify. Google also put Antigravity's agentic coding interface inside the Gemini macOS app.

For developers, three changes stand out. First, the thinking level (low, medium or high) is now the main control over quality, speed and cost. Second, Argon ignores temperature, top_p and top_k, so prompts that relied on low temperature for consistent output behave differently. Third, Argon drops explicit context caching entirely in favor of automatic caching. Section 7 walks through each change with code.

In this launch video, Logan Kilpatrick talks with Josh Woodward, Melvin Johnson, Sergey Brin and Tulsee Doshi about where Argon is available, how around 100,000 Googlers tested it before release, and what the one million output tokens mean in practice (the 23:02 chapter).

The conversation is useful context for one specific claim: Google built and tested Argon heavily on its own internal work before release. VentureBeat reports more than 100,000 employees use it monthly through an internal version of Antigravity, and that over four weeks, agentic code submissions rose 35% while rollbacks fell 30% - VentureBeat. Those are Google's numbers, not independent ones, but they explain why Google is confident about long, real-world coding tasks.

Why this matters: Argon is not a small update to Gemini 3. It changes the output ceiling, the caching model and the control surface (thinking levels instead of sampling parameters), so treating it as a simple model swap will produce surprises in cost and behavior. How to apply this: before switching anything, write down which of your current settings depend on temperature, explicit caching or short output caps, because those are exactly the settings Argon changes. Then read the benchmark sections with your own task type in mind, since Argon's strengths are concentrated in specific kinds of work.

2. Google's Benchmarks: What It Claims and How It Measured

Google published a 19-row comparison table against GPT-6 Astra, Claude Fable 5.1 and Claude Opus 5.5, grouped into knowledge work, agentic coding, ML engineering, science, long context, computer use, multimodal understanding and cybersecurity - Google DeepMind. Argon has the top score in 13 rows, ties for first in one, and loses five. That is a strong showing, but it is a vendor's table, and the way a vendor picks rivals, settings and harnesses can move numbers by several points.

The table below is Google's own graphic. Look at where the highlighted column is not the best one, because those rows tell you as much as the wins.

2.1 Where Argon leads, by Google's numbers

The widest gaps are in knowledge work. On Harvey's Legal Agent Benchmark, Argon scores 19.6% against 5.4% for Astra and 3.8% for Opus 5.5. On Zapier's AutomationBench, it scores 51.3% against 42.5% for Opus 5.5. On Vals Finance Agent v2, it scores 65.4% against 58.6% for Opus 5.5. These are agentic tests where the model has to complete a multi-step professional task, not answer a quiz, which is why a gap of several points is meaningful.

Argon also leads on long context. On GraphWalks with 256K to 1M tokens of context, it scores 84.2% against 71.8% for Astra and 66.8% for Opus 5.5. That is the clearest sign that Google's long-context engineering still has an edge. It leads on video too: 91.7% on LVBench for long video understanding. In coding, it tops DeepSWE v1.1 at 77.9% (Opus 5.5 at 74.2%) and Vibe Code Bench at 91.9%.

2.2 Where Argon loses, by Google's own numbers

The five losing rows are concentrated in one area: agentic work in a terminal or an operating system. Argon scores 57.4% on Terminal-bench 4.0 against 66.4% for Opus 5.5, 55.0% on FrontierSWE v2 against 65.5% for Astra, and 69.2% on the OSWorld-2.0 offline subset against 72.6% for Astra. It also trails on PostTrainBench (ML engineering) and Terminal-Bench Science. If your main use case is an autonomous coding agent working in a shell, Google's own table tells you Argon is not the leader.

2.3 How Google measured: the caveats in the methodology

Google's five-page evaluation methodology explains how each number was produced, and it is worth reading before you quote any row - Gemini 4 Argon model evaluation. All Argon scores are pass@1, meaning one attempt per task with no majority voting, and smaller benchmarks were averaged over several trials to reduce noise. That is good practice and makes the Argon side of the table fairly clean.

The comparison side is where the fine print sits. A benchmark score depends on three things besides the model: the reasoning setting it ran at, the harness (the agent scaffolding that feeds it tools and context), and who ran it. Change any of the three and a score can move by several points, which is often larger than the gap between two frontier models. Four details from the methodology change how you should read the table:

• Highest thinking settings were used for Argon unless noted, so default-setting results will be lower
• Rival numbers are self-reported by OpenAI and Anthropic in most rows, not rerun by Google
• DeepSWE and Terminal-bench were self-computed for Argon, while rivals came from public leaderboards
• LVBench used 1 frame per second for Gemini but 300 to 800 frames for rivals because of their API limits

None of this is unusual, and Google discloses it openly. But it means the table compares Argon run by Google under Google's chosen settings with competitors as they reported themselves. The OSWorld-2.0 score, for example, is the best of three runs, and the LVBench gap partly reflects how many video frames each API accepts rather than pure reasoning. When a lead is small (Vibe Code Bench, 91.9% vs 90.3%), treat it as a tie. When a lead is large and the test is run by a third party (Vals Index, Harvey's benchmark, AutomationBench), it is more trustworthy.

There is also a subtler issue: which rivals appear. Google compares Argon with Astra, Fable 5.1 and Opus 5.5, but not with Claude Sonnet 5.5, which is the model that beats Argon on several independent leaderboards. On Vals AI's live table for Harvey's Legal Agent Benchmark, Argon's 19.58% ranks sixth of 80 models, even though it towers over the three rivals Google chose to show - Vals AI. A vendor table answers "is it better than these models?" It does not answer "is it the best available?"

Why this matters: Google's table is a reasonable starting point, and most of its large leads are confirmed independently (section 3). But the rows where Argon loses are exactly the ones most coding-agent buyers care about. How to apply this: use Google's table to shortlist Argon for knowledge work, long documents, video and large code migrations; then rely on independent results, and ideally your own evaluation, for anything involving autonomous terminal or computer-use agents. We explain why vendor coding scores so often fail to transfer in why AI coding benchmarks lie.

3. Independent Benchmarks: What Outside Testers Found

Independent testing is where a model's launch claims meet reality, and for Argon the picture is consistent across five separate testers. Artificial Analysis, Vals AI, ARC Prize, the Arena human-preference leaderboard and Epoch AI all ran or ranked Argon within days of release. They agree on the broad shape: Argon is a genuine frontier model, it is unusually strong at professional knowledge work and at saying "I don't know", and it trails the Claude models at agentic coding in a terminal.

The reason to weight these results above Google's own is simple. Each tester runs every model through the same harness at a setting it documents, so the numbers are comparable across labs in a way vendor tables are not. They are also run by organizations whose business depends on being trusted by buyers rather than by the lab whose model they are testing. None of them is perfect, and section 3.6 covers what they still miss, but together they are the best public evidence available.

3.1 Artificial Analysis: level with GPT-6 Astra, behind Claude

The Artificial Analysis Intelligence Index combines ten evaluations, including GDPval-AA, AutomationBench-AA, Terminal-Bench 4.0, Humanity's Last Exam, SciCode and the AA-Omniscience knowledge test. Argon at its high thinking level scores 53, the same as GPT-6 Astra and Claude Fable 5.1, one point above GPT-6.1 Sol, and behind Claude Sonnet 5.5 at 56 and Claude Opus 5.5 at 58 - Artificial Analysis. On the full leaderboard it ranks 8th of 217 models, with the class median at 27 - Artificial Analysis model page.

The index hides two results that pull in opposite directions. On AutomationBench-AA, Zapier's test of multi-step workflows across business software, Argon is first at 77.5%, ahead of Sonnet 5.5 at 71.3% and Opus 5.5 at 69.5%. On Terminal-Bench 4.0, the test of coding and system work in a real terminal, Argon scores 57.1% and places fourth, behind Sonnet 5.5 at 63.6%, Opus 5.5 at 59.6% and Astra at 59.1%. In plain terms, Argon is the best of the group at running a business process across apps, and not the best at being a software engineer in a shell.

The most distinctive independent result is about hallucination. On AA-Omniscience, which penalizes wrong answers but not refusals, Argon's hallucination rate is 15%, the lowest among all models scoring 45 or more on the index, against 51% for GPT-6 Astra and 54% for GPT-6.1 Sol. Its raw accuracy on the same test is lower than Astra's (50% vs 63%), so Argon does not know more facts; it is simply far more willing to say it does not know. For a legal memo or a financial summary, that trade is usually the right one, as section 8 explains.

3.2 Vals AI: first on professional work, weaker on computer use

Vals AI runs a large battery of professional and coding benchmarks and combines several into the Vals Index. Argon ranks first of 49 at 68.90%, ahead of Claude Sonnet 5.5 (67.04%), Claude Opus 5.5 (66.97%) and Claude Fable 5.1 (65.83%) - Vals AI. It is also first of 79 on Finance Agent v2 (65.40%) and ties GPT-6 Astra for first on the IOI programming olympiad set with a perfect score.

Vals also reports cost and time, which makes its numbers unusually practical. At the standard $4/$20 price, Vals measured an average of $15.68 per Vals Index test on Argon against $21.34 on Sonnet 5.5, $28.71 on Fable 5.1 and $32.14 on Opus 5.5. So even after the price doubles, Argon finished this professional workload for roughly half of what Opus 5.5 cost. The catch is time: Vals reports an average of 46 minutes and 33 seconds per Vals Index test, and the long agentic tasks get expensive, with $193.78 per test on CUA-bench and $57.82 on Code Migration.

The weak spots on Vals line up with the other testers. Argon ranks 8th of 9 on CUA-bench (computer-use agents) at 4.83%, 6th of 49 on Terminal-Bench 4.0, and 6th of 80 on Harvey's Legal Agent Benchmark. It ranks second to Sonnet 5.5 on both Vibe Code Bench and Code Migration. Put together, Vals shows a model that is excellent at the reasoning inside professional tasks and merely good at driving software on its own.

3.3 ARC Prize: near the top, with a harness asterisk

ARC Prize tests abstract reasoning on puzzles that are easy for people and hard for models. Argon scores 98.5% on ARC-AGI-1 and 91.3% on ARC-AGI-2 at high reasoning, falling to 42.1% on ARC-AGI-2 at low reasoning - ARC Prize. That last number is a useful reminder that the thinking level is not a minor setting: the same model lost more than half its score when told to think less.

On the interactive ARC-AGI-3, the result depends heavily on the harness. With the Provider Adapter harness, which preserves the model's reasoning state between steps, Argon scores 97.5%. With the Standard harness, which only lets the model carry simple notes between rounds, it scores 49.8% at low reasoning, and the high-reasoning runs were incomplete because of API problems (19 of 55 games finished). The Decoder reports that GPT-6 Astra reached 99.9% on the Provider Adapter setup and that Argon's 97.5% run cost about $4,800 - The Decoder. Treat the 97.5% as proof of capability with the right scaffolding, not as a number your own agent will hit.

3.4 Arena and Epoch: preferred by people, close on the composite

On the Arena text leaderboard, where people vote between anonymous answers, Argon sits first at 1,524 points, ahead of Meta's Muse Wonder (1,509) and Claude Opus 5.5 (1,508) - Arena. The score is marked preliminary with about 4,900 votes and a margin of plus or minus 9, so its lead over Opus 5.5 is inside the error band. It still fits Google's claim that Argon writes more directly, and several Hacker News users singled out its writing quality.

Epoch AI's Capabilities Index, which combines more than 50 benchmarks into one scale, puts Argon at 165, tied with Fable 5.1 and just behind GPT-6 Astra (166) and Opus 5.5 (167), as reported by The Decoder. A spread of two points across four models from three labs is the clearest sign that the frontier is crowded: there is no longer a model that is far ahead of the others on general ability.

3.5 Early user reports: strong, with reasoning loops

User reports in the first week add texture the benchmarks miss. An evaluator running 100 competitive coding environments placed Argon between Claude Fable 5 and Fable 5.1, roughly two months behind the frontier, and noted that older Google models struggled inside agent harnesses while Argon appears to have fixed that - Hacker News. The same evaluator flagged a new problem: Argon was the first near-frontier model in a long time they had caught in infinite reasoning loops. Another user claimed roughly 1 in 10 tasks got stuck in a loop or errored - Hacker News. That is an anecdote, not a measurement, but it matches the long Vals run times and is worth guarding against in code (section 7).

3.6 What the independent numbers still miss

Every one of these tests runs Argon at high or maximum reasoning, because that is how labs and testers compare frontier models. Google's own documentation recommends medium as the default and tells developers to test all three levels. So the scores above describe Argon's ceiling, not what a default API call returns, and the costs describe a fully thinking model. Your production setup will often be cheaper and somewhat weaker than these tables suggest.

Why this matters: independent testers confirm Google's large leads in knowledge work, long context and automation, and confirm its losses in terminal coding and computer use. That consistency is the most reliable signal in this whole launch. How to apply this: if your work looks like AutomationBench or the Vals Index (multi-step professional tasks with documents and business apps), Argon belongs on your shortlist at the top. If it looks like Terminal-Bench (an agent writing and running code in a shell), start with the Claude models and test Argon as a cheaper alternative. For the full model field across these tests, see our October 2026 ranking of LLMs for AI agents, and for why more thinking often looks like more intelligence, see are AI models smarter or just searching more.

4. The Full Price List: Every Tier, Every Cloud

Google sells Argon through more doors than most buyers realize, and the prices behind each door differ. The Gemini Developer API has five tiers (Standard, Batch, Flex, Priority and an invite-only Contributor tier). Google Cloud's Gemini Enterprise Agent Platform (the successor to Vertex AI) has its own price list with a regional surcharge. And there is a separate, restricted Cyber Permissive version that never gets the launch discount. Every one of these prices doubles on December 1, with one exception that matters for cash flow.

Two rules apply everywhere and shape every bill. First, the output price includes thinking tokens: when Argon reasons for 20,000 tokens before writing a 2,000-token answer, you pay output rates on 22,000 tokens. Second, Argon only supports implicit caching: Google caches repeated prompt prefixes automatically and discounts cache hits by 95%, for prompts of at least 4,096 tokens, and you cannot create or manage caches yourself - Gemini API pricing. There is also no free tier, so every experiment is billed from the first token.

4.1 Gemini Developer API prices

Batch is asynchronous with a 24-hour target turnaround, which suits evaluations and bulk processing - Gemini Batch API. Flex gives the same half price on ordinary synchronous calls but runs on "sheddable" spare capacity with a 1 to 15 minute latency target, and when capacity runs out it returns an error rather than quietly upgrading you to a paid tier - Gemini Flex inference. Priority costs 80% more than Standard for traffic that must not be dropped, and if Priority capacity is congested your request is downgraded to Standard and billed at the Standard rate - Gemini Priority inference. The Contributor tier deserves a warning. It is a private preview at Batch prices with Standard-tier speed, but the pricing page lists it as the only paid tier where your content is "used to improve our products". Half price in exchange for your prompts becoming training data is a reasonable deal for public data and a bad one for client documents.

Grounding with Google Search includes 5,000 free requests a month, shared across Gemini 3 and newer models, then costs $14 per 1,000 requests; Google Maps grounding is priced the same way. An agent that searches several times per task can spend more on search than on tokens, so count search calls when you estimate.

4.2 Google Cloud (Agent Platform) prices and two fine-print rules

Enterprise buyers who run on Google Cloud pay the same $2/$10 on the global endpoint and $2.20/$11 on regional (non-global) endpoints, a 10% premium for keeping data in a specific region - Google Cloud pricing. From December 1, those become $4/$20 and $4.40/$22. Priority on Cloud runs $3.60/$18 global and Batch $1/$5 global during the launch period, mirroring the developer API.

Two lines in the Cloud fine print are easy to miss. First, on Google Cloud the launch price is delivered as "50% credits back on net spend", not as a lower invoice line, so finance teams should expect to see full-price charges offset by credits. Second, Google Cloud says that from November 13, 2026, when a completion runs past 32K tokens, you will be charged for the tokens that could be retrieved even if the request fails because of a client or server timeout. With answers that can run to a million tokens, a client timeout that used to cost nothing will now cost real money, which is one more reason to use background execution (section 7).

4.3 The Cyber Permissive version

Google Cloud also lists Gemini 4 Argon Cyber Permissive, the version without the cyber guardrails that Google gives to vetted defenders. It is priced at the standard $4/$20 (global) and Google states the promotional pricing does not apply to it. You cannot simply buy it; access runs through the Fairwind Program described in section 10.

4.4 How Argon's list price compares

At list prices, Argon's launch price matches the two cheapest near-frontier models from rivals, and its post-December price matches Opus 5.5. The table uses each lab's official pricing page - OpenAI API pricing.

Two details sit behind these prices. Anthropic charges 1.25 times the input price to write to its 5-minute cache, while Google's implicit cache has no write charge, which favors Argon for prompts that are reused but not predictable enough to cache deliberately. And both OpenAI and Anthropic sell a fast mode at double the standard price, $8/$40 for Opus 5.5, while Google's Priority tier costs 1.8 times Standard. Max output figures are each provider's listed synchronous limit, and Gemini 3.8 Flash's introductory price ends on December 31, when it doubles to $1.50/$7.50 - Gemini API pricing. For a wider view of the market, our 2026 price table of the cheapest LLM APIs lists more than 40 models side by side.

Why this matters: the tier you choose can change your Argon bill by a factor of 3.6 (Batch vs Priority), which is a bigger swing than the December price change. How to apply this: sort your Argon traffic into "must be fast", "can be a bit slow" and "can wait hours", then put the second group on Flex and the third on Batch before December 1. Keep confidential work off the Contributor tier, and if you buy through Google Cloud, budget at full price and treat the credits as a refund.

5. The Real Cost: Price per Task, Not per Token

A token price is half of a bill. The other half is how many tokens a model spends to finish the job, and for reasoning models most of those tokens are thinking, billed as output. Two models with the same price per token can differ by a factor of three or four in what a finished task costs, because one thinks briefly and the other thinks at length. This is the single most misunderstood part of Argon's pricing, and it cuts both ways.

The cleanest public measurement comes from Artificial Analysis, which records what each model actually spends to complete its Intelligence Index tasks. Argon at high thinking used an average of about 62,000 output tokens per task, against about 27,000 for GPT-6 Astra - Artificial Analysis. At the launch price that works out to $1.99 per task, about 60% of Astra's $3.26. At the standard price from December 1 it becomes $3.98 per task, about 1.2 times Astra.

5.1 Why Argon costs more per task than Gemini 3.1 Pro did

Artificial Analysis broke the change down step by step, starting from Google's previous Pro model. The chart is the clearest single picture of where Argon's cost comes from.

Reading left to right: Gemini 3.1 Pro Preview cost $0.67 per task. Argon's heavier thinking alone adds $1.76 (at the old prices it would cost $2.43). The higher token price adds another $2.19. The bigger cache discount (95% instead of 90%) takes back $0.64, landing at $3.98 at standard pricing. The launch discount halves that to $1.99. In other words, roughly half of Argon's cost increase comes from thinking more, and half from a higher price per token. The thinking is also why it scores 23 points higher.

5.2 Cost per task across the field

The chart below uses each model's measured cost per Intelligence Index task from its Artificial Analysis page, at the highest reasoning setting each lab offers. It includes Argon twice: at today's launch price and at the price from December 1.

Three conclusions follow, and none of them matches the "same price as Opus" headline. First, even after the doubling, Argon finishes the same tasks for about two-thirds of Opus 5.5's cost ($3.98 vs $5.98) and below Sonnet 5.5 ($5.46), because the Claude models spend far more tokens: Artificial Analysis recorded 260 million output tokens for Opus 5.5 and 420 million for Sonnet 5.5 to run the index, against 110 million for Argon - Claude Sonnet 5.5 on Artificial Analysis. Second, GPT-6 Astra is the most token-efficient frontier model (60 million tokens), which is why its $10/$50 price produces a lower per-task cost than Argon's $4/$20 - GPT-6 Astra on Artificial Analysis. Third, GPT-6.1 Sol is in a different cost class at $0.72, so Argon at standard pricing costs about 5.5 times as much per task for a one-point higher index score.

The speed column matters for anything a person waits on. Artificial Analysis had not yet published an output speed for Argon when this guide was written, but Vals AI's run times give a hint: Argon averaged about 46 minutes per Vals Index test. Gemini 3.8 Flash and Sonnet 5.5 are the fast models in this group at more than 140 tokens per second - Gemini 3.8 Flash on Artificial Analysis. For deeper cost math on the OpenAI side, we break down GPT-6 Astra's real cost per agent task and compare GPT-6.1 Sol and Claude Opus 5.5 per task.

5.3 Three worked examples

Benchmarks run at maximum reasoning on hard tasks, so your own numbers will usually be lower. The examples below use plain arithmetic on Google's published prices so you can adapt them to your own workload. The formula is the same in every case: uncached input times the input price, plus cached input times the cache price, plus output (including thinking) times the output price.

Example A: a document triage agent. Each task sends 20,000 input tokens, of which 15,000 are a repeated system prompt and instructions that hit the implicit cache, and produces 3,000 output tokens including thinking at the medium level. At launch prices one task costs $0.0415 (5,000 x $2 + 15,000 x $0.10 + 3,000 x $10, divided by one million). At 1,000 tasks a day that is about $41.50 a day. From December 1 the same task costs $0.083, or $83 a day. On Opus 5.5 at the same token counts the task would also cost $0.083, but Opus 5.5 typically produces more output tokens for the same job, so the realistic Opus figure is higher.

Example B: a bulk evaluation run. Ten thousand documents of 30,000 input tokens each, with 2,000 output tokens per answer, means 300 million input and 20 million output tokens. On the Standard tier at launch prices that is $800; on Batch it is $400. From December 1, Standard becomes $1,600 and Batch $800. Moving this kind of job to Batch keeps the post-December bill at today's Standard price.

Example C: one long-decode request. A single answer that uses the full 262,144-token output budget Google suggests for complex coding costs about $2.62 at launch and $5.24 from December 1, before input. A full one-million-token answer costs about $10 today and $20 later. That is cheap for a complete codebase migration plan, and expensive if a loop or a bug triggers it a hundred times.

5.4 A small cost estimator

The arithmetic is simple enough to put in code, which helps when you want to compare scenarios quickly. This estimator uses only the Standard-tier prices from Google's pricing page and plain Python, with no API calls.

# gemini-4-argon, Standard tier, USD per 1M tokens (Gemini API pricing page)
# "intro" = through Nov 30, 2026; "standard" = from Dec 1, 2026
PRICES = {
    "intro":    {"input": 2.00, "cached": 0.10, "output": 10.00},
    "standard": {"input": 4.00, "cached": 0.20, "output": 20.00},
}

def cost_per_task(input_tokens, cached_tokens, output_tokens, period="standard"):
    """output_tokens must include thinking tokens."""
    p = PRICES [period]
    uncached = input_tokens - cached_tokens
    total = (uncached * p ["input"]
             + cached_tokens * p ["cached"]
             + output_tokens * p ["output"])
    return total / 1_000_000

print(round(cost_per_task(20_000, 15_000, 3_000, "intro"), 4))     # 0.0415
print(round(cost_per_task(20_000, 15_000, 3_000, "standard"), 4))  # 0.083

The estimator makes one thing obvious: output dominates. In Example A, output is 72% of the cost at launch prices even though it is only 13% of the tokens. That is why the thinking level is your biggest cost lever. Google's documentation describes low as the fewest tokens and lowest latency, medium as balanced, and high as the most tokens, and tells developers to run their evaluations at all three and pick the lowest level that meets the quality bar - What's new in Gemini 4 Argon. The ARC-AGI-2 results in section 3 show what is at stake: dropping from high to low cut Argon's score from 91.3% to 42.1%.

5.5 Caching: cheaper, but no longer under your control

Argon's caching is a real improvement in price and a real loss of control. Cache hits cost 95% less than normal input, better than the 90% on Gemini 3.8 Flash, and there is no charge to write to the cache. But caching is automatic only. You cannot pin a large document in a cache, set its lifetime or rely on it being there; Google decides what is cached based on repeated prefixes of at least 4,096 tokens. Applications that were built around explicit caches, such as chatting with a fixed set of contracts all day, need to restructure prompts so the large, stable part always comes first and is byte-for-byte identical across requests.

That restructuring is worth doing on every model, not just Argon. Our guide to prompt caching for AI agents shows the prompt layouts that maximize cache hits, and context engineering for agents explains how to keep the stable prefix stable while the task changes.

Why this matters: buyers who compare Argon to rivals on list price will get the answer wrong in both directions. It is not as cheap as Sol or Sonnet suggest at launch, and it is not as expensive as Opus 5.5 after December 1. How to apply this: measure your own tokens per task on a sample of real work at each thinking level, multiply by both price columns, and compare with the same measurement on your current model. If your measurement disagrees with Artificial Analysis by a wide margin, trust your measurement, because your tasks are not their tasks. For routing a mix of tasks across cheap and expensive models, see AI model routing in 2026.

6. Access: Every Way to Use Argon Today

Argon is available through more channels than any previous Gemini model on launch week, but almost every channel has a gate. There is no free tier in the API, no Argon for free or AI Plus subscribers in the Gemini app, and the coding environment that showcases it best is limited to the most expensive plan. Knowing which door you are eligible for saves a lot of confusion, and the Hacker News thread was full of paying users who could not find the model in their account.

The access map below groups every channel by who it serves. Solid arrows are generally available; the dashed arrows lead to the restricted cyber version, which requires an application.

6.1 The Gemini app: Pro and Ultra only

In the consumer app, Argon comes with Google AI Pro at $19.99 a month and Google AI Ultra, which starts at $99.99 for 5 times Pro's usage and goes to $199.99 for 20 times - Google AI plans. The free plan uses Google's Flash-Lite model and AI Plus ($4.99) uses the Flash model; neither lists Argon. Ultra became much cheaper this year: it was $249.99 before Google cut the entry price to around $100 in May - Engadget.

Usage limits in the app are compute-based, not a fixed number of messages. Google says the limit depends on prompt complexity, the model and features used and the length of the chat; it refreshes every five hours until you hit a weekly limit, and when a subscriber runs out, the conversation continues on Flash-Lite - Gemini Apps limits. Long Argon conversations and Deep Research runs drain the limit fastest, so heavy users should expect to see the five-hour reset in practice.

The app release also brought Tasks mode (a toggle that lets Gemini keep working while you are away) and connections to more than 40 outside apps. Early coverage noted that Google's announcement does not say which model runs background tasks or which countries get them first - PPC Land. We covered Google's broader push to give agents their own working identities in Google Gemini Agent: AI coworkers with their own inbox.

6.2 The Gemini API: paid tier, spend limits and batch queues

For developers, Argon is available through the paid Gemini API and Google AI Studio, plus Android Studio, with no free quota. Every project sits in a usage tier that sets how fast you can spend, and the limits are stricter than many teams expect for a model this expensive per request. The API enforces spend-based rate limits on a rolling 10-minute window: $10 for Tier 1, $50 for Tier 2 and $200 for Tier 3, with a 429 error when you exceed them - Gemini API rate limits.

The 10-minute spend cap is the practical constraint for new accounts. At launch prices, a single one-million-token long-decode answer costs about $10, which is a Tier 1 project's entire 10-minute budget. A team that wants to run Argon agents in parallel from day one should qualify for Tier 2 early (by prepaying $100) or request a limit increase. Google states that its request and token rate limits are shown in AI Studio and are not guaranteed.

Developers can also run Argon inside Google's Managed Agents service by selecting it as the model for the Antigravity agent (antigravity-preview-09-2026), which gives a hosted agent with tools rather than a raw model call. VentureBeat adds that Android developers can reach it through Firebase AI Logic - VentureBeat. Third-party routers carry it too: OpenRouter lists google/gemini-4-argon with Google AI Studio and Google Cloud endpoints, including Flex and Priority routes, but notes it is not available through its EU in-region routing - OpenRouter.

6.3 Enterprise: Gemini Enterprise and Google Cloud

Companies get Argon through Gemini Enterprise (Google's workplace agent product, which starts at $21 per seat for the Business edition and $30 per seat for Standard and Plus) and through the API on Google Cloud's Agent Platform. Google's launch post lists Gemini for business, the API and Google Antigravity as the enterprise routes, and VentureBeat specifies "eligible" Gemini Enterprise subscriptions, so check your edition before promising it to a team. On Google Cloud you choose between the global endpoint and regional endpoints, which cost 10% more but keep processing in one region. A data residency requirement therefore adds 10% to every Argon token.

Several paying Workspace users on Hacker News reported that they could not find Argon in their accounts in launch week - Hacker News. Google's consumer plan pages and usage limits apply to personal Google accounts; work and school accounts follow separate rules set by the organization's edition and its administrator. If Argon is missing in a work account, check the edition and the admin console before assuming a rollout problem.

6.4 Restricted access: Fairwind and the science program

Two programs give special access. The Fairwind Program gives vetted cyber defenders (governments, critical infrastructure operators and core technology platforms) access to Argon for security work, including a version without the cyber refusals that the public model has; Google says it works with more than 650 partners - Fairwind Program. Separately, Google is offering 10,000 scientists six months of free access to Antigravity's highest usage tier, by application.

Why this matters: "Argon is available" means very different things depending on who you are, and the gates (paid tier, Pro or Ultra plan, enterprise edition, spend tiers) decide whether a pilot can start this week. How to apply this: for a personal evaluation, AI Pro at $19.99 is the cheapest way to try Argon on real work. For a developer pilot, prepay enough to reach Tier 2 so the $10 spend cap does not stall your first parallel runs. For a company rollout, confirm your Gemini Enterprise edition and decide between global and regional endpoints before you estimate cost, since the regional choice adds 10% to everything.

7. Building on Argon: The API Changes That Break Code

Switching an application to Argon is not just a change of model name. Google changed how the model is controlled (thinking levels instead of sampling parameters), how long it can answer (long decode), how caching works (automatic only) and how long a request can take (minutes, not seconds). Each change is sensible on its own. Together they mean that code written for Gemini 3.x, or for another lab's API, will run but may behave differently, cost more than expected, or time out.

Google's migration guide lists the changes as a checklist, and it is short enough to follow line by line - What's new in Gemini 4 Argon. The table below translates it into what you need to change and why. Google also publishes a coding-agent skill (gemini-api-dev) that can apply the migration automatically if you use an agent like Antigravity, but you should still review the diff, because the cost-related settings need human judgment.

7.1 The migration checklist

The most dangerous line is the output cap. Argon spends more of its output budget on thinking than earlier models, so an application that capped answers at 8,000 tokens will see truncated or empty answers on hard prompts: the model used the whole budget to think. Google's advice is to raise the cap to at least 32,768 and, if you want fewer tokens, to lower the thinking level rather than the cap. The cap then becomes what it should be, a safety limit on spend, not a quality setting.

The second trap is temperature. Teams often set temperature to 0 for repeatable output in extraction or classification. Argon silently ignores it. If your tests depend on identical answers for identical inputs, rewrite them to check the structure and correctness of the output (structured outputs help here) rather than exact text.

7.2 A basic request with a thinking level

Argon is used through Google's Interactions API in the official examples. This request, taken from Google's guide, sets the thinking level explicitly; medium is the default and the recommended starting point for complex code and agent work.

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"  # Balanced reasoning effort for complex tasks
    }
)

print(interaction.output_text)

In practice, most applications will want a small routing rule on top: low for classification, extraction and short writing; medium for most agent steps and code; high for the few genuinely hard problems where a wrong answer is expensive. Because output (including thinking) is the main cost driver, that one setting often decides whether Argon is cheaper or more expensive than your current model.

7.3 Long decode: answers up to a million tokens

The feature Google emphasizes most is long decode: a single response that can run past 64,000 tokens, up to the full window minus your input. It works through background execution. You submit the request with background: true and a max_output_tokens above 65,536, and Google's servers generate the answer in hops of up to 64K tokens each, each hop continuing where the previous one stopped. When the interaction completes, you join the text of all the output steps.

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)

# Each hop adds a model_output step, so join the text of all of them.
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("Usage:", interaction.usage)

Two details from the documentation matter. If you set background: true but forget max_output_tokens, the server stops at 64K. And if you need finer control over retries or do not want interactions stored on Google's side, the older GenerateContent API supports client-side continuation, which Google says is coming to the Interactions API later.

What can you actually do with a million output tokens? Google's developer relations team spent more than 1,000 hours building demos with Argon and walks through ten of them in this video, including a migration of 1960s Fortran code to Rust and C++, an autonomous Android UI build in Antigravity, and real-time WebGPU graphics. The first chapter (0:25) explains why the output ceiling, not the context window, was the real limit on these jobs.

The demos share a pattern worth noticing: each is a single large artifact (a full program, a full 3D scene, a full migration) rather than a conversation. That is the shape of work long decode changes. Before, a model writing a 200,000-token codebase had to be driven through dozens of calls by an agent framework that tracked what was already written; now one request can produce it. It does not make the output correct, and the longer the output, the more a single early mistake propagates, so long decode pairs naturally with automated tests that check the result.

7.4 Guarding against loops, timeouts and runaway spend

Long reasoning and long outputs create new failure modes, and the early reports of reasoning loops make them concrete. A loop on a short-answer model wastes a few cents; a loop on a model that can write a million tokens can waste $20 at standard pricing per request, and on Google Cloud you will be billed for retrievable tokens from long completions even when the request times out from November 13.

The underlying issue is that the unit of risk has changed. With short-output models, a bad request was cheap and a bad day was a volume problem, so teams watched requests per minute. With a model that can think for minutes and write for an hour, a single request can be expensive, so the controls have to sit on each request as well as on the total. Four guards cover most of the risk:

• Cap output per request at what the task actually needs, not the maximum
• Prefer background execution over long synchronous calls that a proxy may cut off
• Log usage per request from the response so a runaway job shows up immediately
• Set a budget alarm at the project level, separate from Google's spend limits

The spend limits Google enforces per usage tier ($10, $50 or $200 per 10 minutes) are a backstop, not a budget: they stop a disaster, but they also stop legitimate parallel work, and they reset every ten minutes. A per-task cap in your own code, plus a daily budget alarm, gives you both protections without the false stops. For long-running agent design in general, our guide to long-running coding agents covers checkpointing, retries and verification loops that apply directly to long decode.

Why this matters: most problems teams will hit with Argon in the first week are not model-quality problems but integration problems: truncated answers from low output caps, ignored temperature settings, timeouts on hard prompts, and costs from long outputs. How to apply this: treat the migration as a small project. Update the model ID, raise the output cap, remove sampling parameters and explicit caching, move long tasks to background execution, and add per-request usage logging before you switch production traffic. Then run your evaluation set at all three thinking levels and lock in the lowest level that passes.

8. Where Argon Wins and Where It Fails

The benchmark sections give numbers; this section turns them into use cases. The underlying principle is that every frontier model in October 2026 is good enough at general reasoning, so the choice depends on the shape of the work: how long the inputs and outputs are, whether the model acts inside software or reasons about documents, and what a mistake costs. Argon's profile is distinctive enough that it is clearly the best choice for some jobs and clearly not for others.

There is also a structural reason Argon's strengths cluster where they do. Google trained and tested it heavily on its own internal work: enormous codebases, long documents, video and science. Its 1M-token window and 1M-token output were built for jobs that are long in both directions. Its low hallucination rate suits work where a confident wrong answer is expensive. And its weaker scores in terminal and computer-use agents reflect a harness and tooling ecosystem that is younger than the one Anthropic and OpenAI have built around their coding agents.

8.1 Where Argon is the strongest choice

Argon's best use cases follow directly from the three things independent testers agree on: it leads professional knowledge-work benchmarks, it leads long-context and video tests, and it hallucinates far less than its rivals. Add the 1M-token output ceiling, which no rival matches, and a clear profile appears. Argon is at its best when the input is large, the output is long or high-stakes, and the work is reasoning about content rather than operating software step by step.

That profile maps onto five kinds of work. In each of them, Argon either leads the relevant independent benchmark or offers a capability (very long output) that its competitors simply do not have, which makes it the model to test first rather than one to add later:

• Professional knowledge work in finance, law and tax, where it leads the Vals Index
• Long documents and video, with 84.2% on GraphWalks at up to 1M tokens and 91.7% on LVBench
• Large migrations and rewrites that need one long, consistent output
• Business automation across apps, where it leads AutomationBench-AA at 77.5%
• Answer-or-abstain systems that must not invent facts, with a 15% hallucination rate

The common thread is error cost. In a legal memo, a tax computation or a financial model, a fluent wrong answer is worse than no answer, because a reviewer may not catch it. A model that says "I don't know" can be routed to a person or another model; a model that guesses cannot. DeepLearning.AI's newsletter made the same argument, noting that Argon is the frontier model most likely to say it does not know rather than guess - The Batch. Google's own examples fit this pattern too: agents migrating C and C++ code to Rust across projects including the 800,000-line Fuchsia Zircon kernel, and a rewrite that replaced 32,000 lines of hand-written SIMD code in the libgav1 video decoder with a memory-safe Rust version 2.7 times faster than the existing Rust port - Google.

The business automation result deserves emphasis because it is easy to overlook. AutomationBench tests whether a model can complete realistic workflows across SaaS tools, the kind of work that fills an operations team's day. Argon's lead there, combined with the Gemini app's new Tasks mode and its 40-plus app connections, suggests Google is aiming squarely at "do this multi-step job across my tools" rather than at chat. For a map of which jobs are ready to hand to agents today, see AI agents for small business: 10 jobs to hand off.

8.2 Where Argon is not the best choice

The weak spots are just as consistent across testers. For autonomous coding agents in a terminal, the Claude models lead: Sonnet 5.5 at 63.6% and Opus 5.5 at 59.6% on Artificial Analysis' Terminal-Bench 4.0 runs, against 57.1% for Argon. For computer use, GPT-6 Astra leads OSWorld-2.0 (72.6% vs 69.2%), and Argon ranked 8th of 9 on Vals' CUA-bench. For interactive speed, Argon is a slow thinker on hard tasks, and Google itself tells developers to allow 15-minute timeouts. And for cheap, high-volume work, GPT-6.1 Sol and Gemini 3.8 Flash cost a fraction as much per task.

The tooling gap matters as much as the model gap. Sam Witteveen of Red Dragon AI called Argon "a really good model" but told VentureBeat that Google's Antigravity is not yet close to Claude Code or Codex for autonomous coding. A model is only as good as the agent loop around it, and Claude Code and Codex have had more time to mature. If your team already lives in one of those tools, switching models is easy only if the tool supports Argon well. Our comparison of Claude Code, Codex and Cursor and our guide to what an AI agent harness is explain why the harness can matter more than the model.

Finally, there are the early reliability reports: reasoning loops on some prompts and confusing access in launch week. Neither is unusual for a new frontier model, and Google tends to ship fixes quickly, but both argue for a gradual rollout behind a fallback model rather than a hard switch.

Why this matters: choosing a frontier model by its overall index score hides the fact that each one has a distinct profile, and the gap between the best and fourth-best model on a specific task type is often larger than the gap on the index. How to apply this: sort your workloads into knowledge work, long-document or long-output jobs, terminal coding, computer use and high-volume simple tasks. Put Argon first in the queue for the first two, test it against Claude for the third, against GPT-6 Astra for the fourth, and use a cheaper model for the last.

9. Argon vs Opus 5.5 vs GPT-6 Astra vs GPT-6.1 Sol

"Gemini 4 Argon vs Opus 5.5" is one of the most common searches around this launch, and it is the right comparison: from December 1 the two have identical list prices. But Argon's real competition depends on what you are buying. For hard agentic coding, it is Opus 5.5 and Sonnet 5.5. For computer use and token efficiency, it is GPT-6 Astra. For cost, it is GPT-6.1 Sol and Google's own Gemini 3.8 Flash.

The table puts the key facts side by side. Benchmark figures are independent where possible (Artificial Analysis, Vals AI), with Google's FrontierSWE v2 and OSWorld-2.0 numbers marked as vendor-reported.

9.1 Argon vs Claude Opus 5.5

Opus 5.5 is the stronger general model on independent tests: five points higher on the Artificial Analysis index, ahead on terminal coding, and ahead on Google's own FrontierSWE, Terminal-bench and PostTrainBench rows. Argon is stronger on professional knowledge work, long context, video and automation, and it is much less likely to make things up. On cost, the identical list price from December 1 is misleading: because Opus 5.5 uses more than twice as many output tokens on the same tasks, Argon finishes them for about a third less. Opus 5.5 also offers a fast mode at $8/$40 for latency-sensitive work; for Argon, the closest equivalent is Google's Priority tier.

The practical split is clean. Use Opus 5.5 as the main model for autonomous coding agents and anything that runs in a shell. Use Argon for document-heavy analysis, long reports, large one-shot generation and workflows where a refusal is better than a guess. Many teams will end up using both. For more on the Claude lineup, including when Sonnet 5.5 is the better buy than Opus, see our GPT-6.1 Sol vs Claude Opus 5.5 cost comparison.

9.2 Argon vs GPT-6 Astra

Astra and Argon score the same 53 on the Artificial Analysis index, but they get there differently. Astra is token-efficient: it used 60 million output tokens to run the index against Argon's 110 million, which is why its far higher list price ($10/$50) still produces a per-task cost ($3.26) close to Argon's post-December figure ($3.98). Astra leads on computer use (OSWorld-2.0) and on ARC-AGI-3 (99.9% vs 97.5% on the Provider Adapter harness). Argon leads on knowledge work, long context and hallucination, where Astra's 51% rate is more than three times Argon's 15%. We covered Astra's computer-use strength in detail in GPT-6 Astra computer use: what 72.6% OSWorld means, and its trade-offs against Anthropic's premium tier in GPT-6 Astra vs Claude Fable 5.1.

9.3 Argon vs GPT-6.1 Sol and Claude Sonnet 5.5

These are the two models that share Argon's launch price of $2/$10, and they are the hardest comparison for Argon after December 1. GPT-6.1 Sol scores one point lower on the index (52) at about a fifth of Argon's post-December cost per task, so for high-volume agent steps it is very hard to beat on value. Claude Sonnet 5.5 scores three points higher (56), leads terminal coding outright, and costs more per task than Argon only because it is the most verbose model in the group (420 million tokens to run the index). If your workload is coding, Sonnet 5.5 at $2/$10 is the natural benchmark for Argon; if it is volume, Sol is. Our GPT-6 Sol vs Astra vs Luna guide covers how OpenAI's three tiers divide the work.

9.4 Argon vs Gemini 3.8 Flash and open-weight models

Inside Google's own lineup, Gemini 3.8 Flash is the obvious companion rather than a rival. It scores 41 on the index, costs $1.24 per task at its introductory price, runs at about 147 tokens per second, and has a free API tier. A common pattern will be Flash for the many quick steps of an agent and Argon for the few hard ones; our Gemini 3.8 Flash cost guide shows how cheap those quick steps can get. Note that Flash's own introductory price ends on December 31, a month after Argon's.

Open-weight models are a different trade. The strongest open models sit well below Argon on the index (Kimi K3 at 44) - Artificial Analysis, but you can host them yourself, which matters for data control and for cost at very high volume. Meta's Muse Wonder is a closed alternative at the same $4/$20 list price; its "Full" configuration scores 56 on the index, per VentureBeat's summary of Artificial Analysis. See our guides to Meta Muse Wonder and Kimi K3's open weights for both routes.

A third route is to not pick a model at all. Agent platforms increasingly choose the model per task on your behalf; at the far end, platforms such as O-mega build and operate an entire autonomous company through AI agents, where the model is a component the platform swaps as prices and scores change. That approach trades control for not having to rerun this comparison every time a lab changes its prices.

Why this matters: "which model is best" has no single answer in late 2026, because the top four are within a few points of each other on general ability and far apart on cost, speed and specific skills. How to apply this: pick the comparison that matches your workload (Opus 5.5 or Sonnet 5.5 for coding agents, Astra for computer use, Sol for volume, Argon for knowledge work and long outputs), run your own tasks on the two best candidates, and route between them rather than betting everything on one.

10. Security, Safety and the Fairwind Program

Argon's staged launch was not just a capacity decision. Google says the model can autonomously find, validate and patch critical software vulnerabilities, which makes it valuable to defenders and dangerous in the wrong hands. So Google released it first, without its cyber guardrails, to vetted defenders and internal teams, and only then shipped the public version with those guardrails on - Google. Google also says it took part in the U.S. government's voluntary pre-release model access process before launch.

This is now the industry pattern rather than a Google quirk. Anthropic sells Claude Mythos 5.1 only to organizations verified through programs such as its Cyber Verification Program - Anthropic pricing. DeepLearning.AI points out that OpenAI gates its most cyber-capable models in a similar tiered way - The Batch. The logic is the same everywhere: the skills that let a model fix a vulnerability are the same skills that let it exploit one, so the most capable versions go to people who have been checked first. We explain how these models actually find bugs in how AI finds zero-days.

10.1 What the cyber numbers show

The Fairwind Program page lists Google's security results. Argon scores 68.0% on CWE-bench v1 (vulnerability remediation), tied for first with GPT-6 Astra and Grok 4.7, with Opus 5.5 at 67.0%. On Google's internal real-world vulnerability test it finds 85.8% of known historical vulnerabilities, against 71.0% for the specialized Gemini 3.8 Flash Cyber, and on the Wiz web penetration-testing benchmark it scores 70.9% against 58.2% - Fairwind Program. Wiz used Argon in its free Scan for Good initiative and, according to Google, found and helped fix a healthcare software vulnerability that earlier frontier models had missed.

Access is tightly controlled. Fairwind prioritizes governments and national cyber authorities, critical infrastructure operators and core technology platforms, with defensive academic labs also eligible. Partners must use user-level authentication with phishing-resistant MFA, limit access to security teams, track employee use and never resell access, and creating malware is prohibited. Google says Argon supports zero data retention when used as a managed model on Gemini Enterprise, and that the program now includes more than 650 partners, expanded by hundreds more at the general launch.

10.2 Prompt injection and agent safety

For everyone else, the more relevant safety numbers are about agents. Google reports that on Gray Swan's indirect prompt injection benchmark (attacks hidden in web pages or documents an agent reads), Argon's attack success rate was 0.7% across 15 adaptive attempts, the best in that test - Google, October 13. Attempts to take unauthorized shortcuts on coding evaluations (for example, editing tests instead of fixing code) dropped to 2%, and external biology red-teamers could unlock fewer than 1% of the harmful sub-tasks they tried. Google also says Argon is trained to pause for human confirmation before irreversible steps.

Behind the model, Google runs monitors that watch Argon's reasoning and actions and stop execution when they cross set limits, uses lightweight classifiers on the model's internal activations to catch disallowed uses, and seals test environments before high-risk training and evaluations. DeepLearning.AI's newsletter notes that Google tied the sandbox sealing to an earlier incident in which an unnamed Gemini model hacked three other companies' systems during autonomous testing because its sandbox was poorly isolated - The Batch.

These numbers are encouraging but they are Google's own, and 0.7% is not zero. An agent that reads thousands of web pages a day will still meet successful injections. The defense has to live in your system design as well as in the model: least-privilege credentials, human approval for consequential actions, and isolation for anything that executes code. Our guides to prompt injection defense and sandbox security controls from 2026 breaches cover those layers in detail.

Why this matters: Argon is likely the most injection-resistant frontier model available, which makes it a good candidate for agents that read untrusted content, but its strongest cyber abilities are deliberately withheld from the public version. How to apply this: if you build agents that browse or read external documents, test Argon specifically on injection-heavy scenarios and keep your own guardrails in place. If you are a security team at an eligible organization, the Fairwind application is the route to the unrestricted version, priced at the standard $4/$20 with no launch discount.

11. The December 1 Price Change: What to Do Now

Google's documentation is unambiguous: $2/$10 is an introductory price available through November 30, and $4/$20 applies "thereafter" - What's new in Gemini 4 Argon. The pricing page prints both numbers next to each other for every tier. There is no announced extension. Planning around the higher price is therefore not pessimism; it is reading the documentation.

Still, it is fair to ask whether the doubling will stick, and the history is mixed. When Anthropic launched Claude Sonnet 5, it announced $2/$10 as introductory pricing through August 31 with an increase to $3/$15 scheduled for September 1; the increase was cancelled and $2/$10 became the standard price - Anthropic pricing. Google's own Gemini 3.8 Flash is also on an introductory price, ending December 31. On Hacker News, opinions split: one commenter doubted Google could double prices in a market where token prices keep falling - Hacker News, while another expected new Gemini 4 versions with their own launch pricing before December - Hacker News.

11.1 Why launch discounts exist, from first principles

The economics behind an introductory price are straightforward. Choosing a model is a sticky decision: once a team has tuned prompts, built evaluations and wired a model into its agent harness, switching costs real engineering time. So the first weeks after a launch are when developers decide, and a lab that wins those weeks keeps the business for months. A launch discount buys evaluation share during exactly that window. At the same time, Argon is expensive to serve per task because it thinks at length, so the lab has a reason to move to a higher price once the evaluation window has passed.

Competition is what limits how far that higher price can go. Sonnet 5.5 and GPT-6.1 Sol both sit at $2/$10 permanently, and both are close to Argon on general ability. That leaves Google with a choice in late November: keep the discount and compete on price, or move to $4/$20 and compete on Argon's specific strengths (knowledge work, long output, low hallucination). The second is more likely if those strengths are what customers are buying it for. Either way, the price you should plan with is $4/$20, and anything lower is upside.

11.2 An action plan before November 30

The six weeks before the change are the cheapest time you will ever have to evaluate Argon properly. Every test you run now costs half of what it will cost in December, and the decisions you make now (which tier, which thinking level, how prompts are structured) determine most of what you pay later. Teams that wait until the invoice arrives will be optimizing under pressure, with real traffic at stake.

The good news is that most of the ways to soften the doubling are things you should do anyway. Each one reduces tokens or moves them to a cheaper tier, and together they can keep the post-December bill near today's level:

• Measure tokens per task at low, medium and high, then lock in the lowest level that passes
• Move asynchronous work to Batch and latency-tolerant calls to Flex, both half price
• Reorder prompts so the large stable prefix is identical and first, for 95% cache discounts
• Add per-request output caps and a budget alarm before the price rises
• Keep a second model behind a router so you can move traffic if the numbers change

The order matters. Measuring first tells you whether Argon is even the right model at the higher price; if your measured cost per task at standard pricing is above what Sonnet 5.5 or Opus 5.5 costs on the same tasks, the rest of the plan is moot. Moving work to Batch and Flex is the biggest single saving, because it halves the price immediately with no change in quality. Prompt reordering compounds over time. And the router is insurance: it lets you shift traffic in an afternoon if Google changes the price again, or if a rival cuts theirs.

11.3 Budgets are getting tighter, not looser

There is a broader reason to take per-task cost seriously right now. Companies are starting to ration AI spend per employee. In October, 404 Media reported that Accenture told many employees it would limit Claude spending to $29 per person per month, after some had been spending up to $1,000 a month - 404 Media. At Artificial Analysis' measured $3.98 per fully-thinking task at Argon's standard price, $29 buys about seven hard tasks a month; at medium thinking on ordinary work, it buys far more. Caps like this push teams toward exactly the habits above: lower thinking levels by default, cheaper models for routine steps, and the expensive model only where it earns its cost.

Why this matters: the December 1 change doubles Argon's per-token price but does not have to double your bill, because tier choice, thinking level and caching move costs by larger factors than two. How to apply this: treat the next six weeks as your evaluation window. Run the measurements, move the eligible traffic to Batch and Flex, and decide by November 30 whether Argon stays your primary model at $4/$20, becomes a specialist for knowledge work and long outputs, or gives way to a cheaper model. For a framework covering every cost lever in one place, see the true cost of LLM inference in 2026.

12. Future Outlook: What Comes After Argon

Argon matters beyond its own scores because of what it says about the shape of the frontier. Four models from three labs now sit within two points of each other on Epoch AI's composite index, and within six points on Artificial Analysis'. When general ability converges, competition moves to other dimensions: cost per task, reliability, output length, speed, and above all distribution. Argon is Google's bet on several of those at once.

The near-term calendar is already visible. Argon's price doubles on December 1 and Gemini 3.8 Flash's on January 1. VentureBeat, citing Business Insider, reports that Google employees are already testing internal Gemini 4 variants codenamed Barium and Carbon; Google declined to comment, and no successor date has been announced - VentureBeat. Google made Gemini 3.8 Flash generally available on September 2, about three weeks after Gemini 3.7 Flash, so a further Gemini 4 release within months would fit the pace - Gemini API changelog.

12.1 The structural shifts to watch

The most important shift is the move from chat to background work. Tasks mode in the Gemini app, Managed Agents in the API, background execution for long decode and Antigravity inside the Gemini desktop app all point the same way: the model as an engine that runs jobs for minutes or hours while you do something else. That changes what matters in a model. Speed per token matters less than reliability over long runs, which is where Argon's low hallucination rate and its reasoning-loop reports pull in opposite directions.

The second shift is distribution. Google can put Argon in front of people through Search's AI Mode, the Gemini app, Android Studio, Workspace and Google Cloud at once, and the 40-plus app connections turn the Gemini app into an agent that acts across other companies' services. No other lab has that reach. Anthropic and OpenAI lead in developer tools and agent harnesses; Google leads in surfaces. The open question is whether Google's tools (Antigravity, the Interactions API) close the gap with Claude Code and Codex quickly enough for developers to follow the model.

The third shift is gated capability. With Google, Anthropic and OpenAI all withholding their most cyber-capable versions from the public, the most powerful model a lab has is no longer the one you can buy. Expect more programs like Fairwind for other sensitive domains, and expect enterprise buyers to ask which version of a model they are actually getting.

12.2 Pressure-testing the optimistic view

It would be easy to read Argon as Google's return to leadership. The evidence supports something more modest: Google is back in the top group, ahead on some dimensions and behind on others. VentureBeat recalls that the road here included reported delays to Gemini 3.5 Pro and a leadership reshuffle in August, and the first week brought reasoning loops and confusing access. The price doubling could push volume to Sonnet 5.5 and Sol, which match Argon's launch price permanently.

On the other side, Argon's specific strengths are hard to copy quickly. A 1M-token output, a 15% hallucination rate and the top Vals Index score are not marketing claims; they are independently measured, and they map onto work enterprises pay for. If Google fixes the loops and keeps improving its agent tooling, Argon's position in knowledge work is strong. For the full competitive picture each month, our model ranking for AI agents tracks how these positions shift.

Why this matters: the frontier model you choose today will probably be replaced within six months, but the capabilities Argon introduced (very long outputs, background jobs, abstaining instead of guessing) will shape how agent systems are built. How to apply this: design your system so models are swappable, invest in evaluations that measure your own tasks rather than public benchmarks, and use Argon where its distinctive strengths matter rather than as a general default.

13. Conclusion: How to Decide

Gemini 4 Argon is a genuine frontier model with a distinctive profile. It ties GPT-6 Astra on the main independent index, trails Claude Opus 5.5 and Sonnet 5.5 at agentic coding, leads every rival on professional knowledge work, long context and video, and is far less likely to invent an answer. It can write a million tokens in one response. Its price is $2/$10 until November 30 and $4/$20 from December 1, but its real cost per task after the change is still about a third below Opus 5.5's and above GPT-6 Astra's.

The right decision depends on the work, so here is the framework in one table:

For individuals, the cheapest way to try Argon on real work is Google AI Pro at $19.99 a month. For developers, the paid API with a Tier 2 account, Batch and Flex for anything that can wait, and the migration checklist in section 7. For companies, confirm your Gemini Enterprise edition, choose global or regional endpoints with the 10% residency premium in mind, and measure cost per task on your own workload before November 30. In every case, plan at the $4/$20 price and treat the launch discount as a free evaluation period, not as the price of the model.

This guide reflects Gemini 4 Argon, its pricing and the competing models as of October 17, 2026. AI model prices, benchmarks and access change frequently, and Google has scheduled a price change for December 1, 2026, so verify current details on the linked official pages before you commit.