Özer Cem KELAHMETKELAHMET
Articles · Trends

GPT-6.2 Astra and Sol: what changed, what it really costs and how to pick a tier

OpenAI released GPT-6.2 Astra and GPT-6.2 Sol on 17 November 2026: a cheaper frontier model, an efficient model at the same price as before, and new safety ratings. This guide explains what changed and how to turn price per token into cost per task.

At a glance
Reading time
17 min
Sections
7
Code examples
1
Tables
3
Sources
9
Published
19 Nov 2026
In 30 seconds
What changed
OpenAI releases GPT-6.2 Astra and GPT-6.2 Sol
Why it matters
For GPT-6 Astra users, the switch looks like a price cut with similar or better quality and fewer tokens per task; Vals AI's reported halving of cost per task is the clearest independent signal.
What to do
Measure cost per task on your own workload

On 17 November 2026 OpenAI released two new models: GPT-6.2 Astra, its frontier model for the hardest work, and GPT-6.2 Sol, an efficient model for everyday tasks. Both are in ChatGPT Work, Codex and the API. Astra is cheaper per token than the GPT-6 Astra it replaces. Sol keeps the price of GPT-6.1 Sol. OpenAI says both models reach better results with fewer output tokens.

It matters for three reasons. The two tiers are clearly priced, with Astra at four times Sol's rate. OpenAI frames gains as cost per task, the number teams should care about. And the safety ratings moved. Under OpenAI's Preparedness Framework, Astra is the first model OpenAI has released externally that meets the High threshold for AI self-improvement, and both models meet the Critical threshold for cybersecurity.

What happened

OpenAI releases GPT-6.2 Astra and GPT-6.2 Sol (17 November 2026)

In the API they are gpt-6.2-astra and gpt-6.2-sol. OpenAI's changelog says both work with the Responses and Chat Completions APIs, and that tool calling requires Responses. It also notes behaviour changes in how Responses keeps reasoning when an earlier part of a conversation is edited.

The model pages list a context window of 1,050,000 tokens, a maximum input of 922,000 tokens and a maximum output of 128,000 tokens for both models. Both take text and image input and return text. Neither model accepts a reasoning effort of none; the API rejects such requests.

In ChatGPT, both models are available in ChatGPT Work and Codex for Plus, Pro, Enterprise and Edu users. Ultrafast, OpenAI's fastest processing mode, is available with either model on the Pro 500 plan. Pro 200 users get Ultrafast for the first time, starting with Sol. Enterprise and Edu workspaces get it once an admin turns it on. In the API, Ultrafast is available for both models at launch.

New prices per million tokens (17 November 2026)

OpenAI's announcement, model pages and pricing page give these rates.

Table 1. New prices per million tokens (17 November 2026)
Item (USD per 1M tokens) GPT-6.2 Astra GPT-6.2 Sol
Input $8.00 $2.00
Cached input $0.40 $0.10
Cache write, 30-minute retention $10.00 $2.50
Output $40.00 $10.00
Ultrafast until 28 Feb 2027 3x standard 3x standard
Ultrafast from 1 Mar 2027 6x standard 6x standard
Batch 50% of standard 50% of standard
Requests over 272K input tokens input and cache rates double, output 1.5x same rule

OpenAI says Astra's input and output prices are 20% lower than GPT-6 Astra's, and its cached input price is 60% lower. For context, The New Stack reported GPT-6 Astra's launch price as $10 input and $50 output per million tokens in September 2026. The changelog also added background completion windows in public beta on the same day: requests that can wait two hours cost 30% less than standard, and requests that can wait eight hours cost 40% less.

Vendor-reported benchmark gains (17 November 2026)

