Gemini 4 Argon vs Opus 5.5: Real Cost per Agent Task (2026)

From December 1 the two models charge the same per token. They will not send the same bill, and which one is cheaper depends on the kind of work your agents do.

$4 in, $20 out, $0.20 cached. From December 1, 2026, that is the list price of both Gemini 4 Argon and Claude Opus 5.5, down to the cent - Gemini API pricing. Until November 30 Argon sells at half that, $2 in and $10 out, while Opus 5.5 has cost $4/$20 since it launched on September 22 - Claude pricing. For about five more weeks the comparison looks easy. After that, the rate card tells you almost nothing about the bill.

The measured costs show why. On Vals AI's suite of professional and coding work, which prices both models at $4/$20, Argon finished the average test for $13.37 against $28.12 for Opus 5.5, at nearly the same accuracy - Vals AI. Yet on Artificial Analysis' index, Opus 5.5 at its high effort setting scores a point higher than Argon for $1.82 per task, less than half of the $3.98 that Argon's index run costs at its December price - Artificial Analysis. Both numbers are correct. Vals runs Opus at its most expensive setting, and three mechanics that no price sheet shows (how each vendor counts tokens, how each caches, and how long each model thinks) do the rest.

The practical problem: most comparisons put Argon at its launch price against Opus at maximum effort, which flatters Argon twice. A team that picks a model on that basis can double its agent bill on December 1, or pay several times what it needs to today.

This guide works out the real cost per agent task from first principles: the price sheets line by line, the tokenizer gap that makes "same price per token" mean different prices per word, the caching difference behind most of the measured gap, cost per solved task by workload across independent benchmarks, the hidden multipliers (effort levels, speed tiers, failures that still bill, safety fallbacks), subscriptions and company AI budgets, and a protocol to measure all of it on your own work. Every number links to the source it came from, and every derived number shows its arithmetic.

Contents

1. The Price Sheets: Same Rates, Different Mechanics
2. Cost per Agent Task, From First Principles
3. A Token Is Not the Same Unit on Both Models
4. What the Measurements Show, Setting by Setting
5. The Cache Gap: Why Argon Pays Full Price More Often
6. Where the Ranking Flips: Cost per Solved Task by Workload
7. Real Runs Outside the Leaderboards
8. Effort Levels Are the Real Price List
9. Speed, Latency and What Waiting Costs
10. Failures That Still Send a Bill
11. Subscriptions, Seats and Per-Employee Budgets
12. How to Measure Cost per Task on Your Own Work
13. Verdicts by Workload, and How to Route Between Them
14. What Happens After December 1
15. The Bottom Line

Scorecard: Eight Configurations, One Decision

Most teams are not choosing between two models. They are choosing between configurations. Opus 5.5 has five effort levels (low, medium, high, xhigh and max), Argon has three thinking levels plus a price that doubles on December 1, and Anthropic sells a second model, Claude Sonnet 5.5, at exactly Argon's launch price, permanently. The scorecard therefore ranks eight configurations a team would realistically run, using Artificial Analysis' independent measurements wherever they exist. Artificial Analysis has published Argon only at its high thinking level, so that is the Argon setting in the table, entered twice: once at today's launch price and once at the price from December 1.

The five criteria come from what an agent bill is actually made of. Capability is the Artificial Analysis Intelligence Index. Agentic coding is its independent Terminal-Bench 4.0 run, the closest public proxy for an agent working in a shell. Business workflows is its AutomationBench-AA run, a Zapier-built test of multi-step work across business apps. Cost is the measured cost per index task, which already includes how many tokens each configuration burns and how well it caches. Speed is the average time per index task. All figures come from the per-configuration data on the Argon and Opus pages of Artificial Analysis, read on October 22.

How the scores were built. Capability (25%) is 10 minus one point per two index points below Opus 5.5 at max (57.6). Agentic coding (20%) and business workflows (20%) are 10 minus one point per three percentage points below the best configuration in the table (59.6% and 77.5%). Cost per task (25%) is 10 minus 1.2 points per dollar, and speed (10%) is 10 minus one point per two minutes per task. Each criterion score is rounded to a whole number, finals are weighted averages rounded half up, and ties are listed alphabetically by configuration name.

The ranking carries the central finding of this guide in one glance. Today, Argon at its launch price is the best value on this scale, mostly because it leads business workflows by a wide margin while costing about what Opus at high costs. From December 1, the same Argon falls to sixth, behind Opus 5.5 at high, which matches its capability, ties it on coding, costs less than half as much per task and finishes in well under half the time. Sonnet 5.5 is the quiet alternative in the middle of the table: at xhigh it costs almost exactly what Argon costs today, and it will keep costing that after December 1. Neither flagship wins everywhere, and the rest of this guide explains which kinds of work tip the balance, and why.

1. The Price Sheets: Same Rates, Different Mechanics

The obvious reading of the two price sheets is that the models will cost the same from December. The headline rates support that reading: $4 per million input tokens, $20 per million output tokens (thinking included), and $0.20 per million cached input tokens on both. Even the Batch prices match at $2/$10. Google's launch post states the switch plainly: Argon "launches today at an introductory price," and "after the introductory period expires on November 30, 2026," the $4 input and $20 output prices apply - Google. Argon is also "not available on the Free tier" of the Gemini API, so every comparison here is a paid one.

But an agent's bill is not made of headline rates. It is made of how many tokens fall into each billing category, and the two vendors draw those categories differently. Four mechanics move real bills in different directions: how caching is charged and controlled, how many tokens the same text becomes (section 3), which speed tiers exist around the standard price, and which tools and runtimes carry fees of their own. The table puts the whole sheet side by side.

Artificial Analysis drew the December effect in one chart. It starts from Google's previous Pro model (Gemini 3.1 Pro Preview), adds Argon's extra token use and higher token prices, subtracts the larger cache discount, and lands on Argon's cost per index task at standard pricing and with the promotion. The two right-hand bars are the ones that matter for planning: $3.98 per task at standard pricing against $1.99 with the promotion.

Note what the waterfall says in its subtitle: Argon "uses more tokens and has higher token prices" than Google's previous Pro model, and only the larger cache discount and the promotion bring the per-task cost down. That is the first hint of the pattern this guide documents: Argon's price advantage today is a price advantage, not an efficiency advantage.

1.1 Caching: platform-controlled and free to write, or developer-controlled and guaranteed

The line that matters most for agents is the one that looks least important. Google's caching for Argon is implicit only: it "is enabled by default for prompts of at least 4,096 tokens and discounts cached input tokens by 95% on cache hits," and explicit caching "is not supported on Gemini 4 Argon" - What's new in Gemini 4 Argon. There is no fee to write a cache, and there is also no way to tell the system what to keep.

Anthropic gives the developer the controls and charges for them. You can add a single top-level cache_control field and let the API manage breakpoints automatically, or place breakpoints on specific content blocks yourself; either way, writing the cache costs 1.25 times the input price for five minutes or 2 times for an hour, and every read inside that window costs $0.20 - Claude pricing. Anthropic itself describes cache reads as the line that makes up "the majority of agentic and coding work costs" - Anthropic.

That looks like a small advantage for Google, and on a perfectly cached workload it is one. The catch is in the word "implicit". With Opus 5.5 a cache hit is guaranteed while the cache lives; with Argon a hit is something the platform decides, and every token that misses is billed at the full $4. When most of an agent's input is re-read context, the difference between "guaranteed at $0.20" and "probably at $0.20, otherwise $4" becomes the largest single cost driver after December 1. Section 5 measures it.

1.2 Speed tiers, regions and tool fees

The tiers around the standard price differ in shape as well as level. Google's Flex tier cuts the price of ordinary synchronous calls by 50% in exchange for "variable latency and best-effort availability," with a latency target of one to fifteen minutes - Gemini Flex docs. Its Priority tier costs 1.8 times standard for traffic that must not be dropped. Anthropic has no Flex equivalent; its premium tier is fast mode at $8/$40, which runs at "up to 2.5x speed" and left research preview on October 15, so it no longer needs a beta header or an access request - Claude release notes.

Regions add a smaller multiplier on both sides. On Google Cloud, Argon's non-global endpoints cost 10% more than global ones ($2.20/$11 during the promotion), and the promotion there arrives as 50% credits back on net spend, issued after the billing month and expiring 30 days after issue - Google Cloud pricing. On the Claude API, pinning inference to the US with inference_geo applies a 1.1x multiplier to every token category.

