Gemini 4 Argon vs Claude Opus 5.5: half the price until Nov 30, but is it worth switching?

In Gemini 4 Argon vs Claude Opus 5.5, Argon wins on long context, video and automation, Opus 5.5 wins on the coding agent that lives in the terminal, and Argon costs half the price only until November 30. Google opened Argon to any developer on the paid API on October 13, with an official table where it beats Opus 5.5 on 14 of the 18 benchmarks where both have a score.

But there are two pieces of fine print in this story.

First: the half price lasts until November 30. On December 1, Argon costs exactly the same as Opus.

Second: the four benchmarks Argon loses are exactly the ones that look most like the work of a coding agent in a terminal.

In this post you'll see the numbers side by side (Google's and the independent ones), what an agentic session costs on all three models, with GPT-6.1 Sol as the yardstick, what breaks if you only swap the model id, and a Laravel fallback that lets you switch models by changing one line of .env.

TL;DR

• What it is: Gemini 4 Argon, Google's new flagship reasoning model. Model id gemini-4-argon, 1M tokens unified across input, thinking and output.
• Where it wins: knowledge work, long context, video, DeepSWE (77.9% vs 74.2% for Opus 5.5).
• Where it loses: Terminal-Bench 4.0 (57.4% vs 66.4%), FrontierSWE and PostTrainBench. On the Artificial Analysis Intelligence Index it scores 53 against Opus's 58.
• Cost/Access: US$ 2/10 per million tokens until 11/30, then US$ 4/20. Paid Gemini API tier only. No free tier.
• Useful link: official model guide.

Gemini 4 Argon vs Claude Opus 5.5: the numbers side by side

Google published the full table in the Argon model card. It compares against GPT-6 Astra, Claude Fable 5.1 and Claude Opus 5.5. I pulled out what matters if you write software:

Across the whole table, Argon wins 14 of the 18 rows that have a score for both. But look at which ones it loses: FrontierSWE, Terminal-Bench 4.0, PostTrainBench and Terminal-Bench Science. All four measure the model operating on its own inside an environment, running commands, reading errors and trying again.

That's not a detail. That's the loop of every coding agent.

Then there's the yardstick that isn't Google's. Artificial Analysis, which runs the same test on everyone, gave Argon 53 points on its Intelligence Index. Eighth out of 217. Tied with GPT-6 Astra and Fable 5.1, and behind Opus 5.5 at 58, according to VentureBeat. Vals AI, on the other hand, puts Argon first on the Vals Index, 68.90% against Opus's 66.97%.

Two independent evaluators, two different winners. The honest conclusion is that, in aggregate, they're at the same level. The difference is in the kind of task.

Sam Witteveen of Red Dragon AI, quoted by VentureBeat, summed it up well: "But is it the best model out there? I actually don't think it is". And on Google's coding environment: "I still don't think, for example, Antigravity is anywhere near as good as Claude Code or Codex".

This is where most developers get lost. They keep switching models with every announcement, steered by the lab's own table. Switching models is a configuration change. The engineering work is knowing how to measure which model solves your task, with your own eval, and that's what we practice every week, live, in the Beer and Code Clan.

Where does GPT-6.1 Sol fit?

GPT-6.1 Sol shipped on September 29, at DevDay, and it's here as the price yardstick. It costs US$ 2/10, the same as Argon's promo price, and scores 75.2% on DeepSWE v1.1, according to Vellum's breakdown of OpenAI's own numbers.

Google left Sol out of its table. So the direct comparison, using only the numbers that exist for all three, looks like this:

The prices match the OpenRouter catalog today.

The point few people are making: on December 1, Argon goes up to Opus's price. And Sol stays at US$ 2/10. So the real price fight, the one that lasts after the promo, is Sol against the other two.

What an agentic session costs on all three

Price per token doesn't pay the bill. Cost per task does.

Take a typical coding agent session: 2 million input tokens across the turns, 90% of them served from cache, and 100 thousand output tokens (thinking included, which is billed as output on all three).

The math is mine, at list prices. For Opus I left out the cache write cost (US$ 5 per million), which makes it a bit more expensive.

But the table assumes all three spend the same number of tokens. They don't. On Artificial Analysis, Argon used 110 million output tokens to run the whole index, against a median of 87 million among comparable models. It's a verbose model. If it thinks 25% more to reach the same answer, the price advantage shrinks by the same amount.

The opposite happens too. The viral test that had both generate a 3D animation of an electric motor, reported by Crypto Briefing, says Argon cost "less than a quarter" of Opus. But the article publishes no token counts and no criteria for who won. Anecdote, not data.

The way out is the usual one: run your 20 most common tasks on both and measure cost per solved task. A third-party benchmark doesn't know what your repo looks like.

What breaks if you only swap the model id

The Argon guide has a list of gotchas that will bite anyone coming from Gemini 3.x:

1. temperature, top_p and top_k are ignored. No error. You send them, it pretends it didn't see them.
2. Explicit caching is gone. cachedContents and caches.create don't work. Caching is now implicit, on by default for prompts of 4,096 tokens or more, with a 95% discount on hits.
3. max_output_tokens caps thinking plus the answer. If your app uses less than 32K, the official recommendation is to raise it to at least 32,768. Otherwise the model burns the budget thinking and the answer comes out truncated.
4. Client timeout of 15 minutes or more. Hard prompts can take several minutes. For output above 64K, use background: true.
5. Thinking has three levels: low, medium (default) and high. Google itself tells you to run your eval on all three and keep the lowest one that clears the bar.

