Why You Should Set Gemini 4 Argon Thinking Levels Per Task

Gemini 4 Argon thinking levels decide how long the model reasons before it answers, and you pay for every token of that reasoning. Most teams leave the default and move on, then wonder why a ticket classifier costs like a research assistant. This article makes the case for choosing the level per task type, with a config file to copy and a harness to test it on your own prompts.

Gemini 4 Argon thinking levels change your bill and your latency

Gemini 4 Argon (gemini-4-argon, generally available since October 13, 2026) supports three levels: low, medium and high. The default is medium, so a request with no setting still thinks.

Thinking is billed as output. The pricing page lists $10.00 per million output tokens, thinking included, through November 30, 2026, and $20.00 from December 1. So 100,000 thinking tokens cost $1.00 today and $2.00 in December.

The thinking guide says thinking tokens are billed in full even though only a summary comes back. Reasoning also shares max_output_tokens with the answer, so a model that over-thinks can eat your cap and leave a truncated reply, and you still pay for the thinking.

What each thinking level is for

Google's guidance for Argon is short:

• low: fewest tokens and lowest latency, for simple, cost-sensitive work. Quality can drop on hard tasks.
• medium: balanced, and the recommended starting point for most tasks, including complex code and agents.
• high: most tokens and the slowest first token, for hard math, science, and difficult code or agent tasks.

Since Google says medium handles complex code and agents, a blanket high buys headroom many calls won't use.

Set the level per task in config

Keep the level in data, not scattered through call sites. Then changing one task is a one-line diff you can review.

# thinking_levels.yaml
default: medium
tasks:
  classify_ticket: low
  extract_invoice_fields: low
  draft_customer_reply: medium
  review_pull_request: medium
  debug_failing_test: high
  plan_schema_migration: high

The task names are examples. Install with pip install -U "google-genai>=2.30.1" pyyaml, the SDK version the Argon docs use.

import yaml
from google import genai
from google.genai import types

client = genai.Client()

with open("thinking_levels.yaml") as f:
    LEVELS = yaml.safe_load(f)

def ask(task: str, prompt: str):
    level = LEVELS["tasks"].get(task, LEVELS["default"])
    return client.models.generate_content(
        model="gemini-4-argon",
        contents=prompt,
        config=types.GenerateContentConfig(
            max_output_tokens=32768,
            thinking_config=types.ThinkingConfig(thinking_level=level),
        ),
    )

ask looks up the task, falls back to medium for anything unlisted, and passes the level through ThinkingConfig. The generous output cap keeps reasoning from starving the answer.

Measure the trade-off on your own tasks

Google's advice is to run evals at all three levels with a high output cap so answers aren't cut short, then pick the lowest level that meets your quality bar. This harness records that for each call. It reuses client and types from the previous snippet.

import time

INPUT_USD_PER_M = 2.00    # standard tier through 2026-11-30, 4.00 after
OUTPUT_USD_PER_M = 10.00  # thinking tokens bill at this rate, 20.00 after

def trial(prompt: str, expected: str, level: str) -> dict:
    start = time.perf_counter()
    response = client.models.generate_content(
        model="gemini-4-argon",
        contents=prompt,
        config=types.GenerateContentConfig(
            max_output_tokens=32768,
            thinking_config=types.ThinkingConfig(thinking_level=level),
        ),
    )
    usage = response.usage_metadata
    thinking = usage.thoughts_token_count or 0
    answer = usage.candidates_token_count or 0
    usd = ((usage.prompt_token_count or 0) * INPUT_USD_PER_M
           + (thinking + answer) * OUTPUT_USD_PER_M) / 1_000_000
    return {
        "level": level,
        "seconds": round(time.perf_counter() - start, 2),
        "thinking_tokens": thinking,
        "answer_tokens": answer,
        "usd": round(usd, 5),
        "passed": grade(response.text or "", expected),
    }

for prompt, expected in cases:  # real prompts from one task type
    for level in ("low", "medium", "high"):
        print(trial(prompt, expected, level))

grade is your own check: exact match for a classifier, a schema validator for extraction, a test run for code. Run 20 to 50 real prompts per task type and read thinking_tokens next to passed. Keep the cheapest level whose pass rate clears your bar.

The strongest objection: just run everything on high

The objection is fair: quality beats token spend, and per-task routing is one more thing to maintain. If you make a few hundred calls a day, set medium, ship, and skip all of this.

But high costs more than money: it has the slowest first token, which users feel in anything interactive. A few lines of YAML is a small price once volume grows. The harness also guards the other side: low can lose quality on hard tasks, so a task moves down only when its pass rate holds.

Gotchas

• Old thinking_budget code still works on Argon: it maps to the nearest thinking_level and returns a warning. Inherited code may already be choosing a level for you, so replace it with an explicit one.
• The December 1 price change doubles the dollar value of every thinking token you trim. Re-run the harness then.
• Argon has no minimal level and no off switch, so for trivial, high-volume calls a smaller model may beat low. Worth a test.
• Don't set a small max_output_tokens to limit thinking. A cap hit mid-reasoning can give a truncated or empty answer, and the thinking is still billed.

Pick your three highest-volume calls this week, run them at all three levels, and write the winners into the YAML. In production, the thinking level is a cost and latency setting like any other, so keep it in config where you can review, test and change it.