Gemini 4 Thinking Levels: How to Choose low, medium, high or xhigh
Which thinking levels each Gemini 4 model supports, where the parameter goes in each API, what each level costs per task, results from our test calls, and a procedure for picking the lowest level that passes.
Gemini 4 Carbon and Argon accept low, medium and high, with medium as the default. Gemini 4 Neon and Hydrogen accept low, medium, high and xhigh, with high as the default. None of them document minimal, and none can turn thinking off. Pick a level by running your own pass/fail tasks at every supported level and keeping the lowest one that passes; use xhigh only when high fails. The per-token price is the same at every level. What changes is how many thinking tokens the model spends, and that drives both cost and wait time.
On Artificial Analysis’s benchmark tasks, moving Hydrogen from low to xhigh raised the average cost per task about elevenfold ($0.29 to $3.16), and moving Neon across the same range raised it about ninefold. The top step bought the fewest points on both models. In our own small test through Ofox, Hydrogen at xhigh used about three times the thinking tokens of high and answered the same prompts no better.
Ofox publishes this article. Sources:
- Google’s documentation: level support, defaults and parameter names, from Google’s thinking guide, the per-model guides and the OpenAI compatibility page, checked on November 19, 2026.
- Artificial Analysis (AA): per-level benchmark numbers from its model pages, read the same day. Third-party figures, not ours.
- Our runs: 56 requests on 2026-11-19 to
google/gemini-4-hydrogenandgoogle/gemini-4-argonthrough Ofox. These are the only results we measured.
As of that date, Gemini 4 Carbon and Neon are not available on Ofox. Everything said about them comes from Google or AA.
Which levels each Gemini 4 model supports
| Model | Model ID | Supported levels | Default | On Ofox (2026-11-19) |
|---|---|---|---|---|
| Gemini 4 Carbon | gemini-4-carbon | low, medium, high | medium | No |
| Gemini 4 Argon | gemini-4-argon | low, medium, high | medium | Yes, google/gemini-4-argon |
| Gemini 4 Neon | gemini-4-neon | low, medium, high, xhigh | high | No |
| Gemini 4 Hydrogen | gemini-4-hydrogen | low, medium, high, xhigh | high | Yes, google/gemini-4-hydrogen |
Source: Google’s thinking guide and the Neon, Hydrogen, Carbon and Argon guides. Ofox availability: authenticated GET /v1/models, 2026-11-19.
Google’s migration checklists put the split in one line: “Carbon and Argon default to medium and cap at high.” The Neon and Hydrogen guides add that both reject minimal with an error. The same name also sits at a different height on each ladder: high is the top setting on Carbon and Argon but the second-highest on Neon and Hydrogen.
Google’s descriptions for Neon and Hydrogen:
| Level | Google’s description | Google’s suggested use |
|---|---|---|
low | Fewest tokens, lowest latency | Fast chat, high-throughput processing; “still capable on agentic tasks” |
medium | Lower token use, faster responses | Interactive coding, live UI prototyping, latency-sensitive tool calls |
high | Balanced intelligence and speed | Default for complex coding, agents, tool calling, multimodal work |
xhigh | Most tokens, deepest reasoning | Hard multi-step problems where high falls short |
For Carbon and Argon the descriptions shift up a notch: medium is “recommended for most tasks, including complex code and agentic use cases,” and high is for the hardest reasoning, math, science and agent work. The Carbon guide warns that at low, “quality can drop on hard tasks.”
How to send the level in each API
The parameter has a different name and location in each API. A level in the wrong spot either fails validation or never reaches the model.
| API | Where the level goes | Where thinking tokens are reported |
|---|---|---|
| Interactions API (Google) | generation_config.thinking_level | usage.total_thought_tokens |
generateContent REST | generationConfig.thinkingConfig.thinkingLevel | usageMetadata.thoughtsTokenCount |
generateContent Python SDK | GenerateContentConfig(thinking_config=ThinkingConfig(thinking_level=...)) | usage_metadata.thoughts_token_count |
| OpenAI-compatible Chat Completions | reasoning_effort | usage.completion_tokens_details.reasoning_tokens |
Values are lowercase strings everywhere: "low", "medium", "high", "xhigh".
Interactions API (Google direct)
The Neon and Hydrogen guides use this shape:
curl "https://generativelanguage.googleapis.com/v1beta/interactions" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "gemini-4-hydrogen",
"input": "Audit this retry queue for race conditions.",
"generation_config": { "thinking_level": "xhigh" }
}'
Ofox’s Gemini-native API reference lists generateContent, streamGenerateContent, cached contents and model listing, but no Interactions endpoint, so send Interactions requests to Google directly.
generateContent (Google or Ofox)
This is the request shape we tested. On Ofox the base is https://api.ofox.ai/gemini, the key goes in x-goog-api-key, and the model path carries the google/ prefix, per the Generate Content reference and Ofox’s Gemini thinking settings page.
curl "https://api.ofox.ai/gemini/v1beta/models/google/gemini-4-hydrogen:generateContent" \
-H "x-goog-api-key: $OFOX_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"contents": [{"role": "user", "parts": [{"text": "What is the chemical symbol for tungsten? Reply with the symbol only."}]}],
"generationConfig": {
"thinkingConfig": {"thinkingLevel": "low"},
"maxOutputTokens": 32768
}
}'
For Google directly, use https://generativelanguage.googleapis.com/v1beta/models/gemini-4-hydrogen:generateContent with your Gemini key. thinkingConfig must sit inside generationConfig; at the top level of the body it never reaches the model.
OpenAI-compatible route
Google’s compatibility page maps reasoning_effort onto Gemini 4 levels:
reasoning_effort | Gemini 4 thinking_level |
|---|---|
minimal | low |
low | low |
medium | medium |
high | high |
xhigh | xhigh (Neon and Hydrogen only) |
If you leave reasoning_effort out, the model uses its default. Google notes that reasoning_effort and thinking_level overlap, “so they can’t be used at the same time.” Through Ofox:
from openai import OpenAI
import os
client = OpenAI(base_url="https://api.ofox.ai/v1", api_key=os.environ["OFOX_API_KEY"])
resp = client.chat.completions.create(
model="google/gemini-4-hydrogen",
reasoning_effort="xhigh",
messages=[{"role": "user", "content": "..."}],
)
print(resp.usage.completion_tokens_details.reasoning_tokens)
The Ofox model pages for Hydrogen and Argon list both openai and gemini protocols; current prices are on those pages.
Remove thinkingBudget
thinkingBudget was the Gemini 2.5 control. Google’s generateContent thinking guide says that on Gemini 4 it is deprecated: “If passed alone, it maps to the nearest thinkingLevel … and returns a warning; sending thinkingBudget and thinkingLevel together returns a 400 error.” Through Ofox, even the budget-only form was rejected (details in the test section). Delete thinkingBudget from any config you carry over and set thinkingLevel instead.
Leave room in max_output_tokens
Thinking tokens and the visible answer share one output cap. Google says that when the model hits the cap while still reasoning, it stops with MAX_TOKENS and “returns truncated or empty output (while still billing for any thinking tokens generated).” To spend less, lower the level, not the cap. Google’s Neon and Hydrogen guides suggest keeping the 65,536 default; the Carbon guide recommends at least 32,768. Our runs used 32,768 and none was truncated.
What each level costs in tokens, time and quality
Per-token prices are identical across levels, so the useful comparison is per task. AA runs its Intelligence Index tasks at each level separately and reports average cost per task at Google’s list prices. Figures below are from AA’s pages on November 19, 2026.
Neon (all four levels)
| Level | AA Intelligence Index | Cost per task | Time per task | Output tokens per task | Hallucination rate |
|---|---|---|---|---|---|
low | 44.1 | $0.75 | 3.7 min | ~21,700 | 18.8% |
medium | 54.9 | $1.90 | 8.3 min | ~50,000 | 16.2% |
high (default) | 59.6 | $3.74 | 14.8 min | ~90,200 | 13.9% |
xhigh | 61.4 | $6.44 | 21.5 min | ~141,600 | 14.4% |
Each step up costs more and buys less: low to medium adds 10.8 points for $1.16 per task, medium to high 4.8 points for $1.84, and high to xhigh 1.8 points for $2.70, with no hallucination improvement.
Hydrogen (all four levels)
| Level | AA Intelligence Index | Cost per task | Time per task | Output tokens per task | Hallucination rate |
|---|---|---|---|---|---|
low | 26.9 | $0.29 | not shown | not shown | not shown |
medium | 41.2 | $0.80 | not shown | not shown | not shown |
high (default) | 50.8 | $1.87 | 8.6 min | ~85,000 | 8.7% |
xhigh | 53.9 | $3.16 | 15.2 min | ~154,400 | 8.5% |
AA’s data gave index and cost for Hydrogen low and medium but not time, tokens or hallucination.
Hydrogen drops off much faster at the bottom than Neon: low scores 24 points below the default, against 15.5 for Neon, so on Hydrogen low is a real downgrade rather than a free speedup. From high to xhigh, Hydrogen gains 3.1 points for about 69% more cost and 77% more time.
Carbon (three levels)
AA prices Carbon at the rate that starts December 1 ($4/$20 per million tokens). Through November 30, Google charges $2/$10. All of Carbon’s token rates, including cached input, halve, so the November column is AA’s figure divided by two (our arithmetic).
| Level | AA Intelligence Index | Cost per task (Dec rate) | Cost per task (Nov rate, our halving) | Time per task | Hallucination rate | Omniscience accuracy |
|---|---|---|---|---|---|---|
low | 54.2 | $7.19 | $3.59 | 30.4 min | 19.8% | 49.2% |
medium (default) | 58.3 | $6.59 | $3.29 | 29.6 min | 4.2% | 48.9% |
high | 60.0 | $7.76 | $3.88 | 37.2 min | 11.4% | 58.3% |
Carbon breaks the pattern. On AA’s tasks, low cost more per task than medium, took about as long, scored 4 points lower, and hallucinated nearly five times as often. Fewer thinking tokens per turn do not guarantee a cheaper task when an agent needs more turns to finish. AA does not explain the result, so treat it as one benchmark, but do not assume low saves money on Carbon.
Argon (AA lists two levels)
AA’s Argon page lists high and medium only. Its unsuffixed Argon entry, the one shown as the headline, is labelled “Gemini 4 Argon (High)”. AA prices Argon at the current $2/$10 rate.
| Level | AA Intelligence Index | Cost per task (Nov rate) | Cost per task (Dec rate, our doubling) | Time per task | Hallucination rate | Omniscience accuracy |
|---|---|---|---|---|---|---|
medium (default) | 47.6 | $4.31 | $8.63 | 29.1 min | 15.4% | 49.0% |
high | 50.4 | $4.97 | $9.95 | 29.8 min | 4.3% | 48.3% |
On AA’s tasks, Argon high cost 15% more than medium, took about the same time, scored 2.8 points higher and cut the hallucination rate from 15.4% to 4.3%. That makes high worth testing first on Argon if factual errors are expensive for you. The low 4.3% rate belongs to high; an Argon call with no level set runs at medium. For the December change, see our Carbon and Argon December price-change guide; for a Neon cost model, see Gemini 4 Neon pricing by thinking level.
Why default-vs-default comparisons mislead
Many Gemini 4 comparisons swap the model ID and leave the level unset. That compares different positions on different ladders.
- The defaults sit at different heights. Neon and Hydrogen run at their second-highest level by default; Carbon and Argon at their middle one. Neon vs Carbon at defaults is Neon
high(59.6, $3.74) against Carbonmedium(58.3, $6.59 at the December rate). Our Neon vs Carbon comparison shows how the verdict depends on the pairing. - Headline numbers usually use the top level. AA’s model pages lead with Neon and Hydrogen at
xhighand Carbon and Argon athigh. Google’s evaluation methodology documents, linked from each model card, say results are run “with the highest thinking settings unless indicated otherwise.” Code that never sets a level is not running the configuration behind those scores. - Model and level are one decision. On AA’s numbers, Neon
medium(54.9, $1.90) scored above Hydrogenxhigh(53.9, $3.16) at 60% of the cost, and Neonlow(44.1, $0.75) above Hydrogenmedium(41.2, $0.80). Availability can matter as much: Neon is paid-tier only and not on Ofox, while Hydrogen has a Google free tier and is on Ofox.
A fair comparison sets the level explicitly on both sides, raises max_output_tokens so neither side is truncated, and records thinking tokens, latency and pass/fail per run.
What happened when we ran the levels through Ofox
We wanted to check two things: whether the level reaches the model through Ofox, and how much it changes token use on ordinary prompts.
Setup (2026-11-19). Ofox’s Gemini-native route, POST https://api.ofox.ai/gemini/v1beta/models/{model}:generateContent, with generationConfig.thinkingConfig.thinkingLevel set and maxOutputTokens: 32768. google/gemini-4-hydrogen at low, medium, high and xhigh; google/gemini-4-argon at low, medium and high. Each level ran twice on three prompts, four requests at a time. We read usageMetadata.thoughtsTokenCount and candidatesTokenCount and timed each request end to end from our client.
The prompts:
- Easy fact: the chemical symbol for tungsten (expected
W). - Multi-step arithmetic: pens at $3, notebooks at $7, exactly $100 spent, at least one of each, strictly more pens than notebooks; count the combinations. The answer is 3: (31, 1), (24, 4) and (17, 7). (10, 10) is a tie and fails “strictly more.”
- Short coding task: write
merge_intervalsso that it merges touching intervals and does not mutate its input, graded against 9 hidden test cases in a sandboxed subprocess.
Hydrogen results
Thinking tokens per run (rep 1, rep 2):
| Prompt | low | medium | high | xhigh |
|---|---|---|---|---|
| Easy fact | 45, 78 | 46, 58 | 84, 87 | 106, 112 |
| Arithmetic | 522, 523 | 669, 715 | 690, 786 | 1,734, 1,687 |
| Coding | 424, 541 | 672, 572 | 426, 389 | 2,119, 1,987 |
| Total (6 runs) | 2,133 | 2,732 | 2,462 | 7,745 |
| Summed latency | 50.1 s | 45.0 s | 44.0 s | 80.3 s |
| Correct | 6/6 | 6/6 | 6/6 | 6/6 |
All 24 Hydrogen answers were correct, and every coding answer passed 9 of 9 tests. xhigh used about 3.1 times the thinking tokens of high overall, and 5 times on the coding prompt, for the same passing code. low, medium and high were hard to tell apart: totals ranged from 2,133 to 2,732 and did not rise in order. Even low produced thinking tokens on the one-word question, consistent with Google’s statement that thinking cannot be turned off.
Argon results
Thinking tokens per run:
| Prompt | low | medium | high |
|---|---|---|---|
| Easy fact | none, none | none, none | 105, 105 |
| Arithmetic | none, none | 398, 367 | 1,071, 895 |
| Coding | none, none | none, none | 739, 890 |
| Correct (all prompts) | 6/6 | 6/6 | 6/6 |
“None” means the response had no thoughtsTokenCount field and no thought parts. Ofox’s thinking page says this is what you see when the model skips thinking on a simple request. Argon at low reported no thinking on any prompt; at medium only on the arithmetic prompt; at high on all three. Every answer was still correct. On the arithmetic prompt at low, Argon worked the problem step by step in its visible answer instead (525 to 637 output tokens), so zero thinking tokens did not mean zero reasoning.
Latency did not follow token counts on Argon. The two medium arithmetic runs took 35.6 s and 59.9 s, the high runs 27.5 s and 25.0 s. With two samples and four requests in flight, read this as a queueing effect, not a property of the level.
Off-list levels: accepted, not supported
Two values Google documents as unsupported returned HTTP 200 through Ofox: thinkingLevel: "minimal" on Hydrogen and "xhigh" on Argon. Nothing in the responses says which level was applied. We ran each twice on the arithmetic prompt:
| Request | Thinking tokens | Closest documented level |
|---|---|---|
Hydrogen minimal | 463, 481 | Hydrogen low: 522, 523 |
Argon xhigh | 1,238, 1,141 | Argon high: 1,071, 895 |
In our runs, usage looked like Hydrogen low and Argon high, which matches how Google’s compatibility table maps minimal. That is an observation of one route on one day, with two samples each, and it is not documented behaviour. A direct Google request may reject both values. Don’t rely on it: map minimal to low, and xhigh to high on Carbon and Argon, in your own code. Our Gemini 4 API errors guide has the single-run results on other prompts.
thinkingBudget through Ofox
We sent thinkingBudget: 1024 six times on 2026-11-19: on Hydrogen three times alone and twice with thinkingLevel: "low", and on Argon once alone. All six returned HTTP 400, while level-only requests sent just before and after returned 200.
- Argon returned an Ofox validation message: “Gemini 4 Argon does not support a thinking token budget. Use low, medium or high reasoning effort instead.”
- Hydrogen returned
"The service is temporarily unavailable. Please try again later."withtype: "api_error", in every case. That reads like a gateway or upstream failure, not a validation error, and the response doesn’t say which layer produced it.
This is how Ofox’s Gemini-native route behaved on that date, not Google’s documented behaviour. Google documents a 400 only when budget and level are sent together; a budget sent alone should map to a level with a warning. We did not test Google directly. In practice: if you see that “temporarily unavailable” 400 on a Gemini 4 request through Ofox, check for a leftover thinkingBudget before retrying.
The OpenAI-compatible route
On the arithmetic prompt (one run each), reasoning_effort: "low" returned 598 reasoning_tokens and "xhigh" returned 1,492. The level reaches the model on this route too.
Two response details worth handling
- Thought parts without
includeThoughts. Observed via Ofox on 2026-11-19: every native response that reported thinking also included a part marked"thought": truecontaining a thought summary, although we never setincludeThoughts. Google describes summaries as opt-in. We did not check Google direct. If your code joins every text part, skip parts wherethoughtis true or the summary leaks into your answer. - Usage counts differ from visible text. Our one-character answers reported a
candidatesTokenCountof 5. Measure from usage fields.
Limits of this test
- Each level ran 2 times on 3 easy-to-medium prompts. That shows whether a level reaches the model and the size of its token effect. It cannot rank quality: the prompts were too easy to separate the levels on correctness.
- Latency is end to end from our client, with 4 concurrent requests, through Ofox.
- We measured nothing on Carbon or Neon, and nothing on Google’s API directly.
- At Google’s list prices, the successful requests work out to about $0.26 by our usage arithmetic. Ofox bills at the rates on each model page.
Raw requests and responses (key redacted) and scripts are kept in our research files for this article.
A procedure for choosing a level
Google’s advice on every Gemini 4 page is the same: run your evaluations at every supported level with a high output cap, and keep the lowest level that meets your quality bar. Concretely:
1. Write 20 to 50 tasks with automatic pass/fail checks. Use real requests from your app, checked by exact answers, unit tests or schema validation, and include your hardest cases. Our test shows why: easy tasks pass at every level and tell you nothing.
2. Sweep every supported level with the level set explicitly. A minimal sweep against Ofox’s native route:
import os, time, json, urllib.request
URL = "https://api.ofox.ai/gemini/v1beta/models/{m}:generateContent"
LEVELS = {"google/gemini-4-hydrogen": ["low", "medium", "high", "xhigh"],
"google/gemini-4-argon": ["low", "medium", "high"]}
def run(model, level, prompt):
body = {"contents": [{"role": "user", "parts": [{"text": prompt}]}],
"generationConfig": {"thinkingConfig": {"thinkingLevel": level},
"maxOutputTokens": 32768}}
req = urllib.request.Request(URL.format(m=model), data=json.dumps(body).encode(),
headers={"x-goog-api-key": os.environ["OFOX_API_KEY"],
"Content-Type": "application/json"})
t = time.time()
r = json.load(urllib.request.urlopen(req, timeout=900))
cand = r["candidates"][0]
text = "".join(p.get("text", "") for p in cand["content"]["parts"] if not p.get("thought"))
u = r.get("usageMetadata", {})
return {"level": level, "finish": cand.get("finishReason"),
"thoughts": u.get("thoughtsTokenCount", 0),
"output": u.get("candidatesTokenCount", 0),
"seconds": round(time.time() - t, 1), "text": text}
Score text with your own checker. Log finish too: anything other than STOP means the run didn’t complete normally, so count it as neither pass nor fail.
3. Run each level at least 3 to 5 times per task. Identical requests in our test varied by up to 70% in thinking tokens (Hydrogen low on the easy fact: 45 vs 78).
4. Pick the lowest level whose pass rate matches the best level’s, then weigh the extra cost of the next level up against its extra passes, using your own usage numbers. For scale: on AA’s tasks, Hydrogen high to xhigh cost $1.29 more per task for 3.1 index points.
5. Set the level per request type, not per app, and re-run the sweep whenever the model, prompt template or price changes.
Starting points by task type
Starting points to test, taken from Google’s per-level guidance and the AA curves above. They are not measured results for your workload.
| Task | Hydrogen / Neon start | Carbon / Argon start | Move up when | Move down when |
|---|---|---|---|---|
| Extraction, classification, short factual answers | low | low (on AA, Carbon low was not cheaper; check on your data) | Checker failures appear | Already at low |
| Chat, summaries, simple tool calls | low or medium | low | Answers miss steps or call the wrong tool | Pass rate unchanged at the lower level |
| Interactive coding, UI prototyping | medium | medium | Tests fail or edits are incomplete | Tests still pass and latency matters |
| Multi-file coding, agent loops, document synthesis | high | medium (default), then high | Tasks stall or the agent gives up | medium passes the same tasks |
| Hard math, science, root-cause debugging | high, then xhigh | high | xhigh only on Neon/Hydrogen, after high fails | Rarely; check the cost first |
Google warns that xhigh “can cause overthinking or exhaust max_output_tokens on simpler prompts such as text or JSON extraction.” Keep it off extraction work.
When a level request fails
| Symptom | Likely cause | Fix |
|---|---|---|
400 naming thinking_level | Value not valid for the model or API | Validate the level against the model ID before sending; see the Gemini 4 API errors guide |
400 “service is temporarily unavailable” through Ofox | In our tests, a leftover thinkingBudget | Remove thinkingBudget and keep thinkingLevel |
400 on an OpenAI-compatible call setting both reasoning_effort and thinking_config in extra_body | Google says the two can’t be used together | Use only one |
HTTP 200 with empty or cut-off text, MAX_TOKENS / length | Thinking used up the output cap | Raise maxOutputTokens or lower the level; see empty or truncated answers |
Timeouts at high / xhigh | Long reasoning on hard prompts | Google’s migration checklists recommend HTTP client timeouts of at least 15 minutes, or background execution on Google’s API |
| Answer text starts with the model’s thought summary | Thought parts joined into the answer | Skip parts where thought is true |
| Multi-turn tool calls fail with a signature error | Thought signatures not sent back unchanged | See missing thought signature in tool calls |
For Argon-specific status codes, see Gemini 4 Argon API errors. For retry behavior on Ofox, see the error handling guide.
Where to go next
- First working Hydrogen request: Gemini 4 Hydrogen API setup
- Neon request shapes: Gemini 4 Neon API guide
- Moving from Argon to Neon, including level changes: Argon to Neon migration
- Picking a Gemini 4 model in the first place: Gemini 4 model selection
Related Docs
- Gemini thinking settings on Ofox:
thinkingLevel,thoughtsTokenCountand the OpenAI-compatiblereasoning_tokensfield - Gemini-native API overview: base URL
https://api.ofox.ai/geminiand thex-goog-api-keyheader - Generate Content reference
- Error handling and retries
Frequently Asked Questions
- Does a higher Gemini 4 thinking level change the price per token?
- No. Google bills thinking tokens at the output rate, and the per-token price is the same at every level. A higher level costs more because the model generates more thinking tokens, and on agent tasks it can also run more turns and read more input.
- Can I turn thinking off on Gemini 4?
- No. Google says thinking cannot be disabled on Carbon, Argon, Neon or Hydrogen, and minimal is not a supported Gemini 4 level. The lowest documented setting is low. In our Ofox runs on 2026-11-19, Argon at low and medium sometimes reported no thoughtsTokenCount on short prompts, so observed thinking can be zero even though you cannot switch it off.
- Should I use thinkingBudget instead of thinkingLevel on Gemini 4?
- No. Google marks thinkingBudget as deprecated on Gemini 4: sent alone it maps to the nearest level with a warning, and sent together with thinkingLevel it returns a 400. Through Ofox on 2026-11-19, every request we sent with thinkingBudget returned HTTP 400, including budget-only requests. Remove it and set thinkingLevel only.


