GPT-6 Astra Reasoning Levels Explained: Low vs Medium vs High vs XHigh vs Max

GPT-6 Astra supports five reasoning-effort settings: low, medium, high, xhigh and max. It does not support none; OpenAI’s reasoning guide says a request using none with Astra returns an HTTP 400 error. That small compatibility detail matters if you are migrating an application that previously disabled reasoning.

The best setting is not automatically the largest one. Use the lowest effort that reliably passes an evaluation built from your real tasks. A higher level gives the model more room to reason, but it should be treated as a quality–latency–cost control, not as a promise that every answer will be better.

This guide explains what the levels mean in practice, how to route work between them and how to test the decision without relying on guesswork.

What “Reasoning Effort” Actually Controls

Reasoning effort changes how much internal reasoning the model can apply before producing its answer. It is set inside the reasoning object in a Responses API request:

const response = await client.responses.create({
  model: "gpt-6-astra",
  reasoning: { effort: "medium" },
  input: "Compare these three production plans and identify hidden dependencies."
});

It is not a conventional creativity slider. It does not directly specify writing tone, randomness or output length. Those outcomes should be controlled with instructions, schemas and explicit length requirements. Nor does an effort label guarantee a fixed number of reasoning tokens, a fixed response time or a universal accuracy gain. Inputs vary too much for that.

OpenAI’s current model guidance also states that Astra tool calling requires the Responses API. If your workflow combines reasoning with custom functions, web search, file search or computer use, build around Responses rather than assuming an older Chat Completions integration has identical behavior.

The Five GPT-6 Astra Reasoning Levels

The following recommendations are practical starting points, not official performance guarantees. Validate them with your own prompts and success criteria.

Low: Fast, Constrained and Easy-to-Verify Work

Choose low when the path from input to answer is short and errors are easy to detect. Good candidates include extracting named fields, classifying a request into a small taxonomy, checking a document against a short rubric, rewriting text under strict constraints or calling one obvious tool.

Low effort is also useful in a first-pass routing layer. For example, a system can classify a request as “script feedback,” “character design” or “shot planning” before sending only complex cases to a more expensive path.

Do not use low merely because a prompt is short. A one-sentence legal, security or mathematical question can still require difficult reasoning. Task complexity comes from the dependencies and consequences, not word count.

Medium: The Sensible Evaluation Baseline

medium is a strong place to begin when you do not yet have evidence for another setting. It suits general analysis, moderately complex drafting, multi-step transformations and tool workflows with a small number of decisions.

For a creative-production assistant, medium may be sufficient to turn a detailed scene brief into a shot list, flag continuity problems and emit a validated JSON structure. For a support assistant, it may handle policy lookup plus a drafted reply. Measure both before escalating.

High: Complex Dependencies and Careful Synthesis

Use high when the model must reconcile several constraints, compare conflicting evidence, plan multiple dependent steps or inspect a large artifact without losing the core objective. Examples include a repository-wide change plan, a research synthesis with source conflicts or a narrative continuity review across many scenes.

High is often appropriate when a mistake is expensive but the task remains bounded enough to evaluate. A storyboard review might need to track character wardrobe, location, lighting, screen direction and dialogue continuity across twenty shots. That is a better reason to raise effort than simply asking for “a very good answer.”

XHigh: Hard Cases That Fail at High

xhigh should earn its place through evaluation. Reserve it for tasks that show a measurable failure rate at high: unusually dense constraint satisfaction, long-horizon planning, difficult debugging or ambiguous evidence that needs careful reconciliation.

Use selective routing. A lightweight classifier, deterministic rule or failed validation can trigger a second attempt at xhigh without sending every request there.

Max: Quality-First Work at the Edge of the Model

max is the highest supported Astra level. It is appropriate for your hardest, highest-value prompts when quality is more important than responsiveness and your evaluations show a benefit over xhigh.

Examples might include a final architecture review before a costly migration, an exceptionally difficult code investigation or a long creative-production plan with many interacting constraints. Max is not a substitute for good context, clear instructions, relevant tools or human review. A poorly scoped prompt remains poorly scoped at maximum effort.

A Practical Selection Matrix

Use this as an initial routing policy:

| Work pattern | Starting level | Escalate when | |---|---:|---| | Extraction, tagging, formatting | Low | Schema validation or spot checks fail | | General drafting and analysis | Medium | Important constraints are repeatedly missed | | Multi-document synthesis or complex planning | High | Cross-document conflicts remain unresolved | | Rare, difficult failures | XHigh | A validated high-effort retry still fails | | Highest-value edge cases | Max | Only when tests show a meaningful gain |

This table is deliberately task-based. Do not route solely by customer tier, prompt length or a user asking the model to “think harder.” Your application knows more about risk and expected structure than the model does.

How to Build an Evidence-Based Router

1. Define Success Before Comparing Levels

