GPT-6.1 Sol vs GPT-6 Astra: One-Fifth Price Math for Agents

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.

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.

1. Cached coding loop. 150,000 input tokens, of which 120,000 are cache reads and 30,000 are fresh, plus 12,000 output tokens.
2. Uncached coding loop. The same 150,000 input and 12,000 output with no cache hits.
3. Short and verbose. 20,000 fresh input tokens, 15,000 output tokens.
4. Long-context review. 300,000 input tokens and 12,000 output on Astra, to show the repricing above 272K.

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.