Developers eyeing a migration from GPT-5.6 Sol to GPT-6 Astra face an immediate concern: token pricing has jumped significantly. Input tokens now cost $10 per million compared to $4 for Sol, while output tokens climbed to $50 per million from $20. Despite this 2.5-fold increase in per-token rates, OpenAI contends that many teams should still upgrade—particularly if they dial down the reasoning setting.

Thibault Sottiaux, engineering lead for Codex at OpenAI, made the case on X over the weekend. "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." Independent testing by Artificial Analysis backs this claim: Astra running at low reasoning scores 49 on its Intelligence Index, slightly ahead of Sol at high reasoning with a score of 48. Response speed also favors the newer model—Astra's first token arrives in 2.53 seconds versus 11.87 seconds for Sol in high mode.

Reasoning effort changes cost

Adjusting the reasoning dial from high to low doesn't alter the per-token rates themselves, but it does affect the total computational work required to complete a task. OpenAI's own benchmarks illustrate this dynamic. On Terminal-Bench 4.0, Astra achieved 57.9% accuracy compared to Sol's 37.3%, yet cost approximately 9% less per task. The disparity widened on GPQA Diamond, where Astra edged Sol 94.9% to 94.6% while running 37% cheaper.

These results underscore a fundamental principle: per-token pricing alone does not determine real-world operational costs. The model that produces results more efficiently—using fewer tokens to reach the same outcome—can deliver better value despite higher unit rates. OpenAI is already exploring this concept through outcome-based pricing models.

Fewer tokens, cheaper tasks

Developer Shinpr conducted a hands-on comparison using the same codebase with Sol at high reasoning and multiple Astra reasoning levels, testing across analysis, implementation, and review phases. Astra at medium reasoning proved superior on both time and cost metrics. The implementation phase required only 80 requests—less than a third of the 238 Sol-high needed—and consumed 11.1 million input tokens versus 37.8 million. The complete Astra-medium run took roughly 51 minutes and cost an estimated $25.67, while Sol-high required approximately 75 minutes and $31.79.

Pushing Astra to high reasoning did not yield benefits. That configuration stretched execution to 77 minutes with a cost of $37.23, and Shinpr noted that the review phase missed a startup bug that the medium setting had caught. While a single developer's test cannot establish universal best practices, it does suggest that elevated reasoning levels may not justify their additional expense in all scenarios.

More reasoning, lower bills

ARC Prize's evaluation of Astra revealed a contrasting pattern. Testing with their standard harness showed Astra scoring 17.5% at low reasoning, 38.6% at medium, 54.8% at high, and 62.7% at max. Notably, the most expensive runs were not those using the highest reasoning levels. ARC Prize recorded costs of $38,166 at low, $48,090 at medium, and $40,705 at high, but max reasoning came in at just $26,098.

At maximum reasoning, Astra allocated more compute resources to each decision but required fewer total actions to solve test environments. This computational tradeoff proved economical overall. 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. This dynamic is particularly relevant for agent-based workflows where incorrect decisions cascade into additional operations.

Dynamic reasoning without cache loss

Astra introduces a configuration_update mechanism that allows applications to shift reasoning effort between responses without modifying the original request-level settings. This capability enables hybrid approaches where routine operations stay at low reasoning, while failed tests, unexpected tool responses, or complex debugging scenarios trigger higher reasoning for the next turn. Once resolved, the agent can revert to lower reasoning levels.

This flexibility helps explain why Shinpr and ARC Prize reached opposing conclusions. Shinpr found that additional reasoning added overhead without improving results, whereas ARC Prize discovered that higher reasoning sometimes reduced the total number of actions sufficiently to lower overall costs. Currently, configuration_update functions only with Astra in standard, single-agent requests, but the feature demonstrates how reasoning levels can be tailored to specific task requirements.

The takeaway for teams evaluating Astra: do not fixate on the 2.5-fold increase in token pricing. A model commanding higher per-token rates often delivers cheaper execution when it requires fewer API calls to complete tasks and fewer iterations to achieve correct results.

Source: The New Stack