# Gemini 4 Argon: judge it by cost per finished task

> Argon's token price doubles on December 1. Test it against your current model by replaying real past tasks, judging blind and comparing cost per finished task.

Published: 2026-10-17 · Updated: 2026-10-17
Author: Sushruth Aeluguri
Tags: AI/ML, Applied AI
Canonical: https://www.techfabric.com/blog/gemini-4-argon-what-to-do-this-quarter

---

Gemini 4 Argon is Google's new frontier model, and this post is a practical test for deciding whether to move your company's AI agents onto it. Its token price doubles on December 1, so the decision should rest on your own numbers. Replay your past agent tasks on both models and compare what each task that actually gets finished costs.

We learned to measure it that way on our own agents. On 15 October one of them was spending faster than everything else we run put together. TechFabric's engineers build AI agents for companies with more work than engineers, and our own fleet writes and fact-checks the posts on this site and the notes on our Databricks Field Guide. All of it bills through one Cloudflare AI Gateway account, and that afternoon the gateway's logs put about 85% of its spend on a single agent, our blog writer on Claude Opus 5. Since the 12th its most expensive day had cost more than six times its cheapest, and it was draining the credit towards the floor that pauses every agent we run.

The Field Guide's agent had just been through a model change of its own, backed by a replay of five of its real past tasks on three candidate models, through every gate the production job runs, counting what each model cost per draft that got through. The cheapest model per call published nothing, and Claude Sonnet 5.5 got three of five drafts through every gate, so each publishable draft cost a third of its run. With the credit running down we moved the blog writer on that result the same day instead of waiting for a replay of its own tasks, a shortcut we'd only take with a deadline that hard.

