How to Set Thinking Levels for Gemini 4 Argon

Gemini 4 Argon gives you three thinking levels that control how much the model reasons before it answers. Low keeps latency and cost down. Medium balances most everyday work. High digs deeper for hard problems. The default is medium.

You set the level in the Gemini API or Google AI Studio. Higher levels spend more tokens on internal reasoning, which can improve results on complex coding, math, or multi-step tasks. Lower levels finish faster and cost less.

What each thinking level does

Google documents the levels this way:

• Low: Uses the fewest tokens and has the lowest latency. Best for simple classification, routing, extraction, or light analysis. Quality can drop on difficult tasks.
• Medium (default): Balanced token use. Recommended for most work, including complex code and agentic flows.
• High: Uses the most tokens and has the slowest time to first token. Choose it for complex reasoning, hard math and science, multi-file debugging, or the toughest agent tasks. It pairs well with long decode when you need very long outputs.

Thinking cannot be turned off. Setting an unsupported value such as “minimal” returns an error. Sampling parameters like temperature are ignored on Argon.

How to set the level in the API

Install or update the Google GenAI SDK first.

pip install -U "google-genai>=2.30.1"

Then pass the level in the config:

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
    model="gemini-4-argon",
    contents="Analyze this code for race conditions and rewrite the locks.",
    config=types.GenerateContentConfig(
        max_output_tokens=65536,
        thinking_config=types.ThinkingConfig(thinking_level="high"),
    ),
)
print(response.text)

In the Interactions API the field is the same. For OpenAI-compatible endpoints use reasoning_effort with the matching values (low, medium, high).

In Google AI Studio you select the thinking level in the model controls when the model is Gemini 4 Argon.

Practical choices by task

Start with these defaults and measure:

• Extraction, classification, or simple chat: low.
• Interactive coding, most agent work, or general analysis: medium.
• Multi-file root-cause debugging, formal proofs, security reviews, or long architecture design: high.
• Very long outputs (near the 1M token limit): high plus long decode continuation.

Run the same prompt at all three levels with a high max_output_tokens so the limit does not cut the answer short. Then pick the lowest level that meets your quality bar. This keeps cost and latency in check.

Remember that thinking tokens count toward the output limit and the bill. Introductory pricing through November 30, 2026 is $2 per million input tokens and $10 per million output tokens. After that the rates rise to $4 and $20. Cached input stays heavily discounted.

Tips for better results

Set max_output_tokens high enough for the thinking plus the final answer. A low cap can leave you with an empty or truncated response after the model has already spent tokens thinking.

For agentic or multi-step work, medium is usually enough. Move to high only when medium fails on the hard cases.

Pair high thinking with long decode when you need outputs that exceed the single-request 65,536 token cap. The SDK handles continuation automatically in recent versions.

Test on your own data. Published benchmarks used the high setting, so your mileage on medium or low will differ.

For more on access and overall setup, see our guide to getting started with Gemini 4 Argon.

Conclusion

Thinking levels give you direct control over Gemini 4 Argon’s quality, speed, and cost. Start with medium for most work, drop to low for simple jobs, and raise to high only for the hardest reasoning. Measure on your prompts, keep the output limit high enough, and you will get better results without overspending tokens.

Sources

• Google AI for Developers: What’s new in Gemini 4 Argon (generateContent)
• Google AI Studio: Gemini 4 Argon Developer Guide
• Gemini API thinking documentation