GPT-6 Astra Reasoning Effort: max Costs 2.3x low for the Same Answers

On GPT-6 Astra, reasoning_effort: "max" costs 2.3x what low costs and returns the same answer on every one of 11 verified tasks; the only setting that changes accuracy is none, which fails 17 of 33 runs (11 tasks, 3 runs each). reasoning_effort is the request parameter that sets how much hidden thinking the model does before it answers; that thinking is billed as reasoning tokens at the output rate, and the ordered values from none to max are the ladder this post measures. The ladder is not the one in the docs: the API's own input check advertises seven values, one of them (minimal) is rejected on every model, and one it never mentions ( disabled) is accepted on Astra and does not disable anything. That matters for reading OpenAI's launch benchmarks, reported as "the maximum at any effort": the leaderboard number comes from the most expensive rung of the ladder.

TL;DR

reasoning_effort values including none and disabled; the docs list five and say low's 151 and costs 54% more per correct answer, same accuracy. max, on work both models get right. Ahead on agent-style work (the model driving tools in a loop, often in a terminal), behind Claude Fable 5.1 on Humanity's Last Exam and on the Artificial Analysis Intelligence Index (an independent aggregate of ten evaluations), and every score reported at whichever effort scored highest. The table below is OpenAI's own, from the launch page, with the comparison columns OpenAI chose:

Three things to read alongside the wins:

The sentence under the tables is the one that connects the benchmarks to your bill: "Evaluation scores are the maximum at any effort." The Artificial Analysis leaderboard lists each model once per effort setting, and Astra at xhigh scores 54 against 55 at max. The rest of this post prices that point.

Seven, and that is not the set the API advertises: one advertised value is rejected on every model, and one accepted value is advertised nowhere. The model page lists low, medium, high, xhigh and max, and states the model "does not support none reasoning effort". The API disagrees with the docs twice, and with itself once.

Send an invalid value and the first check, which validates the request shape before any model is involved, answers with the same list of allowed values on GPT-6 Astra and GPT-5.6 Sol:

Invalid value: '__invalid__'. Supported values are: 'none', 'minimal', 'low', 'medium', 'high', 'xhigh', and 'max'.

Then send each of those values and a second check, specific to the model, rejects some of what the first one advertised (200 means the request went through, 400 means it was rejected):

So none works although the docs say it does not, minimal is advertised and rejected everywhere, and disabled is accepted on Astra alone without appearing in any list. The error messages also give away the dated build the gpt-6-astra alias currently points to, gpt-6-astra-2026-09-03.

none does, and it is the only value that does. disabled is a normal rung with a misleading name. We sent 11 tasks whose answers were computed by exhaustive search on our own machine first, so the answer key cannot be wrong (a rule applied 40 times in a row, a counting problem under three constraints, a knapsack, a base conversion, 7 to the power 222 modulo 1000, and six shorter ones), at all seven efforts (six on Sol, which rejects disabled), 3 runs per task and effort, through an endpoint that speaks the OpenAI Chat Completions API. The five hardest, on GPT-6 Astra:

Cost per correct answer is the spend on a task-and-effort cell divided by the runs it got right: a setting that is 20% correct pays for five runs to get one answer. The cliff is one step wide. Every rung from low up scored 33 of 33 across all 11 tasks on both models; none scored 16 of 33 on Astra and 21 of 33 on Sol, and on the iterated-map task Astra returned three different wrong numbers in three runs. There is no gradual degradation to tune against: reasoning is on, or the model is guessing.

disabled is the trap. It spends more reasoning tokens than low, medium or high, and costs 54% more per correct answer than low for the same 100%. Only xhigh and max cost more per correct answer than the value whose name says off.

Nothing on these tasks, at 2.3x the price: $0.01946 per call against $0.00851, both 100% correct. Reasoning tokens climb from 151 at low to 370 at max, and every one of them bills at the $50 per million output rate.

That is the number to hold next to the benchmark table. Reporting "the maximum at any effort" means each score comes from whichever rung scored best, and on the independent leaderboard Astra's best entry is its max entry, one point above xhigh; our ladder prices that rung at 1.3x the one below it. On a workload that resembles the launch benchmarks, the extra effort may earn its cost. On a workload that resembles ours, it does not, and you find out which by measuring your own tasks at low first.

At low, no: 1.57x. At max, yes: 2.57x. List price is the per-token price on the vendor's own page: Astra lists at $10 input and $50 output per million tokens, Sol at $4 and $20 (both from the OpenAI model pages for Astra and Sol on 2026-09-07), so the list gap is 2.5x on both sides; the [GPT-5.6 Sol vs GPT-6 Astra comparison page](https://synthorai.io/compare/models/gpt-5-6-sol-vs-gpt-6-astra/) carries the live catalog prices. Cost per correct answer, computed from token counts at those list prices across all 11 tasks, both models scoring 33 of 33 from low up:

Astra spends fewer reasoning tokens than Sol to reach the same answer at the low rungs (91 against 158 per call across the 11 tasks at low), which is where the gap closes; its reasoning then grows faster up the ladder (249 against 242 at max), and there the per-answer gap is the full list-price gap.

