Reasoning Tiers: Thinking Harder on Demand

The Five Tiers Explained

GPT-6 Astra exposes five reasoning-effort settings — low, medium, high, xhigh, and max — that directly control how many times the model's layers iterate internally before producing a response. This is recurrent depth in practice: instead of one fixed forward pass, the same weights run again and again, letting the model refine its reasoning before committing to an answer.

The key insight is that more iterations are not always better. Each additional tier costs more in tokens and latency. The tiers exist so you can match thinking intensity to task complexity — not maximize it by default.

Low. Minimal recurrent iterations. Suitable for lookups, formatting tasks, factual retrieval, and any question with a well-defined answer. OpenAI positions low-effort Astra as the replacement for GPT-5.6 Sol at high effort — same output quality, faster and cheaper. Use it for anything you'd have handled with a non-reasoning model.

Medium. The default working tier. OpenAI's own guidance puts agentic coding and research at medium. It's the right place to start for most substantive tasks: summarizing a long document, writing a detailed technical spec, debugging a known-category error. Medium gives the model enough room to reason without running up the cost.

High. For genuine complexity and longer-running tasks. Use high when the job runs autonomously for an extended period — an agent navigating a website, a Codex session driving a shell, a pipeline that calls tools dozens of times before reporting back. At high, the model checks its own work more thoroughly before each step.

Xhigh. Reserved for tasks where a wrong answer creates significant downstream cost. Multi-file refactors with brittle tests, diagnosing intermittent production failures, reconciling contradictory requirements, or producing a decision memo where a missed constraint changes the recommendation. The extra iterations at xhigh help the model catch inconsistencies it would miss at high.

Max. Use max only when you can point at a measured failure rate at high or xhigh that max fixes. Architectural decisions with large downstream consequences qualify. The cost gap between xhigh and max is substantial — you should be able to name the specific failure mode you're paying to prevent.

Choosing the Right Tier

Three questions determine which tier a task needs:

• How novel is the problem? If there's a well-established answer the model has seen before, low or medium is sufficient. If the problem is genuinely original, the model needs more room to reason.
• What does a wrong answer cost? A bad formatting result is cheap to fix. A wrong architectural decision can require weeks of rework. Match the tier to the cost of being wrong, not just the difficulty of the task.
• Is latency a constraint? High and max add meaningful wait time. For interactive use where you're waiting on every response, medium is often the ceiling you'll tolerate in practice.

One note on how to read this table: quality index scores from low to max run 49, 52, 53, 54, 55. The jump from low to medium buys three quality points for fifty cents. The jump from xhigh to max buys one point for seventy cents. The marginal return on reasoning decreases as you climb.

The Token Math

The counterintuitive finding in OpenAI's release data is that at max effort, Astra uses one-third the tokens of GPT-5.6 Sol per completed task. A model that thinks more uses fewer tokens overall.

The explanation is in how recurrent depth changes task completion. GPT-5.6 Sol at high effort often produces an answer, gets it partially wrong, requires a correction turn, produces another answer, and repeats. That back-and-forth generates output tokens with each exchange. Astra at max thinks internally through the same iterations before producing its first response — and gets it right in one pass.

For agentic workflows, this matters significantly. A pipeline that requires twelve exchanges with Sol to complete a task might finish in four with Astra at max. The per-token cost of Astra is higher ($10 input / $50 output versus $2.50 / $10 for Sol), but the total token spend across a completed task can be lower because fewer turns are needed.

The tradeoff is cost per API call versus cost per completed outcome. For high-value tasks where correctness matters, per-outcome cost is the number that matters. For high-volume tasks where each call is independent and tolerates retry, per-call cost is what you optimize.

The Starting Rule

Start at medium. That's the single most important practice when using Astra.

Medium is where OpenAI's own documentation puts the majority of practical tasks. Starting there means you're not overpaying on low-stakes work and not waiting on unnecessary reasoning for queries that don't need it. The built-in reasoning at medium is enough for most substantive tasks — technical writing, coding assistance, document analysis, research summaries.

Escalate only when you can name the reason. Before moving from medium to high, ask: what specifically failed? Vague dissatisfaction with output quality is not a sufficient reason. The question is whether the task has a genuine complexity or novelty that medium's reasoning depth is insufficient to handle. If you can't answer that concretely, you're paying for a feeling, not a capability.

Quality signals that warrant escalation:

• The model reaches an answer but misses a constraint you stated explicitly — not a missing detail, but a logical inconsistency with requirements you provided
• The model produces a solution but an intermediate step has an error that invalidates the conclusion — a sign it didn't verify its own reasoning
• On the same task run multiple times, the model gives meaningfully different answers — not stylistic variation but different conclusions — indicating it hasn't converged on a reliable reasoning path

One practical note on the interface: in ChatGPT, the reasoning effort control appears as a slider in the message composer on web, and at the top of the conversation on iOS and Android. You can adjust it per message, not just per conversation — useful for escalating a single hard question within an otherwise medium-effort session without changing your default.