# Gemini 4 Argon vs Gemini 3.1 Pro: Cost per Task and When to Switch

> Gemini 4 Argon costs $2/$10 per 1M tokens until November 30, then $4/$20. Compare cost per task with Gemini 3.1 Pro, break-even token ratios, and code changes.

- Source: https://www.aifreeapi.com/en/posts/gemini-4-argon-vs-gemini-3-1-pro
- Language: en
- Published: 2026-10-14
- Updated: 2026-10-14
- Publisher: AI Free API (https://www.aifreeapi.com)

As of October 14, 2026, the practical answer for teams running `gemini-3.1-pro-preview` is: **test `gemini-4-argon` on your real tasks now, while its introductory price lasts, and move workloads one at a time based on cost per finished task.** Argon costs $2 input / $10 output per million tokens through November 30, 2026, and $4 / $20 from December 1 ([Gemini API pricing](https://ai.google.dev/gemini-api/docs/pricing)). Gemini 3.1 Pro stays at $2 / $12 for prompts up to 200k tokens.

Argon is the newer, stable model (GA since October 13), and it scores far higher on the one independent index that covers both. But it can also spend more thinking tokens, and thinking is billed at the output rate on both models. That makes the price sheet a poor guide:

- **Through November 30, prompts up to 200k tokens:** Argon costs less per request only if it uses no more than **1.2×** the output-plus-thinking tokens that 3.1 Pro uses for the same task.
- **From December 1, same prompt sizes:** the break-even ratio falls below **0.6×**. For input-heavy requests, where input is more than 6× the output, Argon costs more no matter how few tokens it generates. It then pays off only where it needs fewer attempts or agent steps to finish the job.
- **Prompts over 200k tokens:** Argon is cheaper on both rates now and close to parity after December 1.
- **The one public measurement:** in Artificial Analysis's index runs, Argon (High) used about **1.68×** the output tokens of 3.1 Pro and cost $1.99 per task versus $1.30, rising to $3.98 after the discount.

Switching is also more than a model-ID edit for `generateContent` code. Explicit caching, `thinking_budget`, and sampling parameters stop working, the default thinking level drops from high to medium, and answers longer than 64K tokens need the new continuation protocol.

## Switch, test, or stay on Gemini 3.1 Pro: the answer by workload

Use this as a starting point, then confirm it with your own token ratio (measurement steps are below). Ratios refer to Argon's output-plus-thinking tokens divided by 3.1 Pro's for the same task.

| Workload | Through November 30 | From December 1 | What decides it |
| --- | --- | --- | --- |
| Short chat, Q&A, extraction (prompt ≤200k) | Test; Argon wins only at ≤1.2× tokens | Stay on 3.1 Pro unless Argon clearly needs fewer retries | Token ratio; many such tasks also fit [Gemini 3.8 Flash](/en/posts/gemini-3-8-flash) |
| Agent steps with large context (input much bigger than output) | Test | Stay unless Argon finishes in fewer steps | Steps per finished task, implicit cache hits |
| Hard coding and reasoning, output-heavy | Switch where answers get accepted more often | Switch only where accuracy per attempt pays for 1.67× output pricing | Attempts per accepted answer |
| Long-context review (prompt >200k) | Argon: cheaper on input ($2 vs $4) and output ($10 vs $18) | Near parity: input $4 on both, Argon must stay under 0.9× tokens | Output-token ratio |
| One answer longer than 65,536 tokens | Argon (3.1 Pro cannot) | Argon | Long decode setup |
| Long-lived explicit cache (same large prefix, many questions over hours) | Stay | Stay | Argon has no explicit caching |
| Prompts near 1M tokens that also need a large answer | Stay | Stay | Argon's output shares the 1M window |

The December 1 column is the one to plan around. During the introductory window, Argon's per-token prices are equal or lower on every line; after it, Argon needs a quality or efficiency advantage to justify the price on most short and mid-size requests.

## Gemini 4 Argon vs Gemini 3.1 Pro price: $2/$10 now, $4/$20 from December 1

These are Standard paid-tier prices per 1M tokens on the Gemini Developer API, as of October 14, 2026 ([pricing page](https://ai.google.dev/gemini-api/docs/pricing)). Output prices include thinking tokens on both models.

| Price per 1M tokens | Gemini 4 Argon through Nov 30, 2026 | Gemini 4 Argon from Dec 1, 2026 | Gemini 3.1 Pro Preview, prompt ≤200k | Gemini 3.1 Pro Preview, prompt >200k |
| --- | --- | --- | --- | --- |
| Input | $2.00 | $4.00 | $2.00 | $4.00 |
| Output (including thinking) | $10.00 | $20.00 | $12.00 | $18.00 |
| Cached input | $0.10 (implicit only) | $0.20 (implicit only) | $0.20 + $4.50 per 1M tokens per hour storage | $0.40 + storage |
| Batch / Flex input and output | $1 / $5 | $2 / $10 | $1 / $6 | $2 / $9 |
| Priority input and output | $3.60 / $18 | $7.20 / $36 | $3.60 / $21.60 | $7.20 / $32.40 |

Three details change the comparison:

- **Argon has one price for all prompt sizes.** There is no separate >200k tier, which is why long prompts are where Argon looks best.
- **Argon is paid-tier only.** It is not on the Gemini API Free tier or available through the Google AI Pro plan in AI Studio. 3.1 Pro has no API free tier either.
- **The December 1 date is Google's own.** It appears on the pricing page, the [What's new in Gemini 4 Argon](https://ai.google.dev/gemini-api/docs/latest-model) page, and the [launch post](https://blog.google/innovation-and-ai/models-and-research/gemini-models/introducing-gemini-4-argon/). Check the pricing page again before you budget past November.

## Argon cost per task: break-even at 1.2× tokens now, below 0.6× from Dec 1

A request costs `input tokens × input price + (output + thinking tokens) × output price`. Let `I` be the input tokens and `O` the output-plus-thinking tokens 3.1 Pro uses for a task, and `k` the ratio of Argon's output-plus-thinking tokens to 3.1 Pro's on the same input. With `I` and `O` in millions of tokens, the results below are in dollars. For prompts up to 200k tokens:

- **Now:** Argon costs `2I + 10kO` and 3.1 Pro costs `2I + 12O`. Argon is cheaper while `k ≤ 1.2`.
- **From December 1:** Argon costs `4I + 20kO`. It breaks even at `k = (12O − 2I) / (20O)`. That value is always below 0.6, and it turns negative once `I` exceeds `6O`, which means Argon's input alone costs more than 3.1 Pro's entire request.
- **Prompts over 200k:** 3.1 Pro costs `4I + 18O`. Argon is cheaper on both rates now; from December 1 input prices match, and Argon breaks even at `k = 0.9`.

The table applies those formulas to four request shapes. **The token counts are illustrative assumptions, not measurements.** The `k = 1.68` column uses the ratio derived from Artificial Analysis's index runs, described in the next section.

| Example request (3.1 Pro tokens in / out) | 3.1 Pro | Argon now, k = 1.0 | Argon now, k = 1.68 | Argon Dec 1, k = 1.0 | Argon Dec 1, k = 1.68 | Break-even k now | Break-even k Dec 1 |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Short chat or coding turn (20,000 / 4,000) | $0.0880 | $0.0800 | $0.1072 | $0.1600 | $0.2144 | 1.20 | 0.10 |
| Agentic coding step (80,000 / 12,000) | $0.3040 | $0.2800 | $0.3616 | $0.5600 | $0.7232 | 1.20 | none (input alone $0.32) |
| Output-heavy reasoning (10,000 / 40,000) | $0.5000 | $0.4200 | $0.6920 | $0.8400 | $1.3840 | 1.20 | 0.575 |
| Long-context review (500,000 / 8,000) | $2.1440 | $1.0800 | $1.1344 | $2.1600 | $2.2688 | 14.30 | 0.90 |

Standard tier, no caching, no grounding. Cache hits lower the input side for both models.

![Bar chart of break-even token ratios: Argon costs less up to 1.20× tokens now; from December 1 up to 0.575× for output-heavy requests, 0.90× for prompts over 200k, 0.10× for short turns, and never for an input-heavy agent step, with the 1.68× Artificial Analysis ratio marked](https://www.aifreeapi.com/posts/en/gemini-4-argon-vs-gemini-3-1-pro/img/break-even-token-ratio.webp)

Per request is still not per task. If 3.1 Pro needs a second attempt, another agent step, or a human fix where Argon gets it right the first time, multiply accordingly. In the output-heavy example after December 1 at `k = 1.68`, Argon costs $1.384 per attempt against $0.50 for 3.1 Pro, so it only comes out even if 3.1 Pro averages about 2.8 attempts per accepted answer ($1.384 ÷ $0.50). That is a realistic bar for some hard tasks and an unrealistic one for routine ones.

## Is Gemini 4 Argon better than Gemini 3.1 Pro? What the published numbers show

Google's own benchmark table for Argon compares it with other vendors' frontier models, not with 3.1 Pro. Google-published head-to-head material is limited to safety results and partner quotes:

- The [Argon model card](https://deepmind.google/models/model-cards/gemini-4-argon/) reports that Argon outperforms 3.1 Pro on multilingual and multimodal content safety and substantially reduces unjustified refusals, with text-to-text safety similar within confidence intervals.
- In the [Google Cloud launch post](https://cloud.google.com/blog/products/ai-machine-learning/gemini-4-argon-available-on-google-cloud), Harvey reports "substantial improvements over Gemini 3.1 Pro across our legal agent evaluations."

The independent numbers come from [Artificial Analysis](https://artificialanalysis.ai/models/gemini-4-argon), which ran both models at their highest reasoning setting. Figures as of October 14, 2026:

| Artificial Analysis measurement | Gemini 4 Argon (High) | Gemini 3.1 Pro Preview |
| --- | --- | --- |
| Intelligence Index (current version) | 52.6 | 29.7 |
| Cost per index task | $1.99 (introductory price) | $1.30 |
| Approx. output tokens across the index | ~112.8M | ~67.1M |
| AA-LCR long-context reasoning | 79.7% | 82.0% |

The token row divides Artificial Analysis's reported output spend by each model's output price ($1,128.47 ÷ $10 and $804.90 ÷ $12), which gives the ~1.68× ratio used above. Artificial Analysis also said in its launch post on X that Argon's cost per task will rise to $3.98 after the discount, roughly 3× the [3.1 Pro figure](https://artificialanalysis.ai/models/gemini-3-1-pro-preview).

Read these numbers with their limits. Artificial Analysis rescales its index between versions, so only same-version scores are comparable. Its cost model includes cache writes and its own price assumptions, so it will not match your invoice. And both models ran at high reasoning, while Argon's API default is medium, so the default-to-default token ratio has not been published.

## Measure your own token ratio with usage_metadata

The ratio that matters is the one on your prompts. Pick 20 to 50 real tasks that represent a workload, run them on both models through `generateContent`, and compare billed tokens and accepted answers. These calls are billed at normal rates.

```python
# pip install -U "google-genai>=2.30.1"
from pathlib import Path

from google import genai
from google.genai import types

# Reads GEMINI_API_KEY. 20-minute timeout because Argon can think for several minutes.
client = genai.Client(http_options=types.HttpOptions(timeout=1_200_000))

# USD per 1M tokens, Standard tier, prompts up to 200k tokens, as of October 14, 2026.
# For 3.1 Pro prompts over 200k, use in=4.00, cached=0.40, out=18.00.
PRO = {"in": 2.00, "cached": 0.20, "out": 12.00}
ARGON_NOW = {"in": 2.00, "cached": 0.10, "out": 10.00}   # through Nov 30, 2026
ARGON_DEC1 = {"in": 4.00, "cached": 0.20, "out": 20.00}  # from Dec 1, 2026


def run(model: str, prompt: str, level: str) -> dict:
    resp = client.models.generate_content(
        model=model,
        contents=prompt,
        config=types.GenerateContentConfig(
            max_output_tokens=65_536,
            thinking_config=types.ThinkingConfig(thinking_level=level),
        ),
    )
    u = resp.usage_metadata
    return {
        "in": u.prompt_token_count or 0,
        "cached": u.cached_content_token_count or 0,
        "out": (u.candidates_token_count or 0) + (u.thoughts_token_count or 0),
        "text": resp.text,  # keep it: grade quality, not just cost
    }


def cost(r: dict, p: dict) -> float:
    uncached = r["in"] - r["cached"]
    return (uncached * p["in"] + r["cached"] * p["cached"] + r["out"] * p["out"]) / 1e6


for path in sorted(Path("tasks").glob("*.txt")):  # one real task per file
    prompt = path.read_text()
    pro = run("gemini-3.1-pro-preview", prompt, "high")  # 3.1 Pro's default level
    for level in ("medium", "high"):                     # Argon's default is medium
        argon = run("gemini-4-argon", prompt, level)
        k = argon["out"] / max(pro["out"], 1)
        print(
            f"{path.name} argon-{level}: k={k:.2f} | "
            f"3.1 Pro ${cost(pro, PRO):.4f} | "
            f"Argon now ${cost(argon, ARGON_NOW):.4f} | "
            f"Argon Dec 1 ${cost(argon, ARGON_DEC1):.4f}"
        )
```

Then grade the saved answers the way you already judge 3.1 Pro output (tests passing, reviewer acceptance, extraction accuracy) and divide total cost by accepted answers for each model and level. If `medium` meets your bar, also try `low`. Google's own advice is to run evaluations at all three levels and keep the lowest one that meets your quality bar ([thinking guide](https://ai.google.dev/gemini-api/docs/thinking)).

## Migrating a generateContent codebase from gemini-3.1-pro-preview

Google's migration checklist on the [What's new in Gemini 4 Argon](https://ai.google.dev/gemini-api/docs/latest-model) page is written for the Interactions API. Most existing 3.1 Pro code calls `generateContent`, so here is the same change for that path.

### The code diff for a typical 3.1 Pro request

Upgrade the SDK first: `pip install -U "google-genai>=2.30.1"` for Python or `npm install "@google/genai@>=2.29.1"` for JavaScript. Older versions still call Argon but stop at 64K output tokens instead of continuing.

```diff
- client = genai.Client()
+ client = genai.Client(http_options=types.HttpOptions(timeout=1_200_000))  # 20 minutes

- cache = client.caches.create(
-     model="gemini-3.1-pro-preview",
-     config=types.CreateCachedContentConfig(contents=[policy_docs], ttl="3600s"),
- )
  response = client.models.generate_content(
-     model="gemini-3.1-pro-preview",
-     contents=question,
+     model="gemini-4-argon",
+     contents=[policy_docs, question],  # static content first, for implicit caching
      config=types.GenerateContentConfig(
-         cached_content=cache.name,
-         temperature=0.2,
-         top_p=0.9,
-         max_output_tokens=8192,
-         thinking_config=types.ThinkingConfig(thinking_budget=4096),
+         max_output_tokens=32_768,
+         thinking_config=types.ThinkingConfig(thinking_level="medium"),
      ),
  )
```

### Parameters that now fail, get ignored, or need new values

| What your 3.1 Pro code sends | What happens on Argon | What to do |
| --- | --- | --- |
| `gemini-3.1-pro-preview` or `gemini-3.1-pro-preview-customtools` | Argon's model page lists no customtools variant | Change to `gemini-4-argon`; retest agents that mix bash and custom tools |
| `thinking_budget` | Google Cloud docs: HTTP 400. Gemini API long-decode guide: a warning when sent alone (the field is ignored or mapped), an error when sent with `thinking_level` | Replace with `thinking_level` |
| `thinking_level="minimal"` | Not supported; returns an error | Use `low` |
| `temperature`, `top_p`, `top_k` | Ignored | Remove; for determinism use system instructions and `response_schema` |
| `frequency_penalty`, `presence_penalty`, `candidate_count`, prefilled model turns | On Google Cloud's removal list | Remove |
| `cached_content`, `caches.create`, `cachedContents` | Explicit caching is not supported | Remove; put static content first so implicit caching applies (prefixes of at least 4,096 tokens on the Gemini API, 6,144 on Google Cloud) |
| `max_output_tokens` below 32,768 | Thinking can use up the limit and cut the answer short | Raise to at least 32,768; above 65,536 for long decode |
| HTTP client timeout of 3–5 minutes | Hard prompts can run for several minutes | At least 15 minutes; the long-decode guide recommends 20 |
| Context-trimming logic based on `prompt_token_count` | With long decode, this field is summed across hops | Use `initial_prompt_token_count` |

Google documents these changes in [What's new in Gemini 4 Argon](https://ai.google.dev/gemini-api/docs/latest-model), the [generateContent long-decode guide](https://ai.google.dev/gemini-api/docs/generate-content/long-decode), and Google Cloud's [Get started with Gemini 4](https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/start/get-started-with-gemini-4) and [migration guide](https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/migrate).

Google's Gemini 3 developer guide already recommended keeping `temperature` at its default of 1.0 and removing low values, so most 3.1 Pro code should not depend on it. If a pipeline still sends a low temperature and relies on it for consistent output, test that path first: Argon ignores the value.

Budget for one billing change as well. Google Cloud's migration table says Argon bills every token the model processes, including thinking tokens and, when grounding is on, internal tool system instructions and function declarations, where 3.1 Pro billed a subset. Grounding with Google Search is still billed per query.

### Interactions API and Google Cloud differences

- **Interactions API:** long outputs use background execution. Set `background: true` and `max_output_tokens` above 65,536; servers run the hops and you join the text of every `model_output` step. With `background: false`, a `max_output_tokens` above 65,536 returns a 400 error. Keep multi-turn state on the server with `previous_interaction_id`. Client-side continuation is listed as coming soon ([long decode with the Interactions API](https://ai.google.dev/gemini-api/docs/long-decode)).
- **Google Cloud (Gemini Enterprise Agent Platform):** Argon runs on the global endpoint and the `us` and `eu` multi-regions. Long decode on `generateContent` works only on the `v1beta1` API, not `v1`. The SDK uses `v1beta1` unless you set `api_version` to `v1`; direct REST calls must use the `v1beta1` path.
- **Rate limits:** Google lists identical Batch enqueued-token limits for Argon and 3.1 Pro on each paid tier. Interactive limits are shown per project in AI Studio; see [reading active limits and diagnosing 429s](/en/posts/gemini-api-rate-limits-per-tier).

## Thinking level: Argon defaults to medium, 3.1 Pro defaults to high

Both models accept `low`, `medium`, and `high`. The difference is the default: `gemini-3.1-pro-preview` thinks at high unless told otherwise, and `gemini-4-argon` at medium ([thinking guide](https://ai.google.dev/gemini-api/docs/thinking)).

That has two consequences:

- **A model-ID swap also lowers reasoning effort.** If your 3.1 Pro code never set a level, it ran at high. After the swap it runs Argon at medium. A quick default-to-default comparison therefore compares two different effort settings. Test Argon at medium and high against your current 3.1 Pro setup.
- **Control cost with the level, not with `max_output_tokens`.** Google warns that Argon can spend more of the output limit on thinking than earlier models. A tight `max_output_tokens` does not make it think less; it truncates the answer and still bills the thinking tokens. Lower `thinking_level` instead.

Google describes `medium` as the right level for most tasks, including complex code and agentic work, `high` for the hardest reasoning, math, and science, and `low` for simpler, cost-sensitive work where quality may drop on hard tasks. For how `thinking_level` and the older `thinking_budget` map across Gemini models, see the [Gemini API thinking level guide](/en/posts/gemini-api-thinking-level).

## The shared 1M token limit and the continuation protocol

### How the unified 1M window differs from 3.1 Pro's limits

Gemini 3.1 Pro has two separate budgets: 1,048,576 input tokens and 65,536 output tokens. Argon has one window of 1,048,576 tokens shared by input, thinking, function calls, and the final answer ([long context guide](https://ai.google.dev/gemini-api/docs/long-context)). If your input plus `max_output_tokens` exceeds the window, the API caps output at whatever space is left.

That cuts both ways:

- **Argon can write far longer answers.** With long decode, one response can run up to 1,048,576 tokens minus your input. On 3.1 Pro, a single response tops out at 65,536 tokens (see the [Gemini 3.1 Pro output limit guide](/en/posts/gemini-3-1-pro-output-limit)).
- **Huge prompts leave Argon less room.** A 1,000,000-token prompt leaves Argon 48,576 tokens for thinking and answer combined, while 3.1 Pro would still allow up to 65,536 output tokens on top of the same input.

### Long decode with generateContent: the continuation_token loop

Changing the model ID does not turn long decode on. Without extra setup, Argon's output stops at 64K tokens on streaming and SDK calls and at 32K tokens on non-streaming REST calls ([generateContent long-decode guide](https://ai.google.dev/gemini-api/docs/generate-content/long-decode)). The protocol works in hops:

1. A hop returns up to 65,536 tokens (32,768 for non-streaming REST).
2. If the model reaches that cap with budget left, the response ends with `finish_reason: CONTINUATION` and a `continuation_token`.
3. You send **the same request again** (same `contents`, `system_instruction`, `tools`, and `generation_config`, including the same `max_output_tokens`) plus only the latest token. Do not append the partial output; the token carries the model's state.
4. Stop on any other finish reason. `MAX_TOKENS` means the whole `max_output_tokens` budget, which counts thinking and output across all hops, is used up.

A hop can come back with empty text because it was spent entirely on thinking. That is normal; the answer arrives in later hops.

With `google-genai` 2.30.1 or `@google/genai` 2.29.1 and later, automatic continuation is on by default, so you only raise `max_output_tokens`:

```python
from google import genai
from google.genai import types

client = genai.Client(http_options=types.HttpOptions(timeout=1_200_000))

response = client.models.generate_content(
    model="gemini-4-argon",
    contents="Write a complete, rigorous proof of the prime number theorem.",
    config=types.GenerateContentConfig(
        max_output_tokens=262_144,  # total thinking + output across all hops
        thinking_config=types.ThinkingConfig(thinking_level="high"),
    ),
)
print(response.text)
print("Finish reason:", response.candidates[0].finish_reason)
print("Prompt size:", response.usage_metadata.initial_prompt_token_count)
print("Billed tokens:", response.usage_metadata.total_token_count)
```

If you call REST directly, write the loop yourself: send `continuationToken` at the top level of the request body on each repeat call and keep going while `finishReason` is `CONTINUATION`. A non-streaming REST call with `maxOutputTokens` above 32,768 and no token returns a 400 error. Each request has a 20-minute time limit, so set your HTTP read timeout to match. For diagnosing timeouts on long Pro requests, see [Fix Gemini 3.1 Pro Timeout Errors](/en/posts/gemini-3-1-pro-timeout-fix). Google's own OpenAI compatibility endpoint does not support long decode, so output there stops at the per-request cap.

### What long decode costs, hop by hop

You pay for every token in every hop, including hops that contain only thinking. Each hop also resends your prompt plus everything generated so far as input. Implicit caching discounts that repeated input by 95%, but the cache expires after 15 to 20 minutes without use.

![Four long-decode hops for a 1,000-token prompt producing 200,000 tokens: input sent grows from 1,000 to 197,608 tokens, three hops end in CONTINUATION and the fourth in STOP, summed input 397,216 tokens, about $2.04 now and $4.08 from December 1](https://www.aifreeapi.com/posts/en/gemini-4-argon-vs-gemini-3-1-pro/img/long-decode-hops.webp)

Google's long-decode guide uses this example: a 1,000-token prompt that produces 200,000 tokens of thinking and output takes four SDK hops, and the summed input is 397,216 tokens. Priced at Argon's rates, assuming every repeated hop hits the cache:

- **Through November 30:** 200,000 × $10/1M = $2.00 for output, plus about $0.04 of input (1,000 tokens at $2/1M and 396,216 cached tokens at $0.10/1M), so about **$2.04**.
- **From December 1:** the same request costs about **$4.08**.
- **If no hop hits the cache** (for example, after long pauses), all 397,216 input tokens are billed at the full rate: about $2.79 now and $5.59 after December 1.

Gemini 3.1 Pro cannot produce a 200,000-token answer in one response at any price.

Two accounting traps follow from the hop structure. `prompt_token_count` adds up the input of every hop, so it is not your context size: use `initial_prompt_token_count` from the SDK, or the first hop's `promptTokenCount` in REST, before your agent framework decides to trim history. Proxies that call REST must add each usage field across hops themselves. On failures, a non-streaming hop that fails costs nothing, and a dropped stream costs nothing before 32K tokens; after that you pay up to the last checkpoint.

Long decode is not for chat, Q&A, summarization, short-turn tool-calling agents, latency-sensitive requests, or prompts near the 1M limit. Google recommends it for hard math, science, formal proofs, and the hardest coding tasks.

## Where Gemini 3.1 Pro is still the better pick

These cases follow from the documented differences and the price math above; none rests on a published head-to-head quality test.

- **You depend on explicit caching.** If you cache a large prefix once and ask many questions against it over hours, Argon's implicit cache is no replacement: there is no cache object to create or keep alive, and Google's long-decode guide says it expires after 15 to 20 minutes without use. On 3.1 Pro you pay $4.50 per 1M tokens per hour of storage for that control. For how the two caching modes work, see the [Gemini API context caching guide](/en/posts/gemini-api-context-caching-reduce-cost).
- **Your requests are input-heavy and stay under 200k tokens, and you will still run them after December 1.** When input is more than six times the output, Argon's input charge alone exceeds 3.1 Pro's whole request.
- **Your prompts approach 1M tokens and still need a sizable answer.** 3.1 Pro keeps its 65,536-token output budget separate from input; Argon does not.
- **Latency matters more than depth.** Google says Argon thinks longer than Gemini 3.x models on hard problems and recommends 20-minute client timeouts. Measure response times before moving interactive paths.
- **Your pipeline is tuned around `thinking_budget`, a low temperature, or the `-customtools` endpoint.** None carries over unchanged. Stay until you have retuned and retested.
- **Your workload is long-context retrieval and reasoning.** On Artificial Analysis's AA-LCR benchmark, 3.1 Pro scored 82.0% to Argon's 79.7%. The gap is small, but it points the other way from every other result, so test before switching document-heavy work.

Argon is the better pick for hard coding, math, science, and agent tasks where a higher first-attempt success rate saves retries, for any single answer longer than 65,536 tokens, for prompts over 200k tokens during the introductory window, and when you need features 3.1 Pro lacks: generally available agentic video understanding, computer use (in preview), and file search through the API rather than AI Studio only ([Argon model page](https://ai.google.dev/gemini-api/docs/models/gemini-4-argon)).

Whichever way you go, plan the next review for late November. Staying on 3.1 Pro is a decision you may need to revisit: it is a preview model, and Google Cloud's documentation recommends migrating from `gemini-3.1-pro-preview` to `gemini-4-argon`.

## Gemini 4 Argon and Gemini 3.1 Pro: FAQ

### Is Gemini 4 Argon out in the Gemini API?

Yes. `gemini-4-argon` became a stable, generally available model in the Gemini API on October 13, 2026 ([changelog](https://ai.google.dev/gemini-api/docs/changelog)). It requires the paid tier. Access in the Gemini app (Google AI Pro and Ultra) and in Antigravity (Ultra) comes with those subscriptions and is separate from API billing. For how Argon compares with Anthropic's models, see [Gemini 4 Argon vs Claude Opus 5.5 vs Sonnet 5.5](/en/posts/gemini-4-argon-vs-claude-opus-5-5-vs-sonnet-5-5).

### How much does Gemini 3.1 Pro cost in the API?

As of October 14, 2026, `gemini-3.1-pro-preview` costs $2 per 1M input tokens and $12 per 1M output tokens (thinking included) for prompts up to 200k tokens, and $4 / $18 above that. There is no API free tier. The Argon launch did not change these prices.

### Is gemini-3.1-pro-preview being shut down?

No shutdown date has been announced as of October 14, 2026 ([deprecations page](https://ai.google.dev/gemini-api/docs/deprecations)). It is still a preview model, though, and Google has redirected a preview ID before: since March 9, 2026, `gemini-3-pro-preview` points to 3.1 Pro. Google has also said more Gemini 4 models are coming, without dates. Check the deprecations page before you commit to a long stay.

### Can I keep using explicit context caching with Argon?

No. Argon supports implicit caching only. Remove `caches.create` and `cached_content`, place static content at the start of the prompt, and check `cached_content_token_count` in the response to confirm hits. Cached input costs $0.10 per 1M tokens through November 30 and $0.20 from December 1.

### Can I call gemini-4-argon through an OpenAI-compatible endpoint?

Yes, with limits. Google's OpenAI compatibility endpoint works but does not support long decode, so output stops at the per-request cap. Third-party gateways also list the model: [laozhang.ai](https://api.laozhang.ai/) offers `gemini-4-argon` at $2 / $10 per 1M tokens through `/v1/chat/completions` and a Gemini-style `generateContent` endpoint, useful if you want one key across vendors. Its post-introductory price has not been announced, and its documentation does not cover long decode, background execution, or implicit caching, so use Google's API directly for those.