Tool and runtime fees are small but not zero. Grounding with Google Search includes 5,000 free requests a month shared across Gemini 3 and newer models, then costs $14 per 1,000, while Claude's web search costs $10 per 1,000 and web fetch carries no extra charge. Code execution on the Gemini API is free of charge beyond its tokens. On Claude it is free alongside web search or fetch and otherwise comes with 1,550 free hours a month, then $0.05 per container-hour. Claude Managed Agents adds $0.08 per session-hour of running time on top of tokens, while Google says environment compute for its managed agents "is not billed during the preview period."

Why this matters: identical headline rates make the two models look interchangeable on cost, but every mechanic around those rates (cache writes, cache certainty, Flex and Priority, fast mode, regional premiums, runtime fees) pushes real bills in a different direction. How to apply this: budget both models with the same spreadsheet, but add a row for cache misses on Argon and cache writes on Opus, and decide up front which share of your traffic can tolerate Flex or Batch. Our price table of the cheapest LLM APIs lists the rest of the market on the same basis, and the Argon benchmarks and access guide covers every Google tier and cloud in detail.

2. Cost per Agent Task, From First Principles

Strip an agent down to its mechanics and its bill has only a few moving parts. On every turn, the model re-reads the context so far (system prompt, tool definitions, history, tool results), reads whatever is new, thinks, and writes a reply or a tool call. The re-read context is billed as cache hits or misses. The new material is billed at the full input price, plus a write premium on Claude if you cache it. The thinking and the reply are billed as output. Multiply by the number of turns, then by the number of attempts it takes to get a result you can use.

That structure produces five levers, and it is worth naming them before looking at any benchmark, because every measured difference between Argon and Opus 5.5 traces back to one of them. Since the per-token rates are identical from December, none of the levers is the rate. They are all behavior, plus one property of the vendor's tokenizer:

• Tokens per unit of text: how many tokens the same words become
• Full-price input: fresh tokens, cache misses and (on Claude) cache writes
• Cache reads: re-read context, $0.20 per million on both models
• Output: thinking plus answer, $20 per million
• Attempts per success: retries, rescues and review time

The ratios between those categories explain most of what follows. An output token costs 100 times a cache read and 5 times a fresh input token, so a model that thinks at length is expensive even if it reads little, and a model that reads enormous contexts can still be cheap if almost all of that reading is cached. The tokenizer multiplies every other line, because a vendor that turns the same text into more tokens bills more of everything. And attempts multiply the total: a configuration that costs half as much per attempt but fails twice as often costs the same per solved task, before counting what the failures did downstream.

2.1 Why "same price" does not mean "same cost"

Two agents with identical rates can differ in cost per task by a factor of five, because each model has its own habits. One model takes twenty short turns where another takes eight long ones. One thinks for 30,000 tokens before each tool call where another thinks for 3,000 and corrects itself on the next turn. One gets 97% of its context from cache because its harness manages caching explicitly, and another gets 86% because an automatic cache decided otherwise. None of these habits appears on a price sheet, and all of them appear on the invoice.

The habits also depend on the setting you choose. Opus 5.5 writes about 10,000 output tokens per Artificial Analysis index task at low effort and about 119,000 at max, a twelvefold spread for the same model - Artificial Analysis. Comparing "Argon" with "Opus" without naming the setting is like comparing two cars' fuel bills without saying how fast each was driven, and on which roads.

2.2 The formula you can actually use

For budgeting, the cleanest version is a two-step formula. First, cost per attempt: full-price input tokens times $4, plus cached tokens times $0.20, plus output tokens times $20, plus Claude's write premium where it applies, all divided by a million. Second, cost per solved task: cost per attempt divided by the share of attempts that succeed, plus the cost of handling the failures you cannot detect automatically.

The second step is where most comparisons stop too early. If a failure is caught by a test and simply retried, the cost of a failure is one more attempt. If it reaches a customer, a reviewer or a production system, the cost of a failure is whatever that does to you, and it is usually larger than any token bill in this article. Section 6 turns that into a break-even price of a failure, the single most useful number for choosing between these two models.

Why this matters: once the rates are equal, cost becomes a property of the model's behavior on your task, and you can only predict it by measuring tokens per category and success rates, not by reading a rate card. How to apply this: log every agent run as four numbers (full-price input, cached input, output and success), and compute cost per solved task from them. We built the same decomposition for OpenAI's mid-tier model in GPT-6.1 Sol vs Claude Opus 5.5 and for OpenAI's flagship in GPT-6 Astra's real cost per agent task, and the method transfers unchanged.

3. A Token Is Not the Same Unit on Both Models

Every price in this article is quoted per token, and that hides an assumption almost nobody checks: that a token is the same amount of text on both models. It is not. Each vendor splits text with its own tokenizer, and Anthropic says plainly that its newer models (Claude 4.7 and later, Opus 5.5 included) "use a newer tokenizer" that "produces approximately 30% more tokens for the same text" than its earlier models did - Claude pricing. A price per token is therefore not a price per word, and two models at "$4 per million tokens" can charge different amounts for reading the same document.

The cleanest public measurement comes from a head-to-head test The New Stack ran in launch week. Its author built synthetic documents for a long-context test and recorded what each API billed. The same "500K" document came to 549,483 tokens on Argon and 784,087 on Opus, and a roughly 600K document came to 652,492 and 935,332 respectively: about 43% more tokens on Claude both times. A third document of about 900K tokens on Google's count became 1.4 million tokens on Claude's tokenizer, and Anthropic's API rejected it as over the limit - The New Stack.

3.1 What the tokenizer gap does to a bill

The consequence is simple arithmetic. If the same text costs 1.3 to 1.4 times as many tokens on Opus, then at equal per-token rates Opus charges roughly 30% to 43% more per word of input it reads at full price, and proportionally more per word of cache it re-reads. The effect also shrinks the usable context window: Argon's 1,048,576-token window, shared by input, thinking and output, holds noticeably more text than Opus's 1M-token window. For workloads that load one large document, read it once and answer, Argon keeps a structural cost advantage even after December 1.

The long-context numbers bear this out. In The New Stack's 500K test, Argon's call cost $1.10 at the launch price (so about $2.20 from December) against $3.25 for Opus, mostly because Opus was billed for 43% more input tokens and also reasoned for over 5,000 tokens where Argon wrote a few hundred. On Artificial Analysis' long-context reasoning evaluation, Argon at its December price costs about $0.47 per task against $0.59 for Opus at high, while scoring three points lower (79.7% against 82.7%).

The caveats matter as much as the effect. The ratio depends on the content: prose, code, tables and non-English text tokenize differently, and one publisher's synthetic wiki is not your corpus. The gap also matters least where agents spend most of their tokens, in cached re-reads at $0.20 per million, because a 30% surcharge on a very cheap line is still cheap. And it says nothing about output: a model that thinks in fewer, longer tokens is not cheaper if it needs more of them to reach an answer.

Why this matters: the one cost difference that survives December 1 in Argon's favor is not on either price sheet, and it is largest for exactly the work where Argon is strongest (reading and reasoning over large documents). How to apply this: before you budget, count the tokens of a sample of your real inputs with both vendors' token counters (Anthropic's token counting endpoint, and Google's usage metadata on a test call), and multiply your input estimates by the measured ratio rather than assuming one token equals one token.

4. What the Measurements Show, Setting by Setting

The best public data on cost per task comes from Artificial Analysis, which runs every model through the same ten evaluations, from business-app workflows to terminal coding, and records what each run actually spends. Its pages embed a full cost breakdown per task: fresh input, cache writes, cache reads, thinking tokens and answer tokens. That is exactly the decomposition from section 2, measured rather than estimated, and it allows a comparison of Argon and Opus 5.5 setting by setting instead of headline to headline.

One limitation shapes everything below. Artificial Analysis measured Argon only "with high reasoning (the highest available)," while it lists Opus 5.5 at all five effort levels - Artificial Analysis. Its Argon costs also use the launch price, so the December figure is double, as its own waterfall chart in section 1 shows. The table converts every configuration to the prices that apply from December 1 and keeps Argon's launch-price figure for reference.

The figures come from the per-setting pages, including Opus 5.5 at medium, and from the embedded data on the Argon page. Generation speed is close across the board: Argon writes about 81 tokens per second and Opus 5.5 between 75 and 95, so the large differences in time per task come from how many tokens each configuration produces and how many steps it takes, not from raw speed.

