GPT-6.2 Astra and Sol: Who Should Switch
GPT-6.2 launched November 17 as two models, Astra and Sol. Specs, API prices, benchmarks, where it slips, and who should switch.

OpenAI shipped two new flagships on Tuesday, and the headline is not the one it wants you to read.
The headline is the price tag. GPT-6.2 Astra costs 20% less than the model it replaces, and GPT-6.2 Sol costs exactly what the last Sol cost. In a year when every launch raised the bill, that is the story.
GPT-6.2 is two models released on November 17, 2026: Astra, the frontier model for hard professional work, and Sol, the cheaper everyday model. Astra costs $8 per million input tokens and $40 per million output tokens. Sol costs $2 and $10. Both are in the OpenAI API under the IDs gpt-6.2-astra and gpt-6.2-sol, per OpenAI's launch announcement.
Both models are also available right now to every Magai user. Magai added GPT-6.2 Astra and GPT-6.2 Sol on November 18, so you can try them today in your existing workspace without a separate OpenAI plan.
Here is the part nobody puts in the launch post.
On the independent coding numbers, Astra is flat against the model it replaces, and Sol went backward.
GPT-6.2 is a pricing and professional-documents upgrade, not a coding upgrade, and you should test it on your own work before you move anything.
That is the whole post in one line. The rest is the evidence, the numbers, and a test you can run in an afternoon.
What OpenAI shipped on November 17
Start with the facts, because two model names in one launch confuses people.
Astra is the top of the line. OpenAI calls it "our new frontier model for your hardest projects." Sol is "our efficient, versatile model for everyday work." Astra replaces GPT-6 Astra. Sol replaces GPT-6.1 Sol. If you already use one of those, the new one is the next version of the same slot.
The specs that matter, as OpenAI states them:
| Detail | GPT-6.2 Astra | GPT-6.2 Sol |
|---|---|---|
| Job | Hardest professional projects | Everyday technical and non-technical work |
| Replaces | GPT-6 Astra | GPT-6.1 Sol |
| API model ID | gpt-6.2-astra |
gpt-6.2-sol |
| Input, per million tokens | $8 | $2 |
| Cached input, per million tokens | $0.40 | $0.10 |
| Output, per million tokens | $40 | $10 |
| Price change from predecessor | Input and output down 20%, cached input down 60% | Unchanged |
| Available in Magai | Yes, all users | Yes, all users |
OpenAI also says both models reach developers through GitHub Copilot and Amazon Bedrock. Those rollouts are on the GitHub changelog and in AWS's announcement.
The launch announcement does not publish a context window for these two models. The last Sol in Magai's model list carries a 1.05 million token window, and nothing in the announcement says that changed, but check OpenAI's model docs before you build around a number.
Astra got cheaper and Sol did not, and that is the point
Sit with the pricing for a minute, because it is the most unusual part of the launch.
OpenAI cut Astra's input and output prices by 20% and cut cached input by 60%. It left Sol alone. Here is how the models line up, using the standard API rates from OpenAI's pricing page as reported at launch:
| Model | Input | Cached input | Output |
|---|---|---|---|
| GPT-6.2 Astra | $8 | $0.40 | $40 |
| GPT-6 Astra | $10 | $1.00 | $50 |
| GPT-6.2 Sol | $2 | $0.10 | $10 |
| GPT-6.1 Sol | $2 | $0.10 | $10 |
Per token, Astra is four times the price of Sol. That sounds like a clean rule: pay four times as much for the better model.
It is not that clean, and OpenAI knows it. The pitch in the announcement is that both models "deliver better results on demanding tasks with fewer output tokens." A model that finishes a job in fewer tokens can cost less per job even at a higher rate per token.
Here is the arithmetic on a workload you can check yourself. Take 1,000 requests, each with 10,000 uncached input tokens and 2,000 output tokens. That is 10 million input tokens and 2 million output tokens.
| Model | Input cost | Output cost | Total |
|---|---|---|---|
| GPT-6.2 Astra | $80 | $80 | $160 |
| GPT-6 Astra | $100 | $100 | $200 |
| GPT-6.2 Sol | $20 | $20 | $40 |
At equal token counts, the new Astra saves you $40 against the old one, and Sol does the same work for a quarter of Astra's bill. If Astra really uses fewer output tokens, as OpenAI says it does (22% fewer on its GDPval v2 benchmark), the gap in Astra's favor widens.
Two catches before you copy that math into a budget.
Requests above 272,000 input tokens cost more. Per the pricing page, long-context requests double the input and cache prices and multiply output by 1.5 for the whole request. For Astra that works out to $16 in and $60 out.
And the service tier changes the bill. Batch is half the standard rate. Fast and Ultrafast cost more. A launch-day price table is the floor, not your invoice.