The claim stays narrow: both models score 100% from low up, so this set does not separate their capability, only the price of an answer both get right, which runs from 1.6x to 2.6x on one parameter. OpenAI's launch page reports the opposite direction on agent work, Terminal-Bench 4.0 at "approximately 9% and 63% lower estimated API cost per task" than Sol and Fable 5.1, where a model that solves more tasks in fewer tokens can be cheaper despite a higher per-token price. Different workloads; the effort setting decides the bill on both.

Not at low; medium does. We sent a one-step task (add 2 hours 37 minutes to 08:15) three ways: bare, inside a strict response_format JSON schema (the reply must be JSON matching a shape you supply), and as a forced tool call (tool_choice pinned to one function, so the model must answer by calling it), at four efforts, 3 runs each. GPT-6 Astra, mean reasoning tokens (with their share of all billed output tokens) and cost per call:

low scales to zero: on a task with no steps it spends no reasoning and costs the same as none, and on the multi-step set above it spends 16 to 345 tokens per task and stays correct where none collapses, so low is the floor. The shell is not the tax: a schema or a tool call at low adds 0 to 4 reasoning tokens, while medium puts reasoning at 57 to 67% of the output tokens bare and in the schema, and 18% in the tool call, on a task with nothing to reason about. The same extraction costs 1.6x more at medium than at low inside the schema and 2.2x more bare, and the July GPT-5.6 cost guide found the same lever on that family. Sol is flatter: 0 reasoning bare and in the schema at every effort, 14 to 18 tokens on the forced tool call from medium up.

On one of OpenAI's two API surfaces. The older Chat Completions endpoint and the newer Responses endpoint accept the same model and bill the same way; the same question at medium, 3 runs per surface:

The token counts are within noise of each other, so the billing is the same and the only difference is whether you can see what you paid for. At $50 per million output tokens, the endpoint decides that. The docs also route tool calling to Responses ("GPT-6 Astra supports Chat Completions, but tool calling requires Responses"), so a tool-using workload lands on the readable surface by requirement.

Most of the contract. Measured:

temperature returns 400 on Astra and Sol alike ("not supported with this model"), and so do top_p and logprobs; response_format with a strict JSON schema returns schema-valid output on both; max_tokens below 16 is rejected on both.reasoning_effort: "max" returned 400 on GPT-5.6 Sol through Chat Completions. It is accepted now, and Sol scored 33 of 33 at it. From the docs, not measured here: the context window is 1,050,000 tokens with a 922,000 maximum input and 128,000 maximum output; prompts above 272K input tokens are billed at 2x the input and cache rates, the same threshold the GPT-5.6 family carries and the same mechanism we measured across vendors; cache reads list at $1 per million and cache writes at $12.50, with a new prompt_cache_options.ttl: "30m" parameter replacing prompt_cache_retention. Fast mode, a paid option OpenAI says delivers up to 2x the speed, is 2x the standard price.

The gateway passes reasoning_effort through unchanged, including the values the docs do not list, and the per-request usage record keeps reasoning_tokens as its own field next to completion_tokens and the billed cost. That is what every table above was built from: the effort a request was sent at, the reasoning it burned, and what it cost, readable per request rather than reconstructed from a monthly total.

Does GPT-6 Astra support reasoning_effort none?

Yes. The docs say it does not; the API accepts it on GPT-6 Astra and on GPT-5.6 Sol, and it is the only value that returns zero reasoning tokens. It also failed 17 of 33 runs on a verified task set, so it is a setting for lookups and transforms, not for anything with steps.

What does reasoning_effort disabled do on GPT-6 Astra?

It reasons. disabled is accepted on GPT-6 Astra (and rejected on GPT-5.6 Sol), appears in no documented or advertised list, and spent 243 reasoning tokens per call on our hard set against 151 for low, with identical accuracy. Treat it as an expensive alias for a middle rung, not as an off switch.

Which reasoning_effort should I default to on GPT-6 Astra?

low. On GPT-6 Astra it spent zero reasoning on a one-step task and 16 to 345 tokens per task on multi-step ones, scored 33 of 33 where none scored 16, and max cost 2.3x as much for the same answers. Raise a specific call site only when an eval on your own tasks shows a higher rung changing outcomes. Set it explicitly on every call and read the reasoning count back from the usage block:

resp = client.chat.completions.create(
    model="gpt-6-astra",
    reasoning_effort="low",
    messages=[{"role": "user", "content": prompt}],
)
print(resp.usage.completion_tokens_details.reasoning_tokens)

Measured 2026-09-07 through an OpenAI-compatible Chat Completions surface, plus the Responses endpoint for the visibility comparison: 11 tasks with locally brute-forced answer keys, 7 effort values, 3 runs per cell on both models, salted prompts (a unique suffix per request so no reply is served from a cache), cost taken from per-request usage accounting. Benchmark figures are OpenAI's launch table and the Artificial Analysis leaderboard, both fetched the same day. Cost per correct answer against GPT-5.6 Sol is computed from token counts at each model's documented list price.

Related: thinking controls across 13 models, GPT-5.6 cost guide, Claude Opus 5 cost, long-context pricing tiers, prompt cache write cost.