GPT-6 Astra's Higher Token Costs Mask Lower Per-Task Expenses, OpenAI Claims

Developers eyeing a migration from GPT-5.6 Sol to GPT-6 Astra face an apparent contradiction: the newer model's tokens command a 2.5-fold price premium, yet OpenAI contends the upgrade makes financial sense—particularly when developers dial down the reasoning setting.

Thibault Sottiaux, engineering lead for Codex at OpenAI, made the case on X last weekend, stating: "To calibrate you all on which reasoning effort to use for Astra, know that GPT-6 Astra on low performs better than GPT-5.6 Sol on high." Artificial Analysis currently ranks Astra at low reasoning with an Intelligence Index score of 49, marginally surpassing Sol at high reasoning with 48. Speed also favors Astra-low, which generates its first token in 2.53 seconds versus 11.87 seconds for Sol-high.

To calibrate you all on which reasoning effort to use for Astra, know that GPT-6 Astra on low performs better than GPT-5.6 Sol on high.

Thibault Sottiaux, engineering lead for Codex, OpenAI

Reasoning effort changes cost

Astra pricing stands at $10 per million input tokens and $50 per million output tokens, against Sol's current rates of $4 and $20 respectively. Adjusting the reasoning dial from high to low leaves these per-token rates unchanged, but it alters the computational work required before task completion—a distinction OpenAI emphasizes in its upgrade documentation. According to the company, Astra delivers superior outcomes while consuming substantially fewer output tokens.

OpenAI points to its own benchmarking as validation. Testing with Terminal-Bench 4.0 revealed Astra achieving 57.9% compared to Sol's 37.3%, yet incurring roughly 9% lower per-task expenses. The disparity widened on GPQA Diamond, where Astra narrowly edged Sol at 94.9% versus 94.6% while costing approximately 37% less.

Actual deployments will differ across use cases, but these findings underscore that per-token pricing alone fails to capture true operational costs—a concept OpenAI is already investigating through outcome-based pricing models.

Fewer tokens, cheaper tasks

Developer Shinpr conducted a direct comparison using the same codebase, testing Sol-high against multiple Astra reasoning configurations across analysis, implementation, and review phases.

Astra-medium demonstrated superior performance on both duration and expense, completing the implementation phase with 80 requests—less than one-third of the 238 Sol-high required—and processing 11.1 million input tokens versus 37.8 million. Across all three phases, the Astra-medium execution consumed approximately 51 minutes and cost an estimated $25.67; the Sol-high execution required roughly 75 minutes and $31.79.

Increasing Astra to high reasoning proved counterproductive, as that configuration extended to 77 minutes and $37.23, and Shinpr noted its review phase overlooked a startup bug that the medium setting had caught.

A single developer's test cannot determine whether medium represents the optimal choice across all workloads, but it does suggest that additional reasoning capacity did not justify its expense in this scenario. However, this pattern does not universally apply. Testing by ARC Prize pointed toward nearly opposite conclusions.

Turning Astra up to high didn't help because that run stretched to 77 minutes and $37.23, and Shinpr said its review missed a startup bug that medium caught.

Developer Shinpr

More reasoning, lower bills

ARC Prize's assessment of Astra revealed the inverse relationship. Heightened reasoning not only elevated Astra's performance on ARC-AGI-3; in certain instances, it simultaneously reduced expenses.

Using ARC Prize's standard evaluation framework, Astra scored 17.5% at low reasoning, 38.6% at medium, 54.8% at high, and 62.7% at max. Astra includes an xhigh setting positioned between high and max. Notably, the costliest runs did not correspond to the highest reasoning levels. ARC Prize recorded expenditures of $38,166 at low, $48,090 at medium, and $40,705 at high, with max reasoning coming in at merely $26,098.

At max reasoning, Astra allocated greater computational resources to individual decisions but required fewer total actions to navigate the environments. This trade-off proved sufficient to reduce cumulative expenses—a dynamic that frequently emerges with agent-based systems. Although lower reasoning appears economical initially, a misstep rapidly necessitates additional tool invocations or retry cycles, ultimately consuming more reasoning expenditure than addressing errors through more comprehensive initial analysis.

While lower reasoning may look cheaper, a wrong turn quickly means another tool call or another attempt after another, which costs more in reasoning upfront than just fixing the mistakes later.

Dynamic reasoning without cache loss

Developers need not commit to either extreme across their entire workflow, thanks to Astra's new configuration_update mechanism. This feature permits applications to modify the reasoning effort between individual responses without altering the original request-level settings.

Routine operations can maintain a low reasoning level, while failed tests, unexpected tool outputs, or challenging debugging scenarios can elevate the reasoning level for subsequent turns. Once resolution occurs, the agent can revert to lower reasoning.

This flexibility partly explains the divergent findings between Shinpr and ARC Prize. Shinpr determined that elevated reasoning added time and expense without yielding better results, whereas ARC Prize found that heightened reasoning sometimes reduced action counts sufficiently to lower total costs.

Currently, configuration_update functions exclusively with Astra in standard, single-agent scenarios. Nevertheless, developers should not fixate on Astra's 2.5x token premium. A higher-priced model frequently delivers cheaper overall execution when it requires fewer invocations to finish and fewer iterations to achieve correctness.

Source: The New Stack