If you are weighing this against a subscription instead of the API, the numbers live in ChatGPT pricing, which walks through every plan and what each one buys.
What the benchmarks say, and who is saying it
Benchmarks come in two kinds at a launch: the ones the vendor reports and the ones somebody else runs. You want both, and you want to know which is which.
Start with what OpenAI reports. These are vendor numbers, and some come from OpenAI's own internal benchmark.
| Evaluation | What OpenAI reports |
|---|---|
| Agents' Last Exam | Astra scores 5.2 points above GPT-6 Astra at less than a third of the cost, and 5.5 points ahead of Claude Fable 5.2 at 5% of the cost |
| Terminal-Bench-Science 0.1 | Astra scores 9 points above GPT-6 Astra at less than a third of the cost |
| GDPval v2 (OpenAI internal) | Astra gains 6.2 points over GPT-6 Astra with 22% fewer output tokens, Sol gains 5.3 points over GPT-6.1 Sol |
| FrontierCode 2.0 | Sol comes within 0.5 points of Astra at about one fifth of the cost, both at max effort |
| AA-3D (human preference) | Astra first at 1,318 Elo, Claude Fable 5.2 at 1,271, Sol at 1,259 |
| Harvey LAB-AA (legal work) | Astra sets a new high, more than doubling Claude Fable 5.2's pass rate at about one sixth the cost |
Read that table with one rule: the cost comparisons come from OpenAI's own charts. "5% of the cost" is OpenAI's measurement of OpenAI's run against Anthropic's model, on a benchmark OpenAI chose to feature.
That does not make it false. It makes it a claim to check.
Now the independent view. Artificial Analysis, which runs its own evaluations, put out its own breakdown on launch day. On its Intelligence Index, as reported at launch:
| Model | Intelligence Index score |
|---|---|
| Claude Fable 5.2 | 65 |
| GPT-6.2 Astra | 62 |
| Gemini 4 Carbon | 60 |
| Claude Opus 5.5 | 59 |
| GPT-6.2 Sol | 57 |
Astra gained 5 points over GPT-6 Astra and Sol gained 2 over GPT-6.1 Sol. Astra lands second overall, three points behind Claude Fable 5.2, and Artificial Analysis says it holds most of the cost per task frontier.
Put the two views next to each other and you get a clear read.
OpenAI's chart says Astra beats Claude Fable 5.2 on the work it picked. The independent index says Claude Fable 5.2 is still three points ahead overall. Both can be true. They measure different things.
My read: Astra is the best value in the top tier and probably not the best model in it. If you choose on quality alone, the independent index does not give OpenAI the top spot. If you choose on quality per dollar, it does.
The coding result nobody is leading with
Now the part that should slow you down.
Artificial Analysis also runs a Coding Agent Index, using the Codex harness at maximum effort. The result: GPT-6.2 Astra came in flat against GPT-6 Astra, and GPT-6.2 Sol lost 3 points against GPT-6.1 Sol. A 14 point drop on a benchmark called SWE-Atlas-QnA-AA drove most of Sol's decline.
Read that twice if you write code for a living.
OpenAI's announcement talks about cleaner code style, more focused tests and fewer rounds of revision, and its partners say the same. Those are real observations from real testers. They are also a different thing from scoring higher on a coding index.
The early public reactions split along the same line. Developer Theo said he would not choose Astra over Claude Opus 5.5 for his own development work, after a seven day run on a compiler rewrite that did not land an improvement. He also said Astra built a reverse proxy he expects to save him $25,000 a month and caught review issues other models missed.
Ethan Mollick found Astra uneven and harder to steer than other models, though it delivered on a space elevator project built from scratch in Blender and Unity.
Those are a handful of early testers on tasks of their own choosing. Treat them as a prompt to run your own test, not as a ruling.
The thing to take from the split is simple. A model can write tidier code and still solve fewer of your tickets. If your work is mostly coding, keep your current default until your own tasks say otherwise.
Three other places the numbers should make you careful
Three more results from the independent and official sources belong in your decision, because they bite in production and not in demos.
Hallucination on AA-Omniscience went up for Astra. Artificial Analysis measured the rate at maximum effort: 59% for GPT-6.2 Astra and 55% for GPT-6.2 Sol. Astra's figure rose from 50% for GPT-6 Astra. These rates describe that specific test, not your error rate in production, but a number that moves the wrong way on a factual-recall test is worth knowing before you trust the model with citations.
Both models sometimes skip telling you about a blocker. OpenAI's own safety section says that in two tests the models were more likely to omit mentioning obstacles that blocked their work, such as a missing file or an unavailable search tool. OpenAI added instructions in Codex that reduce the omissions and says it is still investigating. If you run an agent that touches files or tools, log whether it tells you when something was missing. A model that quietly finishes the wrong job is worse than one that stops.
The cyber safeguards are tighter, and they will block some legitimate security work. Both models meet OpenAI's Critical threshold for cybersecurity under its Preparedness Framework, and the company launched them with tighter safeguards for higher-risk cyber requests. Those protections, in OpenAI's words, "restrict some legitimate vulnerability research and security testing workflows." Approved defenders can still reach older models through Daybreak, and OpenAI says it will work to bring the 6.2 models there. If you do security research, plan on that friction.
OpenAI also says Astra is its first externally released model to meet the High threshold for AI self-improvement, which it defines as roughly giving every OpenAI researcher a very capable extra research engineer. Both models meet the High threshold for biological and chemical capabilities. The details are in the system card.
For most readers none of that changes the daily decision. It does tell you what kind of model this is, and who built the guardrails around it.
What actually changed from the last Astra and Sol
Strip out the benchmarks and the safety language, and the practical differences come down to a short list. This is what OpenAI says it improved, in terms you would notice on a Tuesday.
- Documents, slides and spreadsheets read less like AI. OpenAI says it trained Astra to follow your template and the conventions of fields like law, sales, finance and accounting, with less filler and more specific takeaways. The announcement says Astra can match a slide layout, colors and typography from an original file or even a screenshot.
- Computer use is more precise. OpenAI says Astra can work down to individual parts and connections in CAD and simulation tools. Its demos include a Blender driving simulation and an assembly guide for an RC buggy built from public photos and manuals.
- Web design and 3D work improved. The announcement shows a configurator site, a playable racing game and a browser Colosseum. These are OpenAI's chosen demos, so treat them as the best case.
- Token efficiency is the through line. Nearly every claim comes with "fewer output tokens." Partners quote it too. Legora says Astra used 62% fewer tokens than the last Sol on complex legal agent tasks. Harvey says it completed more than three times as many Legal Agent Benchmark tasks with 34.5% fewer output tokens. ClickUp reports about 40% fewer tokens and 30% fewer review rounds.
- Sol is the new daily driver. OpenAI says many of its employees use Sol as their default for technical and non-technical work, and that on its LifeVal everyday-tasks benchmark Sol outscores GPT-6 Astra at about one seventh the cost.
Partner quotes in a launch post are chosen by the vendor. They tell you the best result a customer got, which is useful as a ceiling and useless as an average.
Still, the pattern is consistent enough to take seriously. The upgrade is aimed at people who produce documents, decks and reports, and at teams who care what a finished task costs.
How GPT-6.2 compares with Claude Fable 5.2 and Gemini 4 Carbon
You are probably not choosing between two OpenAI models in a vacuum. The question is whether to move work off whatever you use now.
Here is the head to head on the numbers we have, with each source named:
| Model | Independent index score | Where it stands out | What to watch |
|---|---|---|---|
| Claude Fable 5.2 | 65 | Highest overall on the independent index | OpenAI's own charts put its cost per task far above Astra's |
| GPT-6.2 Astra | 62 | Cost per task, professional documents, 3D and web builds | Coding flat, hallucination test rate up |
| Gemini 4 Carbon | 60 | Close behind Astra on the index | Not covered in OpenAI's launch charts beyond one benchmark bar |
| Claude Opus 5.5 | 59 | A strong coding favorite among early testers | Behind Astra on the overall index |
| GPT-6.2 Sol | 57 | Near-Astra coding results at about one fifth the cost on FrontierCode 2.0 | Lost 3 points on the Coding Agent Index |
The honest takeaway is that no single row wins every column. That is the same pattern we saw when Google shipped its fast model, which we covered in Gemini 4 Hydrogen: what it is and who should use it. A new model leads on the thing its maker optimized for and trades off somewhere else.
If you are deciding between the big three assistants for daily work, our ChatGPT vs Claude vs Gemini comparison covers plans, limits and what each is best at, and Claude vs ChatGPT goes deeper on the one comparison most readers actually face.
The pattern that holds across all of them is the one that matters most: the best model depends on the task, and it changes every few weeks.
Who should switch to GPT-6.2 now, and who should wait
You have a real decision to make, so here is a rule for each kind of reader. Find yours.
| If you are... | Do this | Why |
|---|---|---|
| Producing decks, memos, spreadsheets or legal and finance documents | Test Astra this week | This is where OpenAI's training and its partners' evidence point |
| Running high volume API work on the previous Astra | Test Astra against it on your own prompts | The 20% price cut and the cached input discount are real money at scale |
| Using Sol as your everyday model | Swap to the new Sol and watch coding tasks | Same price, but the coding index slipped |
| Writing code all day | Keep your default, run a side by side first | Independent coding results are flat or lower, and early reactions are split |
| Doing security research | Plan for refusals | The launch added tighter cyber safeguards |
| Trusting a model with facts and citations | Verify everything | The hallucination test rate rose for Astra |
If you are not sure which row is yours, you are probably in the first one or the last one. Most people who write for a living are the first. Anyone who has ever pasted a model's citation into a document without checking it is the last.
One objection comes up every time a model like this ships: "It's a benchmark bump, my work won't change." Fair, for a lot of readers. If the model you use now already does your job, a three point index gain should not move you. Wait until your own task fails, then test.
Where that stops being true is cost. If you pay per token, a 20% cut on the top model and a 60% cut on cached input is not a benchmark story. It is a line on your invoice.
Run the five task test before you change anything
A launch post cannot tell you whether the model is better at your work. Only your work can. Here is a test that takes one afternoon, and it works for any new model, not just this one.
Pick five tasks you did in the last two weeks. Real ones, with real files. Make them different from each other:
- A document you produced from a template or a brief.
- A spreadsheet or report with a right answer you can check.
- A piece of code with a test you can run.
- A factual question where you can verify the sources.
- A long messy task with a missing piece, like a file you forgot to attach.
That last one matters more than it looks. It is the test for the blocker problem OpenAI itself flagged. Leave something out on purpose and see whether the model tells you.
Run each task on the new model and on the one you use today, with the same prompt and the same files. Score each result on three things: did it finish, was it right, and how many rounds of fixing did it take. Write the scores down. Trust the sheet, not your memory.

