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.

Two high-jump standards with four pegs each; an orange crossbar rests on the lowest peg and a small green ball arcs above it, leaving the higher pegs unused.

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-hydrogen and google/gemini-4-argon through 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

ModelModel IDSupported levelsDefaultOn Ofox (2026-11-19)
Gemini 4 Carbongemini-4-carbonlow, medium, highmediumNo
Gemini 4 Argongemini-4-argonlow, medium, highmediumYes, google/gemini-4-argon
Gemini 4 Neongemini-4-neonlow, medium, high, xhighhighNo
Gemini 4 Hydrogengemini-4-hydrogenlow, medium, high, xhighhighYes, 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:

LevelGoogle’s descriptionGoogle’s suggested use
lowFewest tokens, lowest latencyFast chat, high-throughput processing; “still capable on agentic tasks”
mediumLower token use, faster responsesInteractive coding, live UI prototyping, latency-sensitive tool calls
highBalanced intelligence and speedDefault for complex coding, agents, tool calling, multimodal work
xhighMost tokens, deepest reasoningHard 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.

APIWhere the level goesWhere thinking tokens are reported
Interactions API (Google)generation_config.thinking_levelusage.total_thought_tokens
generateContent RESTgenerationConfig.thinkingConfig.thinkingLevelusageMetadata.thoughtsTokenCount
generateContent Python SDKGenerateContentConfig(thinking_config=ThinkingConfig(thinking_level=...))usage_metadata.thoughts_token_count
OpenAI-compatible Chat Completionsreasoning_effortusage.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.io/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.io/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_effortGemini 4 thinking_level
minimallow
lowlow
mediummedium
highhigh
xhighxhigh (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.io/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)

LevelAA Intelligence IndexCost per taskTime per taskOutput tokens per taskHallucination rate
low44.1$0.753.7 min~21,70018.8%
medium54.9$1.908.3 min~50,00016.2%
high (default)59.6$3.7414.8 min~90,20013.9%
xhigh61.4$6.4421.5 min~141,60014.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)

LevelAA Intelligence IndexCost per taskTime per taskOutput tokens per taskHallucination rate
low26.9$0.29not shownnot shownnot shown
medium41.2$0.80not shownnot shownnot shown
high (default)50.8$1.878.6 min~85,0008.7%
xhigh53.9$3.1615.2 min~154,4008.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).

LevelAA Intelligence IndexCost per task (Dec rate)Cost per task (Nov rate, our halving)Time per taskHallucination rateOmniscience accuracy
low54.2$7.19$3.5930.4 min19.8%49.2%
medium (default)58.3$6.59$3.2929.6 min4.2%48.9%
high60.0$7.76$3.8837.2 min11.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.

LevelAA Intelligence IndexCost per task (Nov rate)Cost per task (Dec rate, our doubling)Time per taskHallucination rateOmniscience accuracy
medium (default)47.6$4.31$8.6329.1 min15.4%49.0%
high50.4$4.97$9.9529.8 min4.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 Carbon medium (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 xhigh and Carbon and Argon at high. 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 Hydrogen xhigh (53.9, $3.16) at 60% of the cost, and Neon low (44.1, $0.75) above Hydrogen medium (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.io/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:

  1. Easy fact: the chemical symbol for tungsten (expected W).
  2. 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.”
  3. Short coding task: write merge_intervals so 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):

Promptlowmediumhighxhigh
Easy fact45, 7846, 5884, 87106, 112
Arithmetic522, 523669, 715690, 7861,734, 1,687
Coding424, 541672, 572426, 3892,119, 1,987
Total (6 runs)2,1332,7322,4627,745
Summed latency50.1 s45.0 s44.0 s80.3 s
Correct6/66/66/66/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:

Promptlowmediumhigh
Easy factnone, nonenone, none105, 105
Arithmeticnone, none398, 3671,071, 895
Codingnone, nonenone, none739, 890
Correct (all prompts)6/66/66/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:

RequestThinking tokensClosest documented level
Hydrogen minimal463, 481Hydrogen low: 522, 523
Argon xhigh1,238, 1,141Argon 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." with type: "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": true containing a thought summary, although we never set includeThoughts. Google describes summaries as opt-in. We did not check Google direct. If your code joins every text part, skip parts where thought is true or the summary leaks into your answer.
  • Usage counts differ from visible text. Our one-character answers reported a candidatesTokenCount of 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.io/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.

TaskHydrogen / Neon startCarbon / Argon startMove up whenMove down when
Extraction, classification, short factual answerslowlow (on AA, Carbon low was not cheaper; check on your data)Checker failures appearAlready at low
Chat, summaries, simple tool callslow or mediumlowAnswers miss steps or call the wrong toolPass rate unchanged at the lower level
Interactive coding, UI prototypingmediummediumTests fail or edits are incompleteTests still pass and latency matters
Multi-file coding, agent loops, document synthesishighmedium (default), then highTasks stall or the agent gives upmedium passes the same tasks
Hard math, science, root-cause debugginghigh, then xhighhighxhigh only on Neon/Hydrogen, after high failsRarely; 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

SymptomLikely causeFix
400 naming thinking_levelValue not valid for the model or APIValidate the level against the model ID before sending; see the Gemini 4 API errors guide
400 “service is temporarily unavailable” through OfoxIn our tests, a leftover thinkingBudgetRemove thinkingBudget and keep thinkingLevel
400 on an OpenAI-compatible call setting both reasoning_effort and thinking_config in extra_bodyGoogle says the two can’t be used togetherUse only one
HTTP 200 with empty or cut-off text, MAX_TOKENS / lengthThinking used up the output capRaise maxOutputTokens or lower the level; see empty or truncated answers
Timeouts at high / xhighLong reasoning on hard promptsGoogle’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 summaryThought parts joined into the answerSkip parts where thought is true
Multi-turn tool calls fail with a signature errorThought signatures not sent back unchangedSee 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

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.