Artificial Analysis also plots every model's index score against its cost per task on a log scale, which shows where Argon sits in the wider field. At its launch price Argon lands close to the frontier line, near GPT-6 Astra on score; Opus 5.5 at max sits at the top right, highest on score and among the most expensive.

The scatter plots Argon at its launch price and Opus at max only. Move Argon to its December price and it shifts right to about $4, past Opus at xhigh; add Opus at high to the chart and it sits slightly above Argon on score, at under half Argon's December cost. That is the comparison the next subsection makes explicit.

4.1 The comparison everyone makes, and the one that matters

The comparison that circulated in launch week set Argon at high against Opus 5.5 at max, because those are the headline configurations each lab and tester quotes. On that basis Argon looks dramatically cheaper. One Hacker News commenter put it precisely: on Artificial Analysis' index, "it cost $8,708 to run with Opus and $2,407 to run with Argon so even if Argon's token price doubles, it won't be the same price as Opus" - Hacker News. Those totals match the published data, and the conclusion holds: Argon at high costs two-thirds of Opus at max even after December ($3.98 against $5.98 per task).

But Opus at max scores 58 and Argon 53. The like-for-like comparison is the Opus configuration that reaches Argon's capability, and that is Opus 5.5 at high, which scores 54 for $1.82 per task. At December prices, Argon at high costs 2.2 times as much for a point less and takes 2.5 times as long. Even at today's launch price, Argon's $1.99 is slightly above Opus at high. Artificial Analysis said as much in its launch analysis: Argon's cost advantage is "driven by lower token prices, rather than reduced token use." The same Hacker News commenter drew the general lesson from a different pair: Sonnet 5.5 is cheaper than Opus per token, yet on Artificial Analysis' coding tests it "burns through enough tokens that it's 7.5% more expensive."

The fair reading is that both statements are true and answer different questions. If you need the highest capability available, Opus at max is the only configuration that reaches 58, and Argon is a much cheaper step down. If you need Argon-level capability at the lowest price, Opus at high (or at medium, three points lower) is cheaper on this general mix of tasks, before and after December.

4.2 Where the money goes inside one task

The cost breakdown explains why Opus at high is cheaper despite identical rates, and the answer is not the one most people expect. The intuitive guess is that Argon thinks more. It does: 61,558 output tokens per task against 35,584 for Opus at high. But that is the smaller part of the gap. The larger part is input billed at full price.

Converted back to tokens, the picture is striking. Per index task, Argon at high reads about 3.19 million cached tokens and pays full price on about 528,000. Opus at high reads about 3.02 million cached tokens, a similar volume, but pays full price (as cache writes and uncached input) on only about 106,000. Argon's cached share is about 86%; Opus's is about 97%. Of the $2.16 gap between Argon's December cost and Opus at high, about $1.60 (74%) is full-price input and about $0.52 (24%) is output, with cache reads making up the last few cents. That is our arithmetic on Artificial Analysis' published breakdown.

Two refinements keep the reading honest. First, those token counts are each vendor's own tokens, and section 3 showed that Claude counts the same text as roughly 30% to 43% more tokens. Opus's 3.1 million input tokens per task therefore represent noticeably less text than Argon's 3.7 million, which means Argon is not only caching worse, it is also taking longer trajectories and re-reading more material. Second, Opus at max shows the other pattern: it re-reads about 12 million cached tokens per task, four times as much as at high, and thinks for about 84,000 tokens, yet keeps its full-price input to about 240,000 tokens because almost everything it re-reads is served from a cache it controls. Reading is cheap when cached and expensive when it is not; thinking is expensive either way.

4.3 What the index does not tell you

Three caveats keep this section in proportion. First, Google's default thinking level is medium, not high, and Artificial Analysis has not published Argon at medium, so the cheapest sensible Argon configuration is missing from the table. Zapier's own tests suggest it matters: Argon at medium passed 50.08% of AutomationBench tasks for $1.54 each at list prices, against 51.29% for $1.70 at high - Zapier. Second, every Opus row is labelled "with fallback," meaning some tasks were completed by another Claude model after a safety refusal, which section 10 prices. Third, the index is a weighted mix of ten evaluations, and that mix is not your workload.

Why this matters: the most quoted cost comparison between these models compares two configurations five index points apart, and the like-for-like comparison reverses its conclusion. How to apply this: when you see a cost ratio between Argon and Opus 5.5, check which settings it used, then find the Opus setting that matches Argon's quality on your task (usually high or medium) and compare against that. For a wider field of models measured the same way, see our October 2026 ranking of LLMs for AI agents.

5. The Cache Gap: Why Argon Pays Full Price More Often

Every agent framework re-sends the conversation on every turn. A forty-step agent loop that starts with a 25,000-token prompt and adds 4,500 tokens per step ends with a context of 205,000 tokens, and over its life it re-reads about 4.5 million tokens of history. At $4 per million, re-reading that history uncached would cost about $17.90. At $0.20 per million, cached, it costs about $0.90. For agents, caching is not an optimization; it is the difference between a viable product and an unviable one, which is why both vendors priced cache reads at 95% off this autumn.

The two vendors made opposite design choices about who controls the cache. Anthropic gives control to the developer: mark what to cache (or switch on automatic caching), pay a write premium, and every read inside the time-to-live is billed at $0.20. Google gives control to the platform: no breakpoints, no write fee, and the system decides what gets reused. Each choice has a cost. For agents, the cost of Google's choice is that misses happen silently and are billed at the full input rate, and the cost of Anthropic's choice is the write premium plus a cache that expires if the agent pauses too long.

5.1 The evidence on hit rates

Several independent sources measured how much of Argon's input actually comes from cache, and they agree that it is less than Claude's in agent workloads. The levels vary widely, because hit rates depend on how a harness builds its prompts, how long sessions last and how much each turn changes the start of the prompt, so no single figure is "the" hit rate for either model.

None of them is a controlled cache experiment: each reports the cached share as a side effect of running its own benchmark, in its own harness, with its own prompt layout. The two sources that ran both models through the same harness, Artificial Analysis and Zapier, both put Argon well below Opus. The other two report Argon alone: one high, in a single long and stable session, and one flagged by its maintainers as low:

• Artificial Analysis index: about 86% of Argon's input cached, against about 97% for Opus at high (our arithmetic)
• Zapier AutomationBench: cached share of 59% to 63% for Argon, against 89% to 91% for Opus
• Minecraft research run: 91% cached across about 24,000 Argon calls
• FrontierSWE: maintainers flag Argon's cache hit rate as "much lower" in their runs

The Zapier figures come from its per-model reports, which show Argon's cached share at 59.2% on medium and 62.7% on high - Zapier Argon report, against 89.1% to 91.3% across Opus's five settings - Zapier Opus report. The Argon report predates general availability (it assumed a $0.40 cache price that Google never announced), so its dollar figures are off, but the cached share is a measurement, not a price. The Minecraft figure comes from a research paper discussed in section 7, and FrontierSWE attributes its low Argon hit rate to "a non-production setting" - FrontierSWE.

The pattern across those sources is that Argon's cache works well in long, stable sessions (the Minecraft agents played one continuous 27-hour session) and less well in harnesses that build varied prompts per task, which is what most benchmark and production agents do. Explicit control on the Claude side keeps its share high and stable across settings, from 89% at low effort to 91% at xhigh in Zapier's runs.

5.2 Why implicit caching misses more

The mechanism is partly documented and partly reverse-engineered. Google documents the floor: implicit caching only starts at 4,096 tokens, against 512 for Opus 5.5, so short prompts never cache at all - Gemini caching docs. The engineering team at Induction tested the rest in an October 19 write-up and found that Argon places "another breakpoint 2049 tokens before the end of every request," adding that "there looks to be a requirement that we always pay for at least 2049 tokens" - Induction. In their example, a 1,000-token follow-up on a 4,100-token thread "only hits the cache of 2051 (4100-2049) and we pay for 3049 (2049+1000)."

For an agent, that rule is a tax on every short turn. A tool call that returns 300 tokens still pays full price on at least 2,049, and when a breakpoint is not reused the cache falls back to an earlier point and re-bills everything after it. Agents that take many small steps, which is most of them, pay this repeatedly. Induction's own comparison put a 1,000-token follow-up at 2.19 cents on Argon against 1.41 cents under OpenAI-style caching for the same pattern.