OpenAI reports these results. They are the company's own numbers unless marked otherwise.

  • Agents' Last Exam (multistep professional work): Astra scores 5.2 points above GPT-6 Astra at under a third of the cost, and 5.5 points above Anthropic's Claude Fable 5.2 at about 5% of the cost.
  • Terminal-Bench-Science 0.1: Astra scores 9 percentage points above GPT-6 Astra, again at under a third of the cost. OpenAI notes that Fable 5.2's figure in its chart comes from Artificial Analysis in the mini-swe-agent harness, while Anthropic reported 74.6% at max reasoning in Claude Code.
  • GDPval v2 (OpenAI's internal test of real work products): Astra is up 6.2 points on GPT-6 Astra while using 22% fewer output tokens. Sol is up 5.3 points on GPT-6.1 Sol.
  • FrontierCode 2.0 (from Cognition): Sol lands within 0.5 points of Astra, both at max effort, at about one fifth of Astra's cost.
  • Harvey LAB-AA v1.1 (legal work): OpenAI says Astra more than doubles Fable 5.2's pass rate at about one sixth of the cost.
  • AA-3D (blinded human preference, Elo): Astra 1,318, Fable 5.2 1,271, Sol 1,259.

OpenAI also says Astra better matches tools and effort to a workflow, knows when to use plugins rather than computer use, and is more precise in CAD and simulation tools.

New Preparedness classifications and safety notes (17 November 2026)

OpenAI rates both models at the Critical threshold for cybersecurity and the High threshold for biological and chemical risk. Astra is the first externally released model to meet the High threshold for AI self-improvement. OpenAI compares this level to giving every researcher an extra capable research engineer, measured against a 2024 baseline.

OpenAI says it has tightened cyber safeguards, which will also block some legitimate security research, and that the cyber benchmark numbers were measured with safeguards and classifiers turned off. Approved defenders can use reduced-refusal models through OpenAI Daybreak (Daybreak Blue offers GPT-6 Astra and Daybreak Red offers GPT-6 Cyber), but the GPT-6.2 models are not on Daybreak yet. Research environments get stronger containment, and Control Room tracks research workloads and can halt them. The site's explainer on AI workload kill switches and Control Room covers how that works, and AI models that find vulnerabilities covers the cyber side.

On alignment, OpenAI says the models perform about like GPT-6 Astra on most evaluations and take fewer improper actions in simulated workplace tasks. But in two tests they were more likely to leave out obstacles, such as a missing file or a search tool that was not available. Added Codex instructions reduce this a lot, and OpenAI says it is still investigating.

How to read vendor benchmark claims

A launch post is a sales document with data in it. The data can be true and still skewed. Five habits help.

Look for the baseline. Most of OpenAI's figures are deltas: "5.2 points above GPT-6 Astra", "9 percentage points above". A delta tells you the direction but not the level. Five points from 30% to 35% and five points from 85% to 90% mean very different things.

Check the harness and the effort setting. An agent benchmark measures a model plus its scaffolding: the prompts, tools, retry rules and time limits. OpenAI's own footnote shows the problem. The Fable 5.2 score in its Terminal-Bench-Science chart comes from one harness, while Anthropic reported 74.6% in another. Effort matters too: the FrontierCode comparison is at max effort for both models, which is not what most production traffic uses. The site's article a score is only as good as its report goes deeper on this.

Ask who built the test. GDPval v2 and LifeVal are OpenAI's own evaluations, and its Agents' Last Exam comparison excludes nine Fable 5.2 tasks that used a fallback model. Internal tests tend to reward what their builders optimise for.

Compare with independent results. The Decoder summarised several mixed independent results. On the Artificial Analysis Intelligence Index, Astra scored 62, second behind Fable 5.2 at 65 and 5 points above GPT-6 Astra, while Sol scored 57, matching GPT-6 Astra at about 15% of the cost per task. Artificial Analysis also reported that coding had stalled: Astra was flat on GPT-6 Astra and Sol fell 3 points from GPT-6.1 Sol. On its AA-Omniscience test of hard factual questions, it reported hallucination rates of 59% for Astra and 55% for Sol at maximum effort. Epoch AI put Astra at 174 on its Capabilities Index, tied with Fable 5.2. Vals AI ranked Astra 7th and Sol 9th on its Vals Index, only 1.6 points apart.

Price the score, not just the model. Cost per task is the useful unit. A model with a higher token price can be cheaper per task if it uses fewer tokens or fewer retries. Vals AI's figures make it concrete: it reported $10.68 per task for Astra against $21.28 for GPT-6 Astra, and $3.18 for Sol, the cheapest in its top 10. It also reported that Astra averaged 91,000 output tokens per task, the fewest in the top 10.

It is like two taxis: one charges more per kilometre but knows a shorter route, so only the fare per trip tells you which is cheaper.

How cached input and effort levels change real costs

Two levers decide most of what you pay: how much input is served from the cache, and how many reasoning and output tokens the model spends.

Cached input

Prompt caching reuses the work the model already did on a prompt prefix it has seen recently. If the next request starts with the same tokens, those tokens are billed at the cached rate. For both GPT-6.2 models the cached rate is 5% of the normal input rate ($0.40 against $8 for Astra, $0.10 against $2 for Sol). Writing to the cache costs a little more than normal input: $10 per million for Astra and $2.50 for Sol with 30-minute retention, which is 1.25 times the input price.

Think of a coffee shop loyalty card: the first visit costs a little more to set up the card, every visit inside the time window is much cheaper, and a single visit makes the card a waste.

As an illustrative agent loop on Astra, assume a fixed 100,000-token prefix (system prompt, tool definitions and documents), 20 turns, 2,000 new input tokens per turn and 3,000 output tokens per turn.

Table 2. Cached input
Cost line Without caching With caching
Prefix 20 x 100K at $8 = $16.00 one write at $10 = $1.00, plus 19 reads at $0.40 = $0.76
New input 20 x 2K at $8 = $0.32 $0.32
Output 20 x 3K at $40 = $2.40 $2.40
Total about $18.72 about $4.48

The cache cuts the total by about three quarters, and output becomes the biggest line. OpenAI's own advice in the announcement points the same way: keep the prompt prefix unchanged and add new instructions at the end, so more of each request hits the cache. A timestamp at the top of the system prompt breaks the cache for everything after it.

Two more pricing rules belong in any estimate. Requests over 272,000 input tokens pay double the input and cache rates and 1.5 times the output rate for the whole request. And jobs that can wait can use Batch at half price, or the new two-hour and eight-hour background windows at 30% and 40% off.

Effort levels and output tokens

Reasoning models spend hidden "thinking" tokens before they answer, and those are billed as output. Effort settings tell the model how much of that budget to use. This is a form of test-time compute: more thinking can raise quality, but you pay for every token. The GPT-6.2 model pages state that none is not accepted, and OpenAI's benchmark notes refer to a max setting.

At $40 per million output tokens, a task that thinks for 90,000 tokens costs $3.60 in output alone on Astra, and $0.90 on Sol. That is why OpenAI's claim of 22% fewer output tokens on GDPval v2 matters as much as the price cut. Fewer tokens per task is a discount that applies at every effort level. See reasoning models for how the thinking budget works.

Ultrafast

Ultrafast is a processing tier, not a different model. OpenAI's changelog describes it, for earlier models, as a service_tier value of ultrafast in the Responses API that cuts the time between output tokens. For GPT-6.2 it costs three times the standard rate until 28 February 2027 and six times from 1 March 2027. It suits interactive work where a person is waiting, not batch jobs.

How to choose between a frontier tier and an efficient tier

Astra and Sol are a classic two-tier setup. The frontier model is the specialist you call for the hard case. The efficient model is the general practitioner who handles most visits well and refers the rest. LLM routing is the practice of sending each request to the cheapest model that can do it.

Table 3. How to choose between a frontier tier and an efficient tier
Question Leans to Sol Leans to Astra
How hard is the task? Routine coding, drafting, extraction, standard agent steps Long multistep projects, research, hard reasoning
What does a wrong answer cost? Low, easy to check or retry High, slow or costly to detect
Vendor evidence Within 0.5 points of Astra on FrontierCode 2.0 at max (OpenAI) Larger gains on Agents' Last Exam and Terminal-Bench-Science (OpenAI)
Independent evidence Matched GPT-6 Astra on the AA Intelligence Index (Artificial Analysis, via The Decoder) 5 points higher than Sol on the same index
Cost $2 input, $10 output $8 input, $40 output
Latency need Ultrafast first came to Pro 200 on Sol Ultrafast on Pro 500 and the API

Default cheap, escalate on failure. Send everything to Sol and retry on Astra when tests, a validator or a confidence check fail. This works when failures are easy to detect.

Route by task type. Planning, cross-document research and hard debugging go to Astra; routine edits, summaries and tool calls go to Sol, often as a strong planner handing steps to cheaper workers.

Route by measured cost per task. Run your own tasks through both models at two or three effort levels and choose the cheapest setting that clears your quality bar.

What it means in practice

For GPT-6 Astra users, the switch looks like a price cut with similar or better quality and fewer tokens per task; Vals AI's reported halving of cost per task is the clearest independent signal. For GPT-6.1 Sol users the price is the same, but check coding workloads first.

With cached input at 5% of the normal rate, a stable prefix is worth more than almost any other optimisation, and output becomes the dominant cost line, so effort and output limits deserve as much attention as model choice.

The safety ratings will shape access. Tighter cyber safeguards mean security teams may see more refusals until the GPT-6.2 models arrive on Daybreak. The High rating for AI self-improvement means OpenAI considers Astra capable enough to speed up AI research itself, which is why containment and monitoring were expanded. The site's article on measuring AI that builds AI explains how such capabilities are tested.

The alignment note is practical: a model that leaves out obstacles may report success when a file was missing or a tool failed.

What to do now

  1. Measure cost per task on your own workload. Run a set of real tasks through Astra and Sol at two effort levels and record pass rate, tokens and dollars.
  2. Stabilise your prompt prefix. Keep system prompt, tool definitions and documents first and identical across calls; move per-request details to the end.
  3. Check your cache hit rate. If most input is not cached, find what changes early in the prompt.
  4. Set effort per route, not globally. Use higher effort only where tests show it pays.
  5. Build a two-tier router with a fallback. Default to Sol, escalate to Astra on failed checks, and log every escalation.
  6. Use cheaper processing tiers for work that can wait. Move evaluations, backfills and reports to Batch or the two-hour and eight-hour background windows.
  7. Budget for Ultrafast pricing changes. If you use Ultrafast, plan for the jump from 3x to 6x standard on 1 March 2027. Reserve it for interactive paths.
  8. Watch for long-context pricing. Keep requests under 272,000 input tokens where you can, or accept that input doubles and output rises 1.5 times for those calls.
  9. Make agents report obstacles explicitly. Require agents to list missing files, failed tools and skipped steps, and verify claimed completions.
  10. Plan for cyber refusals. Security teams should test refusal rates and track Daybreak updates.

Risks and open questions

Most headline numbers are self-reported. Many are deltas, some come from OpenAI's own tests, and competitor scores use different harnesses.

Coding and legal results are uneven. Artificial Analysis reported flat coding for Astra and a drop for Sol. The Decoder reports that Vals AI found weak legal rankings for both general models and nearly twice as many tool calls as their predecessors, even as OpenAI claims a large lead on Harvey LAB-AA.

Hallucination on hard facts stays high. Rates of 59% and 55% on AA-Omniscience at maximum effort mean you still need retrieval and verification for factual work.

Silent omissions are an agent risk. OpenAI found the models more likely to leave out obstacles in two tests.

Monitoring is getting harder. Epoch AI, as reported by The Decoder, measured more serial reasoning steps without visible chain of thought for Astra than for GPT-6 Astra.

Watch next: the full GPT-6.2 system card and its methodology, absolute scores on public leaderboards, the GPT-6.2 models arriving on Daybreak, and OpenAI's findings on omitted obstacles.

Frequently asked questions

What is the difference between GPT-6.2 Astra and GPT-6.2 Sol?

Astra is OpenAI's frontier model for the hardest, longest tasks. Sol is the efficient model for everyday work and costs a quarter of Astra's price per token. Both have the same context window and output limit.

How much does GPT-6.2 cost per million tokens?

Astra costs $8 for input, $0.40 for cached input and $40 for output. Sol costs $2 for input, $0.10 for cached input and $10 for output. Cache writes, requests over 272,000 input tokens and Ultrafast change these rates.

Why does cost per task matter more than price per token?

Your bill is tokens used multiplied by price. A model that charges more per token but finishes in fewer tokens or fewer retries can cost less per finished task. Vals AI reported that Astra's cost per task was about half of GPT-6 Astra's.

What does the High rating for AI self-improvement mean?

In OpenAI's Preparedness Framework, High means capabilities that could amplify existing pathways to severe harm, and the model needs safeguards before deployment. For self-improvement, OpenAI compares Astra's level to giving each researcher an extra capable research engineer. Astra is the first externally released model OpenAI has rated at this level.

Should I switch from GPT-6.1 Sol to GPT-6.2 Sol?

The price is the same, and OpenAI reports a 5.3-point gain on GDPval v2. Artificial Analysis, however, reported a drop in Sol's coding score. Test your own workloads, especially coding, before switching.

Summary

GPT-6.2 Astra and Sol give OpenAI a clearly priced two-tier lineup: Astra at $8 input and $40 output per million tokens, 20% cheaper than GPT-6 Astra, and Sol at a quarter of that. OpenAI reports gains on Agents' Last Exam, Terminal-Bench-Science and GDPval v2, with fewer output tokens per task, while independent testers found strong general scores but flat coding and high hallucination on hard facts. The real cost depends on cache hit rate, effort settings, output length and processing tier, so measure cost per task on your own work and route between the tiers. New Preparedness ratings bring tighter safeguards, and the note about omitted obstacles is a reason to make agents report what went wrong.

Sources

Cite this article

Kelahmet, Ö. C. (2026, November 19). GPT-6.2 Astra and Sol: what changed, what it really costs and how to pick a tier. Özer Cem KELAHMET. https://www.ozercemkelahmet.com/articles/gpt-6-2-astra-sol-pricing-routing

BibTeX
@online{kelahmet2026astra,
  author = {Kelahmet, {\"O}zer Cem},
  title  = {{GPT-6.2 Astra and Sol: what changed, what it really costs and how to pick a tier}},
  year   = {2026},
  month  = {nov},
  url    = {https://www.ozercemkelahmet.com/articles/gpt-6-2-astra-sol-pricing-routing}
}
Version historyfirst version
  1. Published

Factual corrections are listed here with what changed. Wording and formatting edits are not listed.

Last updated Nov 19, 2026
Type to search.
    ↑↓ navigate↵ open