The reason most people skip this is the tab problem. Running the same five tasks across two vendors means two apps, two sets of uploads, and no memory of what you told the first one. By task three you have lost the thread.
That is the job Magai does well. You can put both models in one thread, switch between them mid-conversation, and the conversation's context carries over when you change models. Type /GPT to call the OpenAI model and /Claude to call the other, ask the same question twice, and read the answers one under the other with your files still attached. Our walkthrough on switching between AI models in one workflow shows the steps.
How to try it today in Magai
GPT-6.2 Astra and GPT-6.2 Sol are live in Magai for every user, added on November 18. You do not need a separate OpenAI subscription or API key. Open any chat, pick GPT-6.2 Astra or GPT-6.2 Sol from the model picker, and start.
Here is the fast way to use them:
- Open a new chat in Magai and select GPT-6.2 Astra for your hardest task, or GPT-6.2 Sol for everyday work.
- Attach the files from your five task test, so both models see the same material.
- Run the first task, then switch to the model you use today in the same thread and run it again.
- Compare the two answers one under the other, and write down your scores.
Because the conversation's context carries over when you switch models, you do not re-upload files or re-explain the job. That makes the baseline you built before the hype easy to compare against the new models, in one place, with your own files.
If you want to see which models and tools come with your plan, the Magai pricing page has the details.
The next time a model like this ships
GPT-6.2 is a good model with a mixed record. It is cheaper at the top, strong on documents, and no better at code than what you have.
Do not rebuild your workflow around a launch. Run five tasks, write down the scores, and switch only when your own work says so.
Your next move is small. Pick the five tasks today, while the launch is still loud, and run them against what you use now.
More in Artificial Intelligence

Artificial Intelligence
Gemini 4 Neon: Price, Specs and Who Should Switch
Gemini 4 Neon is out and now in Magai. Specs, $3 and $15 pricing, benchmarks, where it loses, and who should switch.

Artificial Intelligence
Gemini 4 Hydrogen: What It Is and Who Should Use It
Gemini 4 Hydrogen is Google's fast, cheap Gemini 4 model, out November 12. Specs, price, benchmarks, where it falls short, and who should switch.

Artificial Intelligence
Perplexity vs ChatGPT: Pick by How They Fail
Perplexity vs ChatGPT: one cites sources you can click, the other sounds sure even when wrong. How each fails, what each costs, and a 20 minute test.