On the Claude side the risks are different and mostly under your control. The 5-minute cache expires if a step pauses longer (a slow build, a human approval, a rate-limit wait), and the next turn re-writes the entire context at $5 per million. Changing anything early in the prompt also invalidates the cache: on Opus 5.5, even editing the system prompt or tools invalidates the model's earlier thinking blocks, which is why Anthropic added mid-conversation system messages that can add or change tools "without editing tools or invalidating the prompt cache" - Claude release notes.

5.3 Same trajectory, different cache rules

The cleanest way to see the effect is to hold the agent's behavior fixed and change only the cache rules. The chart prices one illustrative trajectory (40 turns, a 25,000-token starting prompt, 4,500 new tokens and 2,500 output tokens per turn) at December prices under each vendor's rules. It is our model, not a measurement, and it gives both models identical token counts except in one scenario, which applies a 30% tokenizer surcharge to Opus's input to reflect section 3.

With a perfect cache, Argon is the cheaper model by about 5%, because it pays no write premium. But the break-even is brutal: with identical token counts, Argon has to serve about 98.8% of its prior context from cache to match Opus with a working 5-minute cache, and about 95.4% even if Claude's tokenizer adds 30% to Opus's input. At the 86% that Artificial Analysis' data implies, the same run costs $6.10 on Argon against $3.92 on Opus, 56% more. Opus has its own cliff: if the cache expires before every fourth turn and the whole context is written again, the run costs $8.89, which is why the 1-hour cache ($4.54) is cheap insurance for any agent that pauses.

The arithmetic fits in a few lines of Python, so you can plug in your own trajectory. It uses only the published December prices and makes no API calls.

# December 1, 2026 list prices, USD per 1M tokens
ARGON = {"input": 4.00, "cache_read": 0.20, "output": 20.00}  # implicit cache, no write fee
OPUS = {"input": 4.00, "cache_read": 0.20, "cache_write_5m": 5.00,
        "cache_write_1h": 8.00, "output": 20.00}

def argon_turn(prior_ctx, new_tokens, output_tokens, hit_rate=1.0):
    """Google caches implicitly: you cannot force a hit, only measure it."""
    cached = prior_ctx * hit_rate
    full_price = prior_ctx - cached + new_tokens
    return (full_price * ARGON ["input"] + cached * ARGON ["cache_read"]
            + output_tokens * ARGON ["output"]) / 1e6

def opus_turn(prior_ctx, new_tokens, output_tokens, ttl="5m", token_ratio=1.0):
    """Anthropic caches what you mark: writes cost extra, reads are certain while the cache lives.
    token_ratio scales input for Claude's tokenizer (1.3 = 30% more tokens for the same text)."""
    write = OPUS ["cache_write_" + ttl]
    return (prior_ctx * token_ratio * OPUS ["cache_read"] + new_tokens * token_ratio * write
            + output_tokens * OPUS ["output"]) / 1e6

def run(turn_fn, turns=40, prefix=25_000, per_turn=4_500, out=2_500, **kw):
    ctx, total = 0, 0.0
    for k in range(turns):
        new = prefix + per_turn if k == 0 else per_turn
        total += turn_fn(ctx, new, out, **kw)
        ctx += new
    return round(total, 2)

print("Opus, 5-minute cache:   ", run(opus_turn))                    # 3.92
print("Opus, +30% tokens:      ", run(opus_turn, token_ratio=1.3))   # 4.5
print("Opus, 1-hour cache:     ", run(opus_turn, ttl="1h"))          # 4.54
for h in (1.0, 0.95, 0.86, 0.80):
    print(f"Argon, {h:.0%} cache hits:", run(argon_turn, hit_rate=h))  # 3.72, 4.57, 6.1, 7.13

The model is deliberately simple. Real misses are prefix-shaped rather than an even percentage, Claude agents also lose some cache, and real models differ in tokens per turn (Argon tends to produce more output, as section 4 showed). But the structure holds: under implicit caching, your bill depends on a hit rate you can observe but not set, and every percentage point of misses on a long context costs real money.

5.4 How to close the gap on each model

On Argon, the levers are prompt hygiene. Google's own advice is to put "large and common contents at the beginning of your prompt" and to "send requests with similar prefix in a short amount of time." In practice that means keeping the system prompt, tool definitions and reference documents first and byte-for-byte identical across calls, avoiding anything that changes early in the prompt (timestamps, reordered tools, per-request IDs), and batching small tool results into fewer, larger turns so the 2,049-token minimum bites less often. Then measure: the Interactions API reports cached input as usage.total_cached_tokens, and a falling share is a bug to fix, not weather to accept.

On Opus 5.5, the levers are placement and lifetime. Put cache breakpoints at the end of the stable prefix and at the end of each turn (or use automatic caching), and switch to the 1-hour TTL for any agent that waits on builds, tests or people. Cache diagnostics left beta on September 23, so any request can opt in to diagnostic detail about its cache use. Anthropic's own guidance on its SWE-bench Pro subset is that the same work costs 3.3 times as much without caching - Claude Docs. Our guides to prompt caching for agents and context engineering cover the prompt layouts that keep a prefix stable while the task changes.

Why this matters: from December 1, caching behavior, not price, is the largest single driver of the cost difference between these two models on long agent loops, and it is invisible on both price sheets. How to apply this: before choosing, run twenty of your real agent tasks on each model, record the share of input served from cache, and plug the measured hit rates into the estimator above. If Argon's cached share on your harness stays below about 95%, Opus with a well-placed cache will usually cost less per turn, even after allowing for its tokenizer.

6. Where the Ranking Flips: Cost per Solved Task by Workload

A general index averages very different kinds of work, and the two models are not equally good, or equally expensive, at all of them. Two independent sources split cost by workload, and at first sight they disagree. Artificial Analysis measures Argon at high against every Opus setting. Vals AI runs both models through more than twenty professional and coding benchmarks with both priced at $4/$20, but it runs Argon at high reasoning and Opus at max effort, the headline configurations - Vals AI on Opus 5.5. Read side by side, the two sources stop disagreeing and start telling one story.

The story is that the setting decides the winner more often than the model does. Against Opus at high, Argon at its December price costs more on almost every agentic evaluation. Against Opus at max, Argon is far cheaper on almost everything. And underneath both, a consistent split appears between work that is mostly reading and reasoning over material and work that is mostly acting, observing and correcting inside an environment.

6.1 Artificial Analysis, evaluation by evaluation

Artificial Analysis publishes a score and a cost per task for each evaluation in its index, for each configuration. The table converts Argon's costs to December prices and puts them next to Opus at high and at max. Terminal-Bench 4.0 tests agentic work in a command line, AutomationBench-AA is Zapier's test of multi-step business-app workflows, GDPval-AA and AA-Briefcase grade professional work products on an Elo-style scale, and AA-LCR tests reasoning over long documents.

The figures come from the evaluation data embedded in Artificial Analysis' Argon page and the matching Opus pages. Three patterns stand out. Against Opus at high, December-priced Argon costs more on all four agentic evaluations and is cheaper only on the two document-reading ones (AA-LCR and GDP.pdf), exactly where the tokenizer gap from section 3 helps most. Against Opus at max, Argon is cheaper on every evaluation in the table except Terminal-Bench, where the two cost about the same. And Argon's one decisive quality lead is AutomationBench, where it scores 14 points above Opus at high.

Artificial Analysis' launch charts show the two evaluations where the models' strengths are most distinct. Argon leads every model on AutomationBench-AA, while Sonnet 5.5, Opus 5.5 and GPT-6 Astra all score above it on Terminal-Bench 4.0.

The AutomationBench lead is large enough to survive the price rise. Argon at December prices costs $0.52 more per task than Opus at high on that evaluation and scores 14.3 points higher, so it pays for itself whenever a failed business workflow costs you more than about $3.63. For nearly any real business process (an order entered wrong, a lead routed to the wrong rep, an invoice sent twice), a failure costs far more than that.

6.2 Vals AI, benchmark by benchmark

Vals reports accuracy and cost per test for each benchmark, and its pages make the max-effort comparison concrete. The table lists the benchmarks with the clearest cost signal, ordered from the work where Argon has the biggest advantage per solved task to the work where Opus does. "Cost per solved" divides cost per test by accuracy, which is what you would pay per success if every failure were caught and retried. Opus's scores include tasks completed by a fallback model after a refusal; section 10 explains why that matters.

