OpenAI launched two GPT-6.2 models on November 17, 2026, and the pair is built to be bought together: Sol is the cheap, fast everyday model, Astra is the expensive, slower one for the turns that actually need it. Every figure below was read from OpenAI's own model docs and pricing page, and from Artificial Analysis' benchmark suite, on November 18, 2026. The pricing pages answer the buying question directly: same context window, same tools, same rate limits, and a 4x price gap on every token.
What OpenAI actually shipped, in its own words
The official model docs give each model one job sentence. gpt-6.2-astra is the "flagship model for the hardest engineering, scientific, and professional projects"; gpt-6.2-sol is the "efficient everyday model for coding, code review, and agentic workflows at scale". Nothing in the docs frames them as rivals. They are the deep-reasoning slot and the high-volume slot of one lineup, and both share the same body: 1,050,000 tokens of context, 922,000 max input, 128,000 max output, text and image input with text output, and identical rate limits from 5,000 to 15,000 RPM depending on tier.


Two quieter differences are worth reading before you pick. Sol's knowledge cutoff is June 1, 2026, two weeks newer than Astra's May 18. And starting with GPT-6.2 the API drops reasoning items whenever it detects a mid-conversation prefix edit, a model downgrade, an end-user change, or an organization change, so a session that keeps its prompt prefix byte-identical keeps both its reasoning and its prompt-cache discounts.
What each one costs, including the tiers nobody reads
The pricing page splits by processing tier, and the gap between the models holds at every tier. The table prices the Standard tier; the diagram below carries all five.
gpt-6.2-astra | gpt-6.2-sol | gpt-6-astra (prior) | gpt-6.1-sol (prior) | |
|---|---|---|---|---|
| Standard input, per 1M tokens | $8.00 | $2.00 | $10.00 | $2.00 |
| Standard cached input, per 1M | $0.40 | $0.10 | $1.00 | $0.10 |
| Standard output, per 1M tokens | $40.00 | $10.00 | $50.00 | $10.00 |
| Knowledge cutoff | May 18, 2026 | June 1, 2026 | April 2026 | prior gen |

Three rows of that ladder deserve a second read. First, cached input repeats at 95% off on both models: a rerun over a cached million-token prefix costs $0.10 on Sol and $0.40 on Astra, which is why the prefix-stability rule above is also a pricing lever, not just a correctness one. Second, long context above 272K input tokens doubles the input rates and bills output at 1.5x for the whole request, which is OpenAI's documented rule; the per-1M figures in the diagram derive from it, arithmetically, not from a separate row we invented. Third, ultrafast mode is on a promotional 3x rate through February 28, 2027 and moves to 6x from March 1, 2027. A budget built on today's ultrafast prices doubles on March 1.
What the third-party benchmarks show, and their limits
Artificial Analysis ran both models through its Intelligence Index v5.0.1 at Max effort, and both beat their predecessors on every axis its suite measures.

Astra scores 62, rank #3 of 92 models, up from GPT-6 Astra's 57 at rank #13. Sol scores 57, rank #11, up from GPT-6.1 Sol's 55 at rank #19. The generational story is cleaner than the ranking: Sol at 57 exactly matches what the previous flagship scored, and it does it at $1.01 per index task against the old flagship's $6.24. Astra's $4.00 per task is a 36% drop from $6.24, while running the suite in 10.7 minutes instead of 19.9. Sol runs 7.9 minutes per task at 85 tokens per second output, with a first answer token in 61.56s where Astra takes 147.65s.
The suite median is 43 on the index and 11.4 minutes per task, so both models sit well above the median and both are slower than the median per task. That is the shape of reasoning-heavy models measured on a reasoning suite. What the suite does not do is measure either model on your codebase: one lab's 9-evaluation index is evidence about the models, not about your workload, and the honest way to use it is to run the two prompts you actually care about before deciding where the budget goes.
How to split a workload across the pair
The economics point one way and the price gap points the same way. Sol handles the daily volume: code review, refactor runs, agent loops where the per-call cost compounds at 85 tokens per second. Astra takes the turns where Sol's answer is not good enough: the architecture decision, the cross-file investigation, the security-sensitive review. Escalate per turn, retry the failed turn on Astra once, and move back; do not migrate the whole session, because a model switch mid-conversation is one of the four events that drops reasoning items and resets the prompt cache.
A worked example at Standard rates, our arithmetic on OpenAI's published prices: a request over a 1M-token prefix with 60K tokens of output costs $2.00 + $0.60 = $2.60 on Sol and $8.00 + $2.40 = $10.40 on Astra. The same request rerun on warm cache costs $0.10 + $0.60 on Sol, $0.40 + $2.40 on Astra. Multiply by whatever call volume your agents actually run, and the difference between routing well and routing badly is the whole line item.
Who each one is not for
Astra is not for high-volume agent loops, where 4x the input price and 4x the output price compound into a bill that Sol's benchmark parity cannot justify. Sol is not for the frontier turns: its 57 on the index matches last generation's flagship, which is remarkable, but it is five points under Astra, and on the turn that decides the architecture those five points are the product.
Our AI coding category tracks the editors and agents these models plug into, the ChatGPT, GitHub Copilot, and Cursor profiles carry the sourced figures for the tools themselves, our Claude vs Gemini comparison prices the competing frontier pair, and the Claude Code vs Cursor guide covers the layer where model choice meets editor choice. The Gemini 4 Carbon vs Hydrogen comparison is the same analysis for Google's lineup, and Gemini 4 Krypton covers what Google's reported-but-unconfirmed checkpoint does and does not prove.