We'd test Argon the same way. [Google's announcement](https://deepmind.google/blog/introducing-gemini-4-argon/) on 13 October puts it at $2 per million input tokens and $10 per million output tokens through November 30, 2026, then [$4 and $20 from December 1](https://ai.google.dev/gemini-api/docs/pricing). Below is the method we'd use, with the cost formula worked through on those prices, a replay harness you can adapt and a decision table that makes the call per task.

## Our model replay and its results

The bake-off ran on 15 October and is written up in the pull request that settled our Field Guide agent's model. Each model got the same five real inputs: two briefs our CEO, Preetham Reddy, had answered, two reader questions and one release note. Each replayed the production agent's recorded prompt, taken from the gateway logs, and went through the job's own code with its repair loop, fact-check and helpful-content gate. A draft counted as publishable only if it came out the far end.

| Model | Publishable | Run cost, Sonnet 5.5 = 100% | Per publishable draft |
| --- | --- | --- | --- |
| Claude Sonnet 5.5, thinking low | 3 of 5 | 100% | 33% of run cost |
| Claude Haiku 4.5 | 0 of 5 | 16% | none finished |
| Llama 4 Scout 17B (Workers AI) | 0 of 5 | 3% | none finished |

Llama's whole run cost 3% of Sonnet's and produced no publishable draft, so all of that spend was wasted. Haiku never drew a diagram our renderer accepted in three drafts, even after three repair asks, and one draft invented a first-hand claim. A per-token comparison doesn't show that. A model that fails your gates hands the work back to a person, and an hour of that person's time costs more than the tokens the cheap model saved.

Quality got its own reading. Cloudflare's Clef model judged the drafts blind, anonymised and shuffled, three readings each, every pair asked in both orders. Sonnet 5.5 won 62% of pairwise comparisons, and the Opus 5 notes we'd already published won 39%, so the cheaper model didn't lower the bar.

## Cost per finished task: the formula

An agent bills in tokens, but what you're paying for is a ticket closed, a contract clause checked or a pull request that passes review. So we compare models on what each finished task costs:

```text
cost per finished task =
  sum over every call in every attempt of
    (uncached input × input price + cached input × cached price + output × output price)
  ÷ number of tasks that passed your checks
```

Retries, repair rounds, tool calls and the fact-check all count. On Argon the output side includes thinking tokens, which [Google's pricing page](https://ai.google.dev/gemini-api/docs/pricing) bills at the output rate.

Argon's published prices for the standard paid tier, per million tokens:

| | Through Nov 30, 2026 | From Dec 1, 2026 |
| --- | --- | --- |
| Input | $2.00 | $4.00 |
| Output, including thinking | $10.00 | $20.00 |
| Cached input | $0.10 | $0.20 |
| Batch input / output | $1.00 / $5.00 | $2.00 / $10.00 |

Cached input is 95% off in both periods. Argon isn't on the free tier, and the page lists no higher rate for long prompts.

## A worked example on Argon's prices

Take an illustrative agent task of 20 model calls. Each call sends 30,000 input tokens, of which 24,000 are a stable prefix (system prompt, tool definitions, the policy document) and 6,000 are new. Each call returns 2,000 tokens, thinking included. These sizes are made up for the example; your replay gives you the real ones.

At the December price with no cache hits, every call costs 30,000 × $4 plus 2,000 × $20 per million, so $0.16, and the task costs $3.20.

With the prefix cached from the second call on, each later call costs $0.024 for fresh input, $0.0048 for the cached prefix and $0.04 for output, so $0.0688. The task comes to $1.47. That's cheaper than the same task at the introductory price with no caching, which is $1.60.

Now divide by the finish rate. If Argon finishes 60% of your replayed cases, the cached task costs $2.45 per finished task at the December price, and at 80% it's $1.83. That counts one attempt per case, so it's a floor, and it leaves out the hour a person spends on every case the agent dropped.

Caching saves this task $1.73 at the December price, more than twice what the December increase adds to the cached task, so cache hits matter more to your bill than the November 30 date does. Once the prefix is cached, output is 58% of each call's cost, so the thinking level you pick (Argon takes low, medium or high, per its [model page](https://ai.google.dev/gemini-api/docs/models/gemini-4-argon)) becomes the biggest dial you have.

Argon's caching is implicit only. Explicit caching isn't supported, so you can't pin a cache yourself. The [caching docs](https://ai.google.dev/gemini-api/docs/caching) set a 4,096-token minimum for Argon, advise putting large common content at the start of the prompt and sending similar requests close together, and report hits in `usage.total_cached_tokens`. So keep the stable material first and byte-identical between calls. A timestamp at the top of the system prompt is enough to miss the cache on every call.

## The replay harness

Take an agent that already runs, keep its prompts and tools, and send a fixed set of real past cases through the current model and the candidate. We'd use 20 to 50 cases with known outcomes, and fewer when the finish rates come out far apart. Our five cases were enough to rule out two models that finished none.

This sketch is the shape of ours, cut down to Python. `complete()` is whatever client your agent already uses, and `passes()` is your production checks, unchanged.

```python
import json, random

PRICES = {  # USD per 1M tokens: (input, cached input, output)
    "gemini-4-argon@intro": (2.00, 0.10, 10.00),
    "gemini-4-argon@dec":   (4.00, 0.20, 20.00),
    "current":              (0.00, 0.00, 0.00),   # fill in your current model's list price
}

def cost(usage, price):
    p_in, p_cache, p_out = price
    fresh = usage["input"] - usage["cached"]
    return (fresh * p_in + usage["cached"] * p_cache + usage["output"] * p_out) / 1e6

def replay(cases, model, price_key, complete, passes, max_attempts=3):
    spent, finished, outputs = 0.0, 0, {}
    for case in cases:  # recorded prompts from your gateway or trace logs
        for _ in range(max_attempts):
            text, usages = complete(model, case["messages"])  # every call in the attempt
            spent += sum(cost(u, PRICES[price_key]) for u in usages)
            if passes(case, text):  # the same gates production runs
                finished += 1
                outputs[case["id"]] = text
                break
    return {"spent": spent, "finished": finished,
            "per_finished": spent / finished if finished else None,
            "outputs": outputs}

def blind_pairs(a, b):
    """Shuffle labels so the judge never knows which model wrote which."""
    for cid in a.keys() & b.keys():
        pair = [("x", a[cid]), ("y", b[cid])]
        random.shuffle(pair)
        yield cid, pair  # ask the judge in this order, then reversed
```

The zeros under "current" are yours to fill in. Run the Argon replay once and price the same token counts twice, at `@intro` and at `@dec`, since the tokens don't change on December 1 and only the multiplier does. Google's model page lists Batch API support for Argon, and a replay doesn't need answers in seconds, so batch halves the cost of running the experiment itself.

A gate tells you a draft is acceptable, and the judge tells you which of two acceptable answers is better. Use a model from a different family to the ones under test, hide the labels, ask each pair in both orders so any lean towards the first answer cancels out, and average several readings. We use Clef on Workers AI for ours.

```mermaid
%% caption: How one candidate model goes from a launch to a routing decision, task by task.
flowchart TD
  A["Real past cases with known outcomes"] --> B["Replay on the current model"]
  A --> C["Replay on Argon"]
  B --> D["Same production gates"]
  C --> D
  D --> E["Blind judge on pairs that both passed"]
  E --> F["Cost per finished task at the December price"]
  F --> G["Route this task type to the winner"]
  class F accent
```

## Deciding per task

A model that wins on contract review can lose on ticket triage, so we'd make the decision for each task type separately, and the replay tells you which way each one goes.

The week we'd plan for one task type goes like this. Monday and Tuesday go on pulling the past cases and their outcomes out of your logs and wiring `passes()` to the checks production already runs. Wednesday is the replay on both models, through the Batch API where you can. Thursday the judge reads the pairs that both models passed. On Friday you reprice everything at the December rate and fill in the table below.

| What the replay shows | What we'd do |
| --- | --- |
| Argon finishes more cases and costs less per finished task at the December price | Route that task to Argon |
| Argon finishes more cases but costs more per finished task | Route it only where a failed task costs a person more than the difference |
| Same finish rate, judge prefers Argon, cost within a few cents | Route it, and re-run the replay monthly |
| Same finish rate, judge sees no difference | Keep the current model; moving has a cost too |
| Argon finishes fewer cases | Keep the current model, whatever the token price says |
| It only wins at the introductory price | Treat it as a loss. December is the price you'll pay |

That's the same routing we described for [agents](/ai/agents). A small model takes the volume, a frontier model takes the few tasks where the replay showed a real gain, and the approval step and permission boundary stay outside the model, whichever one wins.

## Context window, long jobs and Argon on Databricks

Argon's context window is 1,048,576 tokens, shared between input and output. A normal synchronous call returns up to 65,536 tokens. Past that you need [long decode](https://ai.google.dev/gemini-api/docs/long-decode), which runs as a background interaction (`background: true`, with `store: true` required) and generates in 64K hops for up to 24 hours. The docs say every token in every hop is billed, and that the input repeated in later hops gets the 95% cache discount. A job that ends `incomplete` has used all of `max_output_tokens`, and the documented fix is to send it again with a higher limit, which means paying for the first attempt as well. We'd size `max_output_tokens` from the replay before any long job goes near production.

The window doesn't replace retrieval for chatbots and search over company documents. Retrieval still decides what the model reads, and a million tokens of the wrong pages costs $4 a call from December. Our page on [chatbots and enterprise search](/ai/chatbots-enterprise-search) covers that layer. The window is worth paying for when a task needs a whole contract or a whole module in view at once.

If your data lives on Databricks, Argon is reachable there. The [Unity Gateway release notes](https://docs.databricks.com/aws/en/release-notes/unity-gateway/) added it on 13 October, and the [supported models page](https://docs.databricks.com/aws/en/machine-learning/foundation-model-apis/supported-models) lists `databricks-gemini-4-argon` as a Databricks-hosted, pay-per-token Foundation Model API endpoint. Two lines on that page matter for a design. It uses a global endpoint and requires cross-geography routing to be enabled, which your data-residency review needs to see, and reasoning can't be disabled, so every call carries thinking tokens. That page gives no per-token price. Our own agents can already send their model calls through Databricks serving endpoints with AI Gateway's usage tracking and rate limits on, and that's where we'd run an Argon replay for a client whose data can't leave the workspace.

## Our Argon test so far

On 17 October we tried to add Argon to our replay. The Cloudflare gateway that pays for our agents routed Gemini 3.8 Flash and Gemini 3.1 Pro Preview through its unified billing, but not `gemini-4-argon`, so that row of our table is still empty. When the route opens we'll run the Field Guide cases through it under the same gates, with a budget per draft like the one our blog writer works to.

## Frequently asked questions

### How much does Gemini 4 Argon cost?

Argon costs $2 per million input tokens and $10 per million output tokens through November 30, 2026, and $4 and $20 from December 1, according to [Google's pricing page](https://ai.google.dev/gemini-api/docs/pricing). Cached input is $0.10 and then $0.20, batch runs at half the standard rate, and thinking tokens bill as output.

### How big is Gemini 4 Argon's context window?

The window is 1,048,576 tokens, shared between input and output. A synchronous call returns up to 65,536 tokens, and long decode in the background can run to the full window, less your input.

### Can I use Gemini 4 Argon from Databricks?

Yes, as the Databricks-hosted pay-per-token endpoint `databricks-gemini-4-argon` in Foundation Model APIs. It needs cross-geography routing enabled, and reasoning can't be turned off.

### Should I move all my AI agents to Gemini 4 Argon?

No, only the task types where a replay of your own past cases shows a lower cost per finished task at the December price. Keep cheaper models on the work they already finish.