The per-benchmark figures come from Vals' leaderboards for Vibe Code Bench, Legal Research, Tax Agent, Finance Agent, SRE Bench, Code Migration, Terminal-Bench 4.0 and SWE-bench Multimodal. Two rows deserve emphasis. On Vibe Code Bench, where an agent builds a web application from a specification, Argon was slightly more accurate and about seven times cheaper per test, finishing in 37 minutes against 1 hour 36 for Opus. On SWE-bench Multimodal, where an agent fixes real issues in real repositories, Opus was 14 points more accurate and cost less than half as much per test.

The same pages show a third option that neither flagship comparison mentions. Claude Sonnet 5.5, at $2/$10, topped Code Migration at 86.88% for $43.88 per test, more accurate than both flagships and cheaper than Argon even at Argon's December price. On Vibe Code Bench, Claude Haiku 5.5 reached 90.44% for $6.07 per test, within two points of Argon for less money. A comparison of two flagships is a comparison of two price points in a much wider menu.

6.3 The break-even price of a failure

Cost per solved task assumes every failure is caught and retried for the price of another attempt. In practice some failures slip through, and those cost whatever they cost your business. The cleaner way to choose is the break-even price of a failure: if one configuration costs ΔC more per attempt and succeeds Δp more often, it is worth paying for when a failure costs you more than ΔC divided by Δp. The arithmetic turns benchmark tables into a question you can answer from your own operations.

Applied to the Vals data, the answers are vivid. On the Vals Index overall, Opus 5.5 is 0.94 points more accurate for $14.75 more per test, so it pays for itself only if a failed task costs you more than about $1,570. On Tax Agent the break-even is about $1,150, and on Finance Agent (0.19 points for $4.59) about $2,400. On Code Migration, though, Opus is 10.2 points more accurate for $27.61 more, a break-even of just $270, and a failed migration almost always costs more than that. On Terminal-Bench and SWE-bench Multimodal no break-even is needed, because Opus is both cheaper and more accurate. On Vibe Code Bench, Legal Research and SRE Bench, Argon is both.

Zapier's AutomationBench gives the same calculation for business workflows, using strict pass rates and standard list prices for both models. Argon at high passes 51.29% of tasks for $1.70, and Opus at max passes 42.47% for $1.44 - Zapier. Argon costs $0.26 more per task and succeeds 8.8 points more often, so it is worth it whenever a failed workflow costs more than about $2.95, close to the $3.63 that Artificial Analysis' data implies against Opus at high.

6.4 What separates the two kinds of work

The pattern is not random, and it follows from the mechanics in sections 2 to 5. Argon is cheapest per success where the work is finding and reasoning over information: research a legal question, work through a tax case, pull figures from filings, move records between business apps, read a long document and answer. These tasks have relatively few turns, so the cache gap has little room to compound, the tokenizer gap favors Argon on fresh reading, and Argon finishes them in fewer, shorter trajectories. On the Vals Index as a whole, Argon processed 13.36 billion input tokens against 31.96 billion for Opus at max and averaged 45 minutes per test against 85 - Vals AI.

Opus 5.5 is cheapest per success where the work is a long loop of acting, observing and correcting inside an environment: run a command, read the error, edit a file, run the tests again. These tasks have many turns over a growing context, which is where guaranteed caching pays most, and where a wrong step is expensive because every later turn carries it. The exceptions (Vibe Code Bench, where Argon builds web apps cheaply, and GDPval, where Opus at high produces professional deliverables more cheaply than Argon) are a reminder that this is a tendency, not a law. Our analysis of why coding benchmarks often fail to transfer and our guide to what GDPval measures explain why your own tasks are the only final test.

Why this matters: the cheaper model flips with the shape of the work and with the setting, and the swing is large: up to seven times in Argon's favor on some professional benchmarks against Opus at max, and up to three times in Opus's favor on repository coding. How to apply this: classify each agent workload as mostly "read and reason" or mostly "act and correct," estimate what a failure costs in each, compare against the Opus setting that matches Argon's quality (usually high), and use the break-even formula to decide whether the extra accuracy is worth its price on that workload.

7. Real Runs Outside the Leaderboards

Leaderboards run thousands of tasks in clean harnesses, which makes them precise and also a little unreal. Developers and journalists spent launch week running the two models on their own work, through their own tools, and their results add two things the leaderboards cannot: the variance of real tasks, and judgments of quality that no automatic grader captures. None of these tests is large enough to settle anything alone. Together they show a consistent pattern that is worth knowing before you run your own.

The table collects the head-to-head tests we could verify, with the settings and prices each author used. All ran in the launch window, so Argon's costs are at its $2/$10 launch price; double them for December.

7.1 Two patterns, and what they mean

The first pattern is about cost, and it is more nuanced than "Argon is cheaper." At the launch price Argon was cheaper in every test. On the longer, multi-step jobs it used more tokens than Opus for the same result: 2.4 times as many per question on Plotly's exam and 1.4 times the output on DataCamp's build, so its advantage came from the half-price rate that ends on November 30. On Plotly's exam the two cost the same at launch prices, so from December Argon will cost about twice as much for the same 41 correct answers. On The New Stack's shorter, single-call tasks the opposite held: Argon used fewer tokens for its code review and fix, and the author notes it "would still come out cheaper at its full Dec. 1 price." Short tasks favor Argon; long loops erode it.

The second pattern is about quality on constrained work. When the task has many hard requirements that must all hold (eighty hidden tests on a billing engine, an arm that must never touch an obstacle, a complete list of failing services), Opus 5.5 was more reliable. The New Stack's billing result is instructive: Argon's logic was mostly right, but its code "passed an extra argument to Python's datetime.combine()," which broke most of the module, and after the author corrected that one line Argon scored 80 of 80. The long-context miss was different in kind: Argon answered the blast-radius question with a few hundred output tokens while Opus reasoned for more than 5,000, and the author judged that Argon "got the reasoning wrong at every size." Cheap answers that skip the thinking are only cheap until someone acts on them.

Pat Simmons' review for AI for Mortals is the most detailed public cost comparison on full builds, and the video walks through every build, its token counts and its cost table. The pricing and benchmark chapter starts at 3:15, and the verdict, including why Argon placed last in every blind ranking despite its low cost, starts at 43:14.

The review also records something the cost tables cannot. Its costs are "API-equivalent costs, meaning the real token counts from each build priced at each model's published rates," and Argon's figure used the promotional rate; at December prices its $39.54 becomes about $79, still well under Opus's $189.04. But on a $99-a-month Google plan the author "hit the daily limit after about one build," and Argon came last on quality in all four builds. Section 11 returns to what subscriptions really include.

7.2 A long-running agent run, priced in full

The most complete real-world cost record so far comes from a research paper in which four Argon agents played Minecraft together until they defeated the Ender Dragon, which took 27 hours and 14 minutes, 2,783 programs and 605 deaths. Its cost section is unusually precise: "the four players processed about 1.35 billion input tokens, 91% of them served from the context cache," and "generated about 16 million output tokens, including 4 million thinking tokens, over roughly 24,000 model calls," which at Argon's introductory list price "comes to about $520 ($1,040 at the standard price)" - arXiv.

The shape of that bill is the shape of most long-running agents. At December prices, roughly $730 of the bill is input and about $320 is output, even though Argon was thinking on every call. The 9% of input that missed the cache, about 120 million tokens at $4, costs about $486, twice the $246 paid for the 91% that hit it. By our arithmetic, the same token counts on Opus 5.5 would cost about $1,170 at the same 91% hit rate (because Claude bills misses as $5 cache writes) and about $780 at a 97% hit rate; Claude's tokenizer would raise both figures by roughly the 30% from section 3. In long agent runs, the cache hit rate moves the bill by as much as the choice of model.

7.3 What full agent benchmarks cost per attempt

Two coding benchmarks publish the cost of complete agent attempts, which is the closest public analogue to a real engineering task. On the official Terminal-Bench 4.0 leaderboard, Opus 5.5 at max inside Claude Code ranks first at 64.8%, using 8.0 billion tokens and about $4.7k for the full run, while Sonnet 5.5 at max ranks second at 61.8% for about $7.3k because it used 19.4 billion tokens - Terminal-Bench. Argon is not listed there yet. On FrontierSWE, where each model gets five trials per task with a 20-hour budget, Opus 5.5 scored 62.3% at $98.87 per trial and Argon 55.0% at $129.36, with the caveat on Argon's cache noted in section 5 - FrontierSWE.

