Reasoning

Some models support a thinking (reasoning) mode: before producing the final answer, the model spends extra effort working through the problem. This improves quality on hard tasks — multi-step logic, math, planning, code — at the cost of higher latency and more tokens.

Reasoning is available only on reasoning-capable models; on other models the setting has no effect.

The effort knob

You control reasoning with a single setting — an effort level. It works exactly like model selection: pick a default once on the SDK, and override it per request when a particular call needs more or less thinking.

effort is one of six values:

One knob works across every model — there is no per-model configuration. The platform maps your effort to each model family's native control automatically.

Default is off

Reasoning is off unless you ask for it. A request that does not set an effort does not reason — the model returns its answer directly, with no think phase. To get reasoning, you must set an effort of minimal or higher.

This means thinking never silently inflates latency or cost: you opt in.

Default plus per-request override

The effort knob is shaped like the model-selection knob — an SDK-level default plus a per-request override:

• Set a default effort on the SDK (or chat client) and every request inherits it.
• Pass an effort on an individual request to override the default for that one call.

Resolution order, highest priority first:

1. The effort on the request, if set.
2. The SDK / client default effort, if set.
3. Otherwise omitted — and the platform defaults to off.

per-request effort  >  SDK default effort  >  (omitted → off)

So a chat client configured with a default of low will reason lightly on every call, except a single tough call you bump to high; and a one-off call you set to off skips thinking entirely.

The wire request carries the resolved value as:

{
  "thinking": { "effort": "medium" }
}

Per-provider "off" semantics

off always means "produce no reasoning," but model families differ in how far they can actually disable thinking. The platform handles this for you:

• Gemini 2.5 Flash / Flash-Lite — thinking is fully disabled (zero thinking budget).
• Gemini 2.5 Pro, Gemini 3, and OpenAI reasoning models — cannot be fully turned off; they are floored to their lowest reasoning setting. off still surfaces no reasoning to your client, but the model does a minimal internal pass.
• Anthropic — thinking is explicitly disabled.

You do not need to know which provider you're on — set the effort you want and the platform applies the correct native behavior.

Turning thinking on streams reasoning

When reasoning is on, the model's thinking is streamed to your client as it happens, separately from the final answer. Surface it. If you ignore the reasoning stream, the player sees a long pause followed by a sudden burst of text — a "dead air, then wall of words" experience.

Show the reasoning as it arrives (for example, a "thinking…" indicator or a collapsible trace) so the wait feels alive. Each SDK exposes a dedicated reasoning callback for this — see the per-SDK guide:

• JavaScript — an onReasoning callback on the streaming methods.
• Unity — a reasoning-delta callback.
• Unreal — an OnReasoningChunk event.

When to use it

• Raise the effort for complex reasoning: math, multi-constraint planning, debugging, careful classification.
• Keep it off for short, factual, or latency-sensitive replies — reasoning adds delay and cost, and off is the default for exactly this reason.

For the exact call in your language, see the JavaScript, Unity, or Unreal text generation guide.