Notice that item 3 is the same trap Opus 5.5 brought, as we showed in the post on the GPT-6 and Opus 5.5 wave: thinking always on, max_tokens covering thought and text, and default effort at medium. Both labs converged on the same design. Whoever migrates without touching the token cap gets truncated answers on both.

A minimal Argon call with the google-genai SDK:

from google import genai
from google.genai import types

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

response = client.models.generate_content(
    model="gemini-4-argon",
    contents=prompt,
    config=types.GenerateContentConfig(
        max_output_tokens=65536,  # covers thinking + answer
        thinking_config=types.ThinkingConfig(thinking_level="medium"),
        # no temperature: Argon ignores sampling params
    ),
)
print(response.text)

Argon ↔ Opus fallback in Laravel, switched by .env

If the conclusion is "it depends on the task", the code has to let you switch without a deploy. The shortest path is OpenRouter, which exposes all three models through the same OpenAI-compatible API.

In config/services.php:

'llm' => [
    'base_url' => env('LLM_BASE_URL', 'https://openrouter.ai/api/v1'),
    'key' => env('OPENROUTER_API_KEY'),
    'models' => [
        'coding' => env('LLM_MODEL_CODING', 'anthropic/claude-opus-5.5'),
        'long_context' => env('LLM_MODEL_LONG', 'google/gemini-4-argon'),
        'fallback' => env('LLM_MODEL_FALLBACK', 'openai/gpt-6.1-sol'),
    ],
],

And a client that tries the task's model and falls back on error or timeout:

namespace App\Services;

use Illuminate\Http\Client\ConnectionException;
use Illuminate\Http\Client\RequestException;
use Illuminate\Support\Facades\Http;

class LlmClient
{
    public function complete(string $task, array $messages): string
    {
        $models = config('services.llm.models');
        $chain = array_unique([$models[$task] ?? $models['fallback'], $models['fallback']]);

        foreach ($chain as $model) {
            try {
                return Http::withToken(config('services.llm.key'))
                    ->timeout(900) // Argon can take minutes on hard prompts
                    ->post(config('services.llm.base_url').'/chat/completions', [
                        'model' => $model,
                        'messages' => $messages,
                        'max_tokens' => 32768, // cap for thinking + answer
                    ])
                    ->throw()
                    ->json('choices.0.message.content');
            } catch (ConnectionException|RequestException $e) {
                report($e);
            }
        }

        throw new \RuntimeException("No model answered for task {$task}");
    }
}

When Argon's promo ends on December 1, you re-evaluate with data and change one variable. No PR, no deploy.

How to access Argon

• Gemini API: paid tier only. Argon is not on the free tier.
• Google AI Studio and Antigravity: Google AI Ultra subscribers only.
• Gemini app and AI Mode in Search: AI Pro and Ultra subscribers, according to the official announcement.
• AI Plus: left out. And starting November 13 it also loses access to the Pro models, keeping only Flash and Flash-Lite, as 9to5Google reported.
• OpenRouter: google/gemini-4-argon is already in the catalog, with a :batch variant at half price.

Limitations and caveats

The table is Google's. The 14 out of 18 come from the lab's own model card, with its own harness. The independent numbers (Artificial Analysis and Vals) disagree with each other on who's ahead.

The promo has an end date. Any decision made on the US$ 2/10 price is valid until November 30. Run the numbers at US$ 4/20 too.

Knowledge cutoff in March 2026. The model card warns that knowledge may be outdated in some domains. For a library that changed after that, put the docs in the context.

Slowness and timeouts. The model card itself lists "occasional slowness or timeout issues" as a known limitation. In production, a fallback is not a luxury.

Hallucination numbers floating around. There are posts comparing "15% vs 59%" hallucination between Argon and Opus. I couldn't find the primary source for that number, so it didn't make it in here.

Quick FAQ

Is Gemini 4 Argon better than Claude Opus 5.5? It depends on the task. Argon wins on long context, video, automation and DeepSWE. Opus 5.5 wins on Terminal-Bench 4.0 by 9 points and on FrontierSWE. On the independent Intelligence Index, Opus scores 58 and Argon 53. For a coding agent in the terminal, Opus is still ahead.

How much does Gemini 4 Argon cost? US$ 2 per million input tokens and US$ 10 per million output tokens until November 30, 2026. From December 1, US$ 4 and US$ 20, the same as Opus 5.5. Cache reads get a 95% discount. There's no free tier on the Gemini API.

Should I switch from Opus to Argon now? For huge-context work, document analysis or video, it's worth testing right away, and the promo helps. For coding agents, run your eval first. And remember that in December the price evens out, so the savings are temporary.

Does Gemini 4 Argon work on the free plan? No. Not on the API free tier and not on the free app plan. In the Gemini app it's on the AI Pro and Ultra plans. In AI Studio, Ultra only.

Conclusion

Argon is Google's first model in a long time that goes toe to toe with the top of Anthropic and OpenAI. It wins comfortably on long context and multimodal, ties in aggregate, and loses where the coding agent lives: in the terminal.

What it isn't: an obvious switch. The half price has an end date, and after it the math you're left with is Argon against Opus at the same price, with GPT-6.1 Sol costing half of both.

The next step in this race isn't the next benchmark. It's whoever solves your task at the lowest total cost, measured on your own eval. If you haven't run that math with caching yet, the Fable 5.1 vs Opus 5 comparison shows how it changes everything.