Running 1,000 agentic coding tasks costs $192 on GPT-6.1 Sol and $1,020 on GPT-6 Astra, a 5.3x gap that comes entirely from the price sheet. The inputs behind that figure are $2.00 and $10.00 per million input and output tokens for Sol, against $10 and $50 for Astra (per OpenAI's launch material and third-party price aggregators, October 2026). Sol's model id is gpt-6.1-sol, and OpenAI describes it as "approaching GPT-6 Astra on several benchmarks at substantially lower cost".
Short answer: default to Sol for agent loops and escalate to Astra only for the steps where a failed attempt costs you more than the price difference. The break-even rule is simple. Sol is cheaper per finished task as long as it succeeds at least one-fifth as often as Astra. For most coding work that bar is low enough that Sol wins the default slot, and the interesting question is which steps still deserve the expensive model.
The two price sheets side by side
Sol launched on day one to Plus, Pro, Business, Enterprise and Edu plans inside ChatGPT Work and Codex. It is not in Chat yet. API prices below combine OpenAI's Sol announcement with third-party aggregated Astra rates, so verify them on the pricing page before you commit a budget.
| Tier | GPT-6.1 Sol | GPT-6 Astra |
|---|
| Input, per million tokens | $2.00 | $10.00 (up to 272K input) |
| Cached input | $0.10 | $1.00 |
| Output | $10.00 | $50.00 |
| Cache write | Not reported | $12.50 |
| Input above 272K | Not reported | $20.00 input, $75.00 output |
| Batch or Flex | Not reported | Half price |
| Fast mode | Not reported | 2x ($20 and $100) |
Look at the cached row before anything else. Standard input is exactly one-fifth the price on Sol, and so is output, but cached input is one-tenth. Sol's cached rate of $0.10 against Astra's $1.00 means a loop that rereads its context on every step gets cheaper on Sol faster than the headline ratio suggests. Agents reread context constantly, so this row is where the real money moves.
Worked examples: cost per 1,000 runs
I priced four run shapes. Each is a plausible agent step sequence rolled into one run, not a measured benchmark, so substitute your own token counts.
Cached coding loop. 150,000 input tokens, of which 120,000 are cache reads and 30,000 are fresh, plus 12,000 output tokens.
Uncached coding loop. The same 150,000 input and 12,000 output with no cache hits.
Short and verbose. 20,000 fresh input tokens, 15,000 output tokens.
Long-context review. 300,000 input tokens and 12,000 output on Astra, to show the repricing above 272K.
| Run shape | Sol per run | Astra per run | Sol per 1,000 | Astra per 1,000 |
|---|
| Cached coding loop | $0.192 | $1.020 | $192 | $1,020 |
| Uncached coding loop | $0.420 | $2.100 | $420 | $2,100 |
| Short and verbose | $0.190 | $0.950 | $190 | $950 |
| Long-context review | Not reported | $6.900 | Not reported | $6,900 |
The arithmetic for the first row: Sol costs 30,000 tokens at $2 per million ($0.06), 120,000 cached tokens at $0.10 ($0.012) and 12,000 output tokens at $10 ($0.12), for $0.192. Astra costs $0.30 plus $0.12 plus $0.60, for $1.02. The long-context row is 300,000 tokens at $20 ($6.00) plus 12,000 at $75 ($0.90). Sol's own long-context pricing does not appear in the sources I checked, so that cell stays empty rather than guessed.
Here is the same calculation as code you can edit:
const PRICE = {
sol: { fresh: 2, cached: 0.10, out: 10 },
astra: { fresh: 10, cached: 1.00, out: 50 },
}
function runCost(model, freshIn, cachedIn, out) {
const p = PRICE[model]
return (freshIn * p.fresh + cachedIn * p.cached + out * p.out) / 1e6
}
runCost('sol', 30000, 120000, 12000) // 0.192
runCost('astra', 30000, 120000, 12000) // 1.02
The AI Model Cost Calculator does the same sum for other models side by side, and the new Agent Run Cost Simulator lets you model a multi-step loop with growing context instead of a single flat run.
The speed tiers change the answer
Price per token is not the only dial. OpenAI sells speed separately, and the multipliers are large.
Astra Fast mode doubles the rate to $20 and $100. On the uncached coding loop that is $4.20 per run, or $4,200 per 1,000. A third-party report puts the Ultrafast API tier at six times standard, which is $60 input and $300 output. The numbers match six times Astra's list price, so they describe Astra Ultrafast, not Sol. Treat that as reported, not confirmed. On the uncached coding loop it works out to $12.60 per run and $12,600 per 1,000, about 30 times the Sol cost for the same token counts.
In the ChatGPT plans, the same idea appears as Pro 500: $500 per month, 25 times the Plus allowance, with Astra Ultrafast included. Ultrafast generates Codex tokens eight times faster and also burns allowance at eight times the rate, so the quota depletes quickly when you use it. Buying credits on Pro 100 or 200 does not unlock it.
Inside Codex on a Plus plan, the October guide estimates 5 to 45 Astra local messages per five-hour window against 15 to 160 for Sol. That is 3 to 3.6 times more Sol messages from the same quota, so the allowance maths favours Sol too, though by less than the API maths.
Batch and Flex give Astra half price. The uncached coding loop drops to $1,050 per 1,000 runs, which is still 2.5 times Sol's standard price. Discounts do not close the gap. Only a lower failure rate can.
When Astra still wins
Cost per attempt is the wrong metric. Cost per finished task is the right one, and it is the attempt cost divided by the probability the attempt succeeds. On the uncached loop Sol costs $0.42 per attempt and Astra $2.10. Sol is cheaper per finished task when its success rate is above one-fifth of Astra's, or 20% of whatever Astra achieves.
That sounds like an easy bar, and often it is. The catch is that a failed attempt rarely costs only tokens. If a failed run leaves a broken branch that takes ten minutes of review at $60 per hour, the failure costs $10, which is 24 times the Sol token cost of the whole attempt. Now the break-even looks different. Add the human cost to the numerator and a model that fails often becomes expensive quickly, because the review time dominates the token bill.
That points to a split policy:
Sol for generation. Drafting code, writing tests, refactoring within a file, summarising logs. Failures are cheap to detect and retry.
Astra for judgment. Architecture decisions, security review, multi-file changes with hidden coupling, anything where a wrong answer ships silently.
Cheaper still for triage. Classification and routing do not need either model.
A hard stop on retries. Cap attempts at three and escalate to a stronger model or a person, never loop.
A note on what is not on the table. One outlet reported that OpenAI canceled GPT-6.1 Astra after incidents involving autonomous hacking. This is a single-source report, so treat it as unconfirmed. If true, it explains why the comparison is a 6.1 Sol against a 6.0 Astra rather than two same-generation models, and it means Sol's gap to Astra may not close by an Astra refresh soon.
Decide in ten minutes
Take one real task from your backlog. Run it ten times on Sol and ten on Astra with logging on. Record tokens in, cached tokens, tokens out and whether the result passed your tests. Put those numbers in the calculators linked above and compute cost per passing run. If Sol passes at least 20% as often as Astra you have your default, and if the pass rates are within a few points the saving is the full 5x.
The instrumentation is the hard part, not the arithmetic. The AI Agent Ops Bundle ships the logging schema and cost dashboards that make this measurement repeatable, and the Agent Prompt Vault has 50 tested prompts so both models run against identical instructions. Keep the instructions fixed and vary only the model, or the comparison tells you nothing.
The measurement also exposes the multiplier hiding inside most agent loops, which is the number of agents per task. A pipeline that fans out to four parallel agents multiplies every figure in the tables by four before any model choice. We covered why one agent should be the default in the multi-agent tax. Fix the fan-out first, then pick the model.
If you use Codex through a ChatGPT plan instead of the API, the dollars are fixed and the question becomes how many tasks fit in the quota. Codex has no separate subscription. It is included in plans from $0 to $500, and the API-key path is billed per token and excludes cloud features such as GitHub review and Slack. Plus costs $20, Pro starts at $100 with roughly five times the Plus allowance, and overflow credits cost about $0.04 each. On those plans Sol's advantage shows up as more completed tasks per five-hour window, 3 to 3.6 times more by OpenAI's estimates, instead of lower invoices.
So the decision tree has two branches. On the API, compare cost per finished task. On a plan, compare finished tasks per window. Both reach the same default for most teams: Sol for the bulk, Astra for the steps that cannot fail quietly.
Quick answers
How much cheaper is GPT-6.1 Sol than GPT-6 Astra?
One-fifth on standard input and output ($2 and $10 against $10 and $50 per million tokens), and one-tenth on cached input ($0.10 against $1.00).
What does 1,000 agent runs cost on each?
For a run with 120,000 cached and 30,000 fresh input tokens and 12,000 output tokens, $192 on Sol and $1,020 on Astra. Without caching it is $420 and $2,100.
Is Astra ever the cheaper choice?
Yes, when Sol succeeds less than one-fifth as often per attempt, or when each failure costs significant review time. Otherwise Sol wins on cost per finished task.
Is Sol available in the API?
Yes, under the model id gpt-6.1-sol at $2.00 input, $0.10 cached input and $10.00 output per million tokens. In ChatGPT it is available in Work and Codex, not yet in Chat.
Every product mentioned is available at wowhow.cloud — pay once, ship forever.
Originally published at wowhow.cloud
Top comments (0)