Developer anecdotes point the same way at smaller scale. One Hacker News user who built Pac-Man with both found Argon "as good as Opus 5.5, it was slightly cheaper, but took twice as long" - Hacker News. Another, paying for Argon through an OpenCode subscription, reported that "using Gemini Argon 4 on High for a few sessions supposedly used $26 of my $60 usage and burned up my weekly request limit already" - Hacker News. For agents that run for hours, our guide to long-running coding agents covers the checkpointing and verification loops that keep these bills predictable.

Why this matters: small real-world tests consistently show Argon's launch-week cost advantage coming from its half-price rate rather than from efficiency on long jobs, and Opus 5.5 holding an edge on tasks with many hard constraints. How to apply this: treat launch-week cost comparisons as December comparisons by doubling Argon's figures, weight quality results on constrained tasks heavily (those are the failures that cost the most after the agent hands over its work), and note which tests were short single calls, where Argon stays cheap.

8. Effort Levels Are the Real Price List

Both models now expose a single dial that controls how much they think, and that dial moves cost per task by an order of magnitude. Opus 5.5 has five effort levels; a request that omits the setting "runs at medium; on Claude Opus 5 it ran at high" - Claude Docs. Thinking cannot be switched off on Opus 5.5 at all: the effort parameter is the only control. Argon has three thinking levels, with medium as the default, and Google tells developers to run evaluations "at all three levels" and then pick the lowest level that meets their quality bar - What's new in Gemini 4 Argon.

The practical consequence is that "Argon vs Opus" is really a comparison of two price lists, one with three entries and one with five. On Artificial Analysis' index, Opus 5.5 spans $0.55 to $5.98 per task from low to max, an elevenfold range. Anthropic's own guidance is to "start with Claude Opus 5.5 at its default effort (medium)" for most agent workloads, and its sweep on a SWE-bench Pro subset shows why: $0.11 per task at low for 87.4% solved, $0.21 at medium for 92.8%, $0.29 at high for 95.3%, and $0.74 at xhigh for 96.7% - Claude Docs.

8.1 More effort is not always more accuracy

The most expensive settings are not reliably the best ones. On Artificial Analysis' Terminal-Bench 4.0 run, Opus 5.5 scores 59.6% at both xhigh and max, but costs $8.78 per task at xhigh against $13.11 at max. On ARC-AGI-2, Opus at high scores 93.3%, above both xhigh (92.5%) and max (91.7%), at a fraction of the price. Anthropic itself reports its Terminal-Bench 4.0 headline result "for Claude Opus 5.5 at xhigh effort," not max - Anthropic. An independent test on SlopCodeBench found the same: Opus 5.5 at medium passed 28 of 196 strict checkpoints for $193.47, while xhigh passed 25 for $817.04, and the author concluded that "opus 5.5 did BETTER on medium effort than on xhigh" - SlopCodeBench.

Argon shows a different risk at the top of its dial. In DataCamp's robot-arm test, Argon at high "spent its whole default 65,536-token output budget reasoning and never wrote the file," so both models were rerun at medium. That is the worst possible outcome for cost per task: a full bill and no result. Google's documentation warns about exactly this, advising apps with lower limits to "raise max_output_tokens to at least 32,768" because Argon can spend more of the limit on thinking than earlier models, and to raise client timeouts to at least 15 minutes for hard prompts.

8.2 The two dials side by side

ARC Prize publishes cost per task for both models at every setting, which makes it the cleanest public view of the two dials together. The table converts Argon's costs, which ARC Prize reports at the introductory price, to December prices; Opus's are already at $4/$20 - ARC Prize on Argon.

The Opus figures come from ARC Prize's Opus 5.5 results. Three things stand out. At medium, the two models are level on accuracy and Argon is about 20% cheaper even at December prices. At high, Opus is both more accurate and cheaper. And Argon at low collapses to less than half its high score, so its cheapest setting is only safe for genuinely simple work. The same shape appeared on AutomationBench, where Argon at medium reached 50.08% against 51.29% at high for about 9% less money.

Why this matters: the effort setting moves cost per task more than the choice between these two models does, and the most expensive settings often buy nothing. How to apply this: start both models at medium, raise the setting only for the task types where your evaluation shows a real gain, and cap output per request so a high setting cannot spend a whole budget without producing an answer. Our guide to cutting LLM costs covers effort routing alongside the other levers, and are AI models smarter or just searching more explains why more thinking so often looks like more intelligence on a leaderboard.

9. Speed, Latency and What Waiting Costs

Token cost is only part of what an agent task costs when a person is waiting for it. A developer pairing with a coding agent, an analyst waiting for a report or a support lead waiting for a draft all turn latency into money. If an engineer's time is worth $100 an hour to the business, five extra minutes of waiting costs about $8, more than the token bill of most tasks in this article. For interactive work, the faster configuration can be the cheaper one even when its tokens cost more.

The two models' speed profiles differ more by task than by raw generation rate. Artificial Analysis measures similar output speeds, about 81 tokens per second for Argon and 75 to 95 for Opus 5.5, but very different times per index task: 723 seconds for Argon at high, against 294 for Opus at high and 797 for Opus at max. Time to first token runs from about 20 seconds for Opus at medium and 37 at high, through 48 for Argon, to more than ten minutes for Opus at max, because thinking happens before the first visible token. On Vals' professional suite the order reverses (Argon averaged 45 minutes per test against 85 for Opus at max), and the real builds split the same way: AI for Mortals recorded Argon finishing in about a third of Opus's time, while the Pac-Man tester found it took twice as long.

9.1 Buying speed: fast mode, Priority and Flex

Both vendors sell speed and both sell patience. Anthropic's fast mode for Opus 5.5 costs $8/$40, double the standard rate, for up to 2.5 times the speed, and since October 15 Opus 5.5 "has a default fast mode rate limit in the Start, Build, and Scale tiers," so nobody needs to request access - Claude rate limits. It is available on the Claude API and on Microsoft Foundry for Azure-hosted deployments, not on Bedrock or Google Cloud, and not through the Batch API.

Google's equivalent is the Priority tier at $7.20/$36 from December 1, 1.8 times standard, which is sold as reliability under load as much as speed: its default rate limits are "0.3x the standard rate limit for each model and tier" - Gemini API rate limits. In the other direction, Flex halves the price of ordinary synchronous calls for traffic that can wait one to fifteen minutes and can tolerate being shed under load, and Google names background agents ("CRM updates, profile building, or content moderation") as the intended use. Both vendors also halve prices for Batch. For background agents nobody watches, Flex on Argon is a real advantage that Claude only matches with the Batch API.

The decision rule is simple once the cost of waiting is on the table. Fast mode doubles the token bill; it pays when the human time saved is worth more than the extra tokens. For a $2 task that a developer watches, fast mode adds about $2 and can save several minutes, which is usually worth it. For an overnight run of ten thousand document reviews it never is, and Flex or Batch is the right tier on either model.

Why this matters: for interactive agents, latency often costs more than tokens, and the two models' speed varies by task type rather than by a fixed ratio. How to apply this: measure wall-clock time per task alongside tokens in your own evaluation, put a dollar value on waiting for each workflow, and use fast mode or Priority only where that value exceeds the doubled token cost. Push everything that can wait to Batch, or to Flex on Argon.

10. Failures That Still Send a Bill

Every pricing page describes what a successful request costs. Agents spend a surprising share of their budgets on requests that do not succeed: answers cut off by a timeout, reasoning that never converges, requests refused and retried, runs abandoned halfway. Both models bill for some of these, under rules that are different enough to matter for anyone running long or sensitive workloads.

The differences follow from each model's design. Argon's ability to produce very long answers means a failed request can be very expensive. Opus 5.5's safety classifiers mean some requests are quietly handed to a different, older and pricier model. Neither is a reason to avoid either model, but both belong in a cost estimate, and both can be contained with settings you control.

10.1 Argon: long answers, long bills

Argon can write up to about a million tokens in one answer through long decode, which generates the response in hops of up to 64,000 tokens. Google's guide is explicit about billing: "You pay for every token in every hop, including hops that contain only thinking," and for cancelled and failed interactions, "You pay for all work completed before the interaction ends" - Gemini long decode. A background interaction "can run for up to 24 hours," and because the context is re-read on every hop, Google's own example bills about 397,000 input tokens for a 1,000-token prompt that generates 200,000 tokens.

Google Cloud adds a related rule that takes effect next month: "When a completion exceeds 32K tokens in length, users will be charged for retrievable token usage even if the request ultimately fails due to client or server timeouts. This will take effect on November 13 2026" - Google Cloud pricing. In practice, a client timeout that used to cost nothing will soon cost money on long Argon answers, which makes background execution and explicit output caps part of cost control, not just reliability.

