Reasoning

How to ask#

Both dialects reach the same control. What you send is an intent; xKiro translates it into whatever the model that ends up serving your request actually understands.

{ "reasoning_effort": "high" }

{ "thinking": { "type": "adaptive" } }                          // model decides the depth
{ "thinking": { "type": "enabled", "budget_tokens": 16000 } }  // a token budget
{ "thinking": { "type": "disabled" } }                         // off

Budgets become levels

When a request carrying budget_tokens is served by a model that expresses reasoning as a level rather than a budget, the budget is converted:

Support is per model#

Every model declares which control it has and which values it accepts. The shapes currently in the catalog:

Finding out for your model

The catalog in the dashboard lists the control and accepted values per model. Treat it as the source of truth: the table above is a snapshot, and models are added and revised without a documentation deploy.

Four intents, and why they differ#

This is the part that trips people up most, so it is worth stating precisely.

Levels a model does not have#

Nothing is rejected for this reason, and nothing is ever quietly upgraded. The rules, in order:

• Above the model's range → step down to the nearest level it has. Asking for max on GPT-5.4, which stops at xhigh, gives xhigh — not the model default, which would be lower than you asked for.
• Below the model's lowest level → nothing is sent. Rounding up would cost more than you asked for, so the model runs on its own default instead.
• Two-position models get the obvious answer. Any positive level turns the switch on; noneturns it off. There is no way to ask for "a bit" of thinking on those models.
• Unrecognised values fall back to the model default. A typo does not silently disable reasoning, and is never forwarded upstream — some providers return 400 for an unknown level.
• Models with no control ignore the field. No error, no cost, no effect.

What this means when routing substitutes a model

If your request is served by a different model (see Overview), your reasoning intent is re-resolved against the model that actually runs. A request that asked for max may therefore run at xhigh, or on a two-position model simply run with thinking on. The intent is preserved as closely as the substitute allows; it is never escalated.

Reading the reasoning#

Where a model exposes its thinking, it arrives alongside the answer: thinking content blocks on Messages, and reasoning_content on the delta in Chat Completions. Not every model returns it, and some return only a summary.

for await (const chunk of stream) {
  const delta = chunk.choices[0]?.delta as
    | { content?: string; reasoning_content?: string }
    | undefined;

  if (delta?.reasoning_content) showThinking(delta.reasoning_content);
  if (delta?.content) showAnswer(delta.content);
}

Cost and latency#

• Reasoning tokens are billed as output tokens. On the same prompt, a high level can cost several times what a low one does.
• Time to first visible token grows with depth, because the model reasons before it writes. Use streaming so the wait is visible rather than blank.
• Sampling parameters are dropped while reasoning is active — reasoning models reject temperature and top_p, so xKiro removes them rather than letting the provider fail the request.
• If a model defaults to reasoning and you do not need it, turning it off explicitly is one of the largest single savings available.