Create a representative set of real prompts, including routine requests, difficult examples and known failures. Score objective properties wherever possible: required fields present, citations valid, calculations correct, tool arguments accepted, prohibited claims absent and latency within budget.

For subjective work, use a stable rubric and blind reviewers to the effort setting. A screenplay rubric could score narrative clarity, continuity detection, actionable notes and fidelity to the supplied script.

2. Establish a Medium Baseline

Run the complete set at medium. Record task success, end-to-end latency, retries and total usage. Average quality alone is not enough; look at the worst important failures. A setting that performs beautifully on easy prompts but misses safety-critical constraints is not your baseline.

3. Test Low on Routine Segments

Identify categories where medium has comfortable quality margin, then test low. If low stays within your threshold, route that category down.

4. Escalate Failures, Not Everything

Compare high, xhigh and max on the difficult slice. Require a meaningful gain, and use validators to retry incomplete responses selectively.

5. Re-Evaluate When Prompts or Tools Change

Reasoning level is part of a system. Better retrieval, cleaner tool descriptions or stricter schemas can let a lower level outperform a higher level with noisy context. Re-evaluate after material changes.

Changing Effort During a Conversation

GPT-6 Astra supports a configuration_update item that can change reasoning effort mid-conversation while preserving the existing prompt prefix and its cache eligibility. OpenAI documents this for Astra in a standard single-agent flow.

const followUp = await client.responses.create({
  model: "gpt-6-astra",
  previous_response_id: firstResponse.id,
  input: [
    {
      type: "configuration_update",
      reasoning: { effort: "high" }
    },
    {
      role: "user",
      content: "Now audit every dependency and explain the two riskiest assumptions."
    }
  ]
});

There are important constraints. Keep the request-level effort unchanged; the configuration update controls subsequent reasoning. Adjacent configuration updates are invalid. OpenAI also says the feature is incompatible with automatic compaction and truncation, so long-running applications need an explicit compaction approach if they use it.

A useful pattern is to begin at medium for discovery and move to high for a final audit. Test the full sequence because multi-turn quality and caching matter.

Example: Reasoning Levels in an Animation Workflow

Suppose a creator starts with a one-paragraph anime concept. Low effort can classify genre and extract named characters. Medium can expand the concept into a scene outline. High can inspect the outline for continuity, pacing and production dependencies. Xhigh or max should be reserved for an unusually complex rewrite with intertwined timelines or strict constraints.

Once the planning is approved, a creator can take the resulting script, character notes and shot plan into Elser AI to build the visual production. The model setting should solve the planning task; Elser’s animation workflow handles the creative assembly. Keeping those responsibilities clear produces a more dependable pipeline than asking one prompt to do everything.

Common Mistakes to Avoid

Treating Max as a Universal Quality Button

Some tasks are limited by missing evidence, unclear instructions or bad tool results. More reasoning cannot recover information the model never received. Fix the input and instrumentation first.

Confusing Reasoning with Output Detail

If you want a 12-shot storyboard table, request that structure. If you want concise prose, set a concise output requirement. Reasoning effort and visible answer length are different controls.

Ignoring Unsupported none

A migration that mechanically copies reasoning: { effort: "none" } will fail for Astra. Normalize unsupported settings to a tested Astra value—usually low as the closest starting point—then run regression tests.

Measuring Only Accuracy

Production quality also includes latency, invalid tool calls, retries, source quality and user correction rate.

Skipping Human Review for Consequential Work

Even max effort does not make an output infallible. High-impact financial, medical, legal, security or publishing decisions require appropriate expert review and verification.

FAQ

What reasoning levels does GPT-6 Astra support?

It supports low, medium, high, xhigh and max according to OpenAI’s current model guidance.

Does GPT-6 Astra support none reasoning?

No. OpenAI states that none returns an HTTP 400 error with Astra.

Which level should I use by default?

Medium is a practical evaluation baseline. Move routine categories to low when tests show equivalent quality, and raise difficult categories only when higher effort provides a measurable benefit.

Does a higher level always improve the answer?

No. Results depend on the task, context, prompt, tools and validation. Higher effort can also increase latency or usage, so compare levels on representative work.

Can reasoning effort change during a conversation?

Yes. Astra supports configuration_update in a standard single-agent Responses flow, subject to the documented request and compaction constraints.

Is reasoning effort the same as temperature?

No. Reasoning effort controls the model’s reasoning allowance. OpenAI’s Astra migration guidance says to remove temperature, top_p and top_logprobs; those are not interchangeable with reasoning effort.

Conclusion

GPT-6 Astra’s five reasoning levels are most useful as a routing system. Start with medium, prove where low is enough, and reserve high, xhigh and max for cases that demonstrate a real quality gain. Pair the setting with structured outputs, validators, task-specific evaluations and human review where consequences demand it.

For creative teams, that discipline turns model reasoning into a reliable planning layer. When the script and production decisions are ready, start building the animation in Elser AI and keep the workflow measurable from concept to final scene.