10.2 Opus 5.5: refusals, fallbacks and an older model

Opus 5.5 ships with safety classifiers (cybersecurity, and a biology classifier new on this model), and when one declines a request the API can retry it on another model. With server-side fallback (in beta), "the API retries a declined request on the fallback model Anthropic recommends for its refusal category," and the routing "is not published for each model" - Claude Docs. Anthropic's launch page says most cybersecurity tasks "will be re-routed to Opus 4.8," which lists at $5/$25, more per token than Opus 5.5 itself. Since September 24, refusals that arrive before any output are billed in three categories (bio, frontier LLM development and reasoning extraction), and a fallback credit spares you from paying to write the fallback model's cache twice.

How often does it happen? Vals measured a 4.28% fallback rate and a 1.01% refusal rate for Opus 5.5 across its suite, and counting fallback-assisted tasks as failures lowers Opus's Vals Index score from 70.18% to 64.16%, while "Gemini 4 Argon had no fallbacks, so it would rank first" - Vals AI. On security-adjacent infrastructure work the effect is extreme: on SRE Bench, 217 of 262 Opus tasks (82.8%) were fallback-assisted, and on CyberBench standard Opus 5.5 scored 55.36% against 77.86% for Argon, while a separate Vals entry for Opus under Anthropic's Cyber Verification Program (labelled CVP) scored 74.58% - Vals CyberBench. One cheap fix sits in your prompts: requests that ask the model to write out its reasoning in the answer can be refused as "reasoning extraction" and billed, so ask for summarized thinking blocks instead.

10.3 Spend caps that stop a runaway

Both platforms give you a hard stop, and both stops are blunt. The Gemini API enforces a spend limit per rolling ten minutes on some accounts: $10 on Tier 1, $50 on Tier 2 and $200 on Tier 3, with a 429 error when exceeded. At Argon's December cost of about $3.98 per index-style task, a Tier 1 project can finish only about two or three such tasks every ten minutes, which matters more for parallel agents than any price line. Anthropic enforces monthly caps of $500 on Start, $1,000 on Build and $200,000 on Scale, returning enforced_spend_limit_reached when one is hit, and lets you set a lower limit of your own.

A real budget sits in your own code: a per-request output cap sized to the task, a per-task token budget, and an alarm on spend per hour. Opus 5.5 also supports task budgets in beta, which give the model a running countdown for a whole agentic loop; Anthropic is explicit that they are "a soft hint, not a hard cap," and that max_tokens remains the enforced ceiling - Claude task budgets. Our guide to AI agent observability tools compares the platforms that track spend per run, and AI agent sandbox security covers the containment side of runaway agents.

Why this matters: a cost estimate built only from successful requests understates both models: Argon for long answers that fail or time out, Opus 5.5 for refusals and fallbacks on sensitive work. How to apply this: cap output per request on Argon and prefer background execution for anything long; log fallback events on Opus and price them at Opus 4.8 rates; and keep your own per-task budget and alarms instead of relying on the platforms' blunt spend limits.

11. Subscriptions, Seats and Per-Employee Budgets

Many teams never see a per-token bill, because their people use these models through subscriptions: the Gemini app and Google Antigravity on one side, Claude, Claude Code and Cowork on the other. A subscription turns cost per task into tasks per month, and the question becomes how much agent work a flat fee actually buys before a limit stops it. That is also how companies have started to think about AI spend per employee, which makes the cost-per-task numbers in this guide a budgeting tool rather than a curiosity.

Both vendors moved their plans this autumn. Google AI Pro and Ultra subscribers got Argon in the Gemini app on October 13, together with a Tasks mode in which "Gemini can work for you even when you're not at your computer" and connections to "more than 40 apps" - Google. Anthropic started including monthly API credits in its Max and Team plans on October 7, which blurs the line between a seat and a token budget.

The Claude figures come from Claude's pricing page and the Google tiers from Google's May subscription update, which introduced the $100 Ultra tier and cut the top tier to $200. Argon in Antigravity is reserved for Ultra subscribers. Limits are where these plans differ in practice: the AI for Mortals tester ran out of a $99 Google plan's daily allowance after about one heavy build, and the OpenCode user in section 7 spent nearly half of a monthly allowance in a few high-effort Argon sessions. A flat fee is only cheap if your agent's cost per task fits inside the limit.

11.1 What companies now budget per employee

Companies have started to ration AI spend, and their caps turn cost per task into policy. Accenture told many employees that it "will now only spend $29 a month per person on Claude," effective October 1, with extra usage charged to a project budget - 404 Media. Some of its staff had been spending as much as $1,000 a month, and premium plans include $250 of token usage a week - The Next Web. Uber caps each employee at $1,500 a month per agentic coding tool, a policy Simon Willison estimated at about $36,000 a year for an engineer using two tools - Simon Willison.

Those caps sit at opposite ends of a very wide distribution. Ramp's card and bill-pay data from more than 70,000 US businesses puts the median AI adopter at $11.95 per employee per month, the top 10% at $650, and the top 1% at $7,400.50 - Ramp. The chart translates Accenture's $29 into whole Artificial Analysis index tasks per month at each configuration's measured cost, which is a rough but honest proxy for heavy, multi-step agent work.

The spread is the point. At Opus 5.5's default medium effort, $29 buys about 21 heavy tasks; at max it buys 4; Argon at its December price buys 7. Lighter work stretches the same budget much further: at Anthropic's measured $0.21 per task on its SWE-bench Pro subset at medium effort, $29 covers about 138 tasks. Under a per-employee cap, the effort setting is no longer an engineering detail, it is the number of things each person can get done.

Why this matters: flat fees and per-employee caps convert every difference in this guide into a difference in output per person, and a configuration that costs twice as much per task halves what a capped employee can do. How to apply this: express your AI budget as tasks per person per month at the configuration you actually run, set defaults (effort, model) centrally so the cap buys the most useful work, and reserve high and max effort for the tasks where your own evaluation shows they pay for themselves.

12. How to Measure Cost per Task on Your Own Work

Every number in this guide is somebody else's workload. The only cost per task that matters for your decision is the one your own agents produce on your own tasks, through your own harness, and it is cheaper to measure than most teams assume. Twenty to fifty real tasks with a checkable outcome are enough to see which side of each break-even you are on, because the differences that matter here are large (factors of two to seven), not a few percent.

The measurement has to capture the same categories the bill is made of, or it will repeat the mistakes of the launch-week comparisons. That means recording cached and uncached input separately, output (thinking included), whether the task succeeded, and how long it took, for each configuration you are considering. The protocol below is the minimum that produces a decision you can defend.

1. Pick real tasks with an outcome you can check automatically or by quick review
2. Run each configuration you would actually deploy, at least twice per task
3. Log four token numbers per call, plus success and wall-clock time
4. Price everything at December rates, doubling any Argon bill from November
5. Compute cost per solved task and the break-even price of a failure

The fourth step catches the most common error: a November pilot on Argon that looks cheap because it ran at the introductory price. The fifth step forces the question that decides most cases, which is what a failure costs your business. For tasks whose failures are caught by tests, cost per solved task is enough; for tasks whose failures reach customers, the break-even price is the number to put in front of whoever owns the budget.

12.1 A small calculator for the logged numbers

The calculator below turns logged usage into cost per solved task and a break-even price, using the December list prices. On Claude, the usage object reports input_tokens, cache_creation_input_tokens, cache_read_input_tokens and output_tokens separately. On Argon through the Interactions API, cached input appears as usage.total_cached_tokens; everything else in the input count is billed at the full rate, because implicit caching has no separate write charge.

from dataclasses import dataclass

# December 1, 2026 list prices, USD per 1M tokens (standard tier, 5-minute Claude cache writes)
PRICES = {
    "argon": {"input": 4.00, "cache_write": 0.00, "cache_read": 0.20, "output": 20.00},
    "opus":  {"input": 4.00, "cache_write": 5.00, "cache_read": 0.20, "output": 20.00},
}

@dataclass
class Call:
    model: str        # "argon" or "opus"
    fresh_input: int  # Claude: input_tokens. Argon: total input minus usage.total_cached_tokens
    cache_write: int  # Claude: cache_creation_input_tokens. Argon: 0
    cache_read: int   # Claude: cache_read_input_tokens. Argon: usage.total_cached_tokens
    output: int       # thinking plus answer

    def cost(self) -> float:
        p = PRICES [self.model]
        return (self.fresh_input * p ["input"] + self.cache_write * p ["cache_write"]
                + self.cache_read * p ["cache_read"] + self.output * p ["output"]) / 1e6

