Evidence checked September 22, 2026. This article uses published evaluations and direct API prices in US dollars. Kingy did not run paid benchmark tests.
GPT-6 Sol is the cheaper starting point for everyday coding and agent work. Astra is worth considering when a higher completion rate, fewer corrections or a harder task justifies the extra spend. The complication is effort: Sol at max is not automatically cheaper than Astra at low, and neither model improves on every benchmark each time you turn the setting up.
OpenAI’s DeepSWE v1.1 chart makes the trade-off concrete. Sol xhigh scores 66.6% at $1.00 per task; Astra low scores 67.0% at $1.60. Sol max reaches 68.8%, but costs $2.74. In that published run, turning Sol up to max moves it above Astra low in both score and cost. Source: OpenAI’s September 22 coding charts.
That is the decision this comparison addresses: when to spend more effort on Sol, and when to move to Astra. Our Sol and Luna overview covers the broader launch. This guide focuses on the two models’ effort curves, bills and practical starting configurations.
What the 5× price gap covers
Both current model references list a 1,050,000-token context window and 128,000 maximum output tokens. Both accept text and images and return text. Context capacity alone therefore does not explain a decision to pay for Astra. The important question is how effectively each model uses that context. Sol specifications, Astra specifications.
| Standard API billing category, per 1M tokens | GPT-6 Sol | GPT-6 Astra | Astra ÷ Sol |
|---|---|---|---|
| Ordinary input | $2 | $10 | 5× |
| Cache read | $0.20 | $1 | 5× |
| Cache write | $2.50 | $12.50 | 5× |
| Output | $10 | $50 | 5× |
Sources: Sol rate card, Astra rate card.
The fivefold ratio holds for the same billable token counts and the same processing route. It does not promise a fivefold difference in the cost of finishing a task. A model can spend different amounts on reasoning, tool calls, repeated context and failed approaches. The later examples show both a fixed-token bill and a conditional escalation workflow.
Both models have low, medium, high, xhigh and max API reasoning settings. Sol also supports none and defaults to medium. Astra does not support none. None is omitted from the effort tables because OpenAI’s displayed benchmark curves do not provide that row. Sol model reference, OpenAI reasoning guide.
Business automation: Sol xhigh is a useful stopping point
OpenAI’s AutomationBench 1.0.6 chart reports the following scores and costs. Each cell is score / cost per task. These are OpenAI-published results, not Kingy measurements.
| Effort | GPT-6 Sol | GPT-6 Astra |
|---|---|---|
| Low | 21.2% / $0.19 | 30.3% / $1.08 |
| Medium | 26.9% / $0.21 | 34.1% / $1.27 |
| High | 31.2% / $0.24 | 37.1% / $1.44 |
| Xhigh | 33.2% / $0.27 | 39% / $1.50 |
| Max | 32% / $0.34 | 41.4% / $1.73 |
Source: OpenAI’s AutomationBench chart. The benchmark covers workflows using tools across business applications.
Sol high already clears Astra low’s displayed score: 31.2 − 30.3 = 0.9 percentage points, at $0.24 ÷ $1.08 = 22.2% of the cost. Sol xhigh reaches 33.2% for $0.27. Its max point then costs more and scores lower. Those observations make high and xhigh useful candidates for this task class; they do not prove a statistically significant win over Astra low.
Moving from Sol xhigh to Astra medium adds 34.1 − 33.2 = 0.9 points and changes the displayed cost from $0.27 to $1.27. That is $1.27 ÷ $0.27 = 4.70 times the cost. Moving to Astra max gives a larger score difference: 41.4 − 33.2 = 8.2 points, at $1.73 ÷ $0.27 = 6.41 times the cost.
There is a small rounding issue in the source worth making explicit. OpenAI’s prose calls Astra low 3.9 times the cost of Sol xhigh. Dividing the chart’s displayed dollar amounts gives $1.08 ÷ $0.27 = 4.0. We use the displayed amounts for our arithmetic; the chart does not expose enough precision to reconstruct the prose ratio exactly.
For a workflow where a failed task gets a quick, cheap review, Sol’s lower cost may be attractive. When a failure leaves several business systems inconsistent or forces a long manual repair, the higher Astra score may be worth examining. The benchmark does not price that repair for your company.
Coding: compare Sol high/xhigh with Astra low/medium
DeepSWE v1.1 asks agents to solve software-engineering tasks in real repositories. Here is OpenAI’s complete five-setting comparison, again as score / cost per task:
| Effort | GPT-6 Sol | GPT-6 Astra |
|---|---|---|
| Low | 37.2% / $0.16 | 67% / $1.60 |
| Medium | 56.6% / $0.38 | 72.8% / $3.08 |
| High | 65.3% / $0.64 | 73.2% / $3.92 |
| Xhigh | 66.6% / $1.00 | 74.1% / $4.43 |
| Max | 68.8% / $2.74 | 73.2% / $7.50 |
Source: OpenAI’s DeepSWE v1.1 chart.
Sol makes a large move from medium to high. The score rises by 65.3 − 56.6 = 8.7 points; cost rises by ($0.64 − $0.38) ÷ $0.38 = 68.4%. Moving from high to xhigh adds 1.3 points, with ($1.00 − $0.64) ÷ $0.64 = 56.3% more cost.
The last step is much more expensive. Sol max adds 68.8 − 66.6 = 2.2 points over xhigh, while cost rises from $1.00 to $2.74, an increase of 174%. That does not make max useless. It makes max a setting that needs a reason.
Astra medium is another candidate near that budget: 72.8% at $3.08. Relative to Sol max, the displayed score is 4.0 points higher for ($3.08 − $2.74) ÷ $2.74 = 12.4% more cost. If your coding workload resembles these tasks, comparing those two configurations is more useful than comparing both models at the same effort name.
Astra’s own curve also has diminishing returns. Medium to xhigh adds 74.1 − 72.8 = 1.3 points, while cost rises from $3.08 to $4.43. Max costs $7.50 and scores below xhigh. Small score changes may be noise, and the chart does not show that a setting causes the change. It does show that the largest budget did not produce the best observed score.
FrontierCode, which considers whether changes are ready to merge, reinforces the value of comparing across settings. OpenAI displays Sol xhigh at 48.4% and $1.37, versus Astra medium at 48.8% and $2.43. The gap is 0.4 points; Sol costs $1.37 ÷ $2.43 = 56.4% as much. That is a second reason to shortlist Sol xhigh for ordinary repository work rather than treating Astra as the only serious coding option. OpenAI’s FrontierCode chart and task description.
Computer use gives Astra a stronger case
The next table is OpenAI’s OSWorld 2.0 offline set, partial-score evaluation from the v2026.08.08 release. Partial scores must not be described as the percentage of tasks fully completed. Each cell gives the published partial score and cost per task.
| Effort | GPT-6 Sol | GPT-6 Astra |
|---|---|---|
| Low | 43.9% / $0.97 | 62.2% / $2.55 |
| Medium | 54% / $1.32 | 69.3% / $5.10 |
| High | 58.3% / $1.64 | 70% / $6.60 |
| Xhigh | 60.5% / $2.21 | 71.3% / $7.17 |
| Max | 64.4% / $3.25 | 73.5% / $9.07 |
Source: OpenAI’s OSWorld chart and methodology.
Sol max scores 64.4% at $3.25. Astra low scores 62.2% at $2.55. The higher-effort Sol point gains 2.2 points but costs ($3.25 − $2.55) ÷ $2.55 = 27.5% more. The assumption that “Sol is always the cheap route” fails again once actual token use enters the picture.
Astra medium reaches 69.3% at $5.10. Compared with Sol max, that is 4.9 points higher for ($5.10 − $3.25) ÷ $3.25 = 56.9% more cost. Astra max reaches 73.5%, leaving a 9.1-point gap above Sol max, but its $9.07 cost is $9.07 ÷ $3.25 = 2.79 times as much.
For browser and desktop workflows with many dependent steps, I would keep Astra medium on the shortlist early. For inexpensive, easy-to-check actions, Sol can still be the better budget choice. The partial-score benchmark cannot tell you how often an agent will finish your exact workflow without intervention.
There is also a reason to resist transferring a coding setting into document work. On OpenAI’s Agents’ Last Exam chart, Sol medium is 53.1% at $1.27 and high is 52.6% at $1.53. The direction differs from DeepSWE. Effort should follow the task, not become one account-wide habit. OpenAI’s professional-work charts.
Three worked bills
Reasoning tokens count as output for billing. A cost model should include ordinary input, cache writes, cache reads and output as separate categories, then add any separately billed tools. The examples below hold token counts fixed to isolate rates; they do not claim either model will use those counts on a real prompt. OpenAI reasoning billing, prompt caching.
1. A short uncached request
For 20,000 input tokens and 2,000 output tokens:
- Sol: 0.020 × $2 + 0.002 × $10 = $0.04 + $0.02 = $0.06.
- Astra: 0.020 × $10 + 0.002 × $50 = $0.20 + $0.10 = $0.30.
Astra ÷ Sol = $0.30 ÷ $0.06 = 5.
2. An agent session with a warm cache
Assume 200,000 ordinary input tokens, 100,000 cache-write tokens, 1.8 million cache-read tokens and 150,000 output tokens across the session. These categories do not overlap. Every individual request stays at or below 272,000 input tokens.
- Sol: 0.2 × $2 + 0.1 × $2.50 + 1.8 × $0.20 + 0.15 × $10 = $0.40 + $0.25 + $0.36 + $1.50 = $2.51.
- Astra: 0.2 × $10 + 0.1 × $12.50 + 1.8 × $1 + 0.15 × $50 = $2 + $1.25 + $1.80 + $7.50 = $12.55.
The ratio is $12.55 ÷ $2.51 = 5. The benchmark costs above depart from five because the models and effort settings do different amounts of work.
3. A request above the long-context threshold
Both model references double input and cache rates and multiply output rates by 1.5 when a request exceeds 272,000 input tokens. The surcharge applies to the whole request. Take one uncached request with 300,000 input tokens and 20,000 output tokens:
- Sol input rate: $2 × 2 = $4. Output rate: $10 × 1.5 = $15. Total: 0.3 × $4 + 0.02 × $15 = $1.20 + $0.30 = $1.50.
- Astra input rate: $10 × 2 = $20. Output rate: $50 × 1.5 = $75. Total: 0.3 × $20 + 0.02 × $75 = $6 + $1.50 = $7.50.
The ratio remains 5, but both bills are higher than a flat-rate calculation would suggest. By comparison, incorrectly applying the short-context rates would give Sol $0.80 and Astra $4.00. Sol pricing conditions, Astra pricing conditions.
All three examples exclude tools, regional premiums and taxes. Batch and Flex list at half Standard rates, while Fast mode doubles applicable rates. Compare the same route, and check whether its latency and availability fit the job. Sol processing rates, Astra processing rates.
When escalation can cost less than using Astra for everything
Consider an illustrative batch of 100 jobs with the session costs from example 2. Sending every job directly to Astra costs 100 × $12.55 = $1,255.
Now assume every job first runs on Sol, and 20 jobs then receive a full Astra attempt costing the same $12.55 each:
- Initial Sol attempts: 100 × $2.51 = $251.
- Astra escalations: 20 × $12.55 = $251.
- Combined token cost: $251 + $251 = $502.
- Difference: $1,255 − $502 = $753, or $753 ÷ $1,255 = 60% less.
The 20% escalation rate is an assumption, not a finding. This calculation also does not establish equal output quality. It assumes the escalated Astra attempt has the stipulated bill and omits any extra review or handoff costs. If Sol produces errors you fail to detect, this policy can save tokens while delivering worse work.
That makes the acceptance check central. Code that has meaningful tests is a better candidate for cheaper-first routing than a report whose plausible mistakes are expensive to discover. Define what triggers escalation: a failing check, a missing requirement, repeated unproductive steps, or a task known to need stronger reasoning. See our cost-per-successful-job guide.
Which configuration should you start with?
| Your work | Starting candidate | What would justify moving up? |
|---|---|---|
| Routine, bounded work | Sol medium | Missing requirements or failed checks that higher effort fixes. |
| Repository coding | Sol high or xhigh | Harder tasks where Astra low/medium adds accepted changes worth its cost. |
| Business-tool workflows | Sol high/xhigh | Astra’s higher completion score matters enough to pay for the gap. |
| Difficult desktop or browser sequences | Astra low/medium alongside Sol max | Fewer broken steps, less intervention, or a higher complete-task rate. |
| Highest available score on a particular task class | Compare that task’s upper effort points | A measurable gain; max alone is not evidence of one. |
These are editorial starting points from published curves. My default for a new budget-sensitive coding workflow would be Sol high, with xhigh and Astra medium as deliberate alternatives. For demanding computer use, I would examine Astra earlier. Keep the choice tied to accepted work and review time, not loyalty to a model name.
If your other shortlist includes Anthropic, our Astra vs Opus 5.5 effort guide shows why a cross-vendor comparison can lead to different starting settings.
Evidence and reproducibility
The effort tables use OpenAI’s September 22 Sol/Luna launch charts, including the Astra series embedded in those charts. Values were transcribed from their accessible point labels. We retain the displayed rounding and the benchmark’s scoring labels. We do not substitute Astra numbers from an older announcement or another vendor’s chart.
OpenAI says its GPT evaluations used its research environment or API, which can differ from production ChatGPT because of prompts and tools. These are vendor-published results and cost estimates. They establish useful candidates for evaluation, not a guaranteed outcome in Codex, ChatGPT or your own application. OpenAI’s evaluation note.
Kingy ran no paid tests for this article. The arithmetic is reproducible from the stated token counts, price tables and chart points. Before changing a production default, compare accepted outputs, the complete bill and the time needed to review or repair the result.