def cost_per_solved(runs):
    """runs: list of (calls, solved) pairs for one configuration."""
    total = sum(call.cost() for calls, _ in runs for call in calls)
    solved = sum(1 for _, ok in runs if ok)
    return total / solved if solved else float("inf")

def break_even_failure_cost(cost_a, success_a, cost_b, success_b):
    """Above this cost of one failure, the pricier but more accurate configuration B pays off."""
    return (cost_b - cost_a) / (success_b - success_a)

# Vals Index, both models at $4/$20: Argon at high vs Opus 5.5 at max
print(round(break_even_failure_cost(13.37, 0.6924, 28.12, 0.7018)))  # about 1569

Two measurements belong next to the calculator. First, count tokens for the same text on both vendors, because the tokenizer ratio from section 3 changes every estimate you make from a document size. Second, watch the cached share per call over a session: on Claude, cache diagnostics (out of beta since September 23) can explain a miss, and on Argon a falling total_cached_tokens share usually means something early in the prompt has started to change.

12.2 Making the measurement permanent

A one-off evaluation decides the first routing; a permanent one keeps it right as prices, models and prompts change. Anthropic launched an OpenTelemetry export beta on October 14 that traces Messages API requests and Managed Agents sessions into an observability platform, which lets cost per task become a standing dashboard rather than a spreadsheet - Claude release notes. On the Google side the same numbers come from each response's usage object and can be logged by whatever harness runs the agent.

The harness matters as much as the model here, because it decides how prompts are built and therefore how well each cache hits. Our comparison of agent harnesses covers the options that log usage per run, and the observability tools guide prices the platforms that store and chart it.

Why this matters: published benchmarks give you starting estimates and the shape of the trade, but your harness, prompts and task mix decide the actual hit rates, token counts and success rates. How to apply this: run the five-step protocol before December 1 on twenty to fifty real tasks, price everything at December rates, and keep logging the same four numbers in production so the routing can follow the data when either vendor changes its prices.

13. Verdicts by Workload, and How to Route Between Them

The evidence in this guide does not produce one winner, and it should not, because the two models were built around different trade-offs. Argon spends more tokens and relies on an automatic cache, and in exchange it reads text cheaply and excels at structured business work. Opus 5.5 controls its cache and spends its thinking efficiently at moderate effort, and in exchange it carries a tokenizer surcharge and safety fallbacks on sensitive work. The right question is not which model is cheaper, but which model is cheaper for which kind of task, at which setting.

The table condenses the verdicts for the prices that apply from December 1. "Lower cost per success" assumes failures are caught and retried; where failures are expensive, apply the break-even prices from section 6 on top.

Routing between the two is now a normal architecture, not an exotic one, and the diagram shows the decision a router makes for each new workload. The branches are starting points, to be replaced by your own measurements as soon as you have them.

13.1 The options a two-model comparison leaves out

The flagship comparison hides two cheaper Anthropic options that the benchmarks keep surfacing. Claude Sonnet 5.5 costs $2/$10 with cache reads at $0.10, exactly Argon's launch price, and it does not double on December 1 - Claude pricing. It ranks first on the Vals Index at $18.70 per test, and Anthropic measured it level with Opus at low effort on its SWE-bench Pro subset for about the same cost per solved task. It is not automatically cheaper, though: on the official Terminal-Bench 4.0 run it used more than twice Opus's tokens and cost more in total. Claude Haiku 5.5, at $0.10/$0.50 for prompts up to 100,000 tokens, came within two points of Argon on Vibe Code Bench for less money.

The same logic applies one level up. If your team would rather not assemble and tune this routing itself, platforms that build and operate a whole company's work through AI, such as O-mega, are an alternative to wiring individual models into your own agent stack, and they can be judged by the same yardstick: cost per solved task on your work, not price per token. Our guide to AI model routing covers the routing patterns and the savings they produce, and the true cost of LLM inference explains why per-task cost keeps falling faster than list prices suggest.

Why this matters: a single default model leaves money on the table in both directions, because each flagship is the cheaper choice for a different and identifiable kind of work. How to apply this: classify your workloads with the table above, route the "read and reason" share to Argon and the "act and correct" share to Opus 5.5 at medium or high, send simple high-volume steps to a cheaper tier, and let measured cost per solved task move workloads between branches.

14. What Happens After December 1

The calendar for the next six weeks is fixed and worth putting in a planning document. On November 13, Google Cloud starts billing completions over 32,000 tokens that fail on a timeout. On November 30, Argon's introductory price ends; on Google Cloud, where the promotion arrives as 50% credits back, credits are issued on the seventh day of the month after the usage and expire 30 days after issue, so the credit for November's usage arrives on December 7 and lapses in early January. On December 1, Argon's rates double to $4/$20, and every cost comparison made at launch prices becomes a comparison at the wrong price.

The structural question is where the two vendors compete next, and the evidence points to the lines this guide found decisive rather than the headline rates. Anthropic has already cut the cache-read price twice: Opus 5.5's cache reads cost "$0.20 per million tokens, 60% less than Opus 5" - Anthropic, and on October 7 it halved Sonnet 5.5's cache reads to $0.10. Google, by contrast, competes with an automatic cache and has not offered explicit caching on Argon at all: "Explicit caching (cachedContents / caches.create) is not supported on Gemini 4 Argon." Our reading, which is reasoning rather than reporting: once headline rates match, the next price moves will come on cached reads, cache controls and token efficiency per setting, because those are what decide cost per task for agents.

Three developments would change the verdicts in this guide, and they are worth watching more closely than any new headline rate. The first is explicit caching for Argon, or simply a lower 2,049-token minimum, which would close most of the cache gap that drives Opus's advantage on long agent loops. The second is an Argon thinking level that keeps its quality while cutting thinking tokens, because output is the other half of Argon's December gap against Opus at high. The third is fewer Opus fallbacks on security and infrastructure work, which would remove Argon's clearest win. Any of the three would move workloads between the branches of the routing diagram in section 13, which is why the measurement in section 12 should run continuously rather than once.

Pressure from outside the two labs will keep pushing in the same direction. Open-weights releases such as Meta's Muse Spark Open, covered in our guide to running it, put a floor under what simple agent steps can cost, and per-employee caps like Accenture's make cost per task a procurement metric rather than an engineering one. Both forces reward the configuration that solves the task with the fewest full-price tokens, whichever lab makes it.

Why this matters: decisions made on launch-week prices expire on December 1, and the factors that will decide the next round (cache controls, token efficiency, fallback behavior) are already visible. How to apply this: put November 13, November 30 and December 1 in your plan, re-run your measurement protocol in the first week of December at real prices, and treat any change to either vendor's caching rules as a trigger to re-route.

15. The Bottom Line

From December 1, Gemini 4 Argon and Claude Opus 5.5 charge the same per token, and that equality hides almost everything that decides the bill. Argon reads text more cheaply per word, leads business-app workflows by a wide margin, and costs far less than Opus at max effort. Opus 5.5 caches more reliably, thinks more efficiently at moderate effort, and at its high setting matches Argon's measured capability for less than half Argon's December cost per task and in well under half the time. Measured head to head at comparable capability, Opus 5.5 is the cheaper general-purpose agent model after the promotion ends; measured on reading, research and business workflows, Argon often wins on cost per solved task.

The decision framework reduces to five questions you can answer from your own logs. First, what kind of work is it: read-and-reason work favors Argon, act-and-correct work favors Opus. Second, which setting matches the quality you need: compare Argon with Opus at high or medium, never only with max. Third, what share of input will be served from cache: below about 95% on Argon, Opus usually wins on long loops even after its tokenizer surcharge. Fourth, what a failure costs: use the break-even price, not the cost per attempt. Fifth, whether the work touches security or infrastructure, in which case check Opus's fallback rate before you commit.

Until November 30, Argon at its launch price is the best value on our scorecard, and running a real pilot on it now costs half of what it will cost later. Just price that pilot at December rates before you decide, measure cost per solved task rather than cost per token, and let each workload go to whichever model solves it for less.

This guide reflects pricing, benchmarks and documentation as of October 22, 2026. Gemini 4 Argon's introductory price ends on November 30, 2026, Google Cloud's timeout billing rule starts on November 13, 2026, and benchmark figures change as providers and testers re-run models, so verify current details before committing budget.