GPT-6.2 Astra and Sol Complete Guide: Model Specs, API Pricing, Claude and Gemini Comparison, and Codex Operations

GPT-6.2 Astra is 20% cheaper than GPT-6 Astra and gains 5 points on an independent index. Sol keeps its price and reaches the previous Astra's level. We cover API pricing, benchmarks, a Claude and Gemini 4 comparison, append-only API migration, and ChatGPT Work and Codex.

GPT-6.2 Astra and Sol Complete Guide: Model Specs, API Pricing, Claude and Gemini Comparison, and Codex Operations

Hello!

On November 17, 2026 (US time), OpenAI announced GPT-6.2 Astra and GPT-6.2 Sol. The update comes about two and a half months after GPT-6 Astra in September.

Performance, price, and speed. Here is how they line up against the previous models and the other vendors' flagship models.

GPT-6.2 Astra and Sol at a glance. Intelligence Index, API price, cost per evaluation task, and output speed, lined up against the previous GPT-6 Astra and GPT-6.1 Sol, Claude Fable 5.2 and Opus 5.5, and Gemini 4 Carbon. GPT-6.2 Astra scores 62.1 on the index, costs $8 for input and $40 for output, and $4.00 per task. Source: Artificial Analysis (retrieved November 18, 2026) and each vendor's official pricing page. Chart by Qualiteg
GPT-6.2 Astra and Sol at a glance. Intelligence Index, API price, cost per evaluation task, and output speed, lined up against the previous GPT-6 Astra and GPT-6.1 Sol, Claude Fable 5.2 and Opus 5.5, and Gemini 4 Carbon. GPT-6.2 Astra scores 62.1 on the index, costs $8 for input and $40 for output, and $4.00 per task. Source: Artificial Analysis (retrieved November 18, 2026) and each vendor's official pricing page. Chart by Qualiteg

First, to sum up these models in one sentence.

"GPT-6.2 Astra is 20% cheaper per token than GPT-6 Astra, gains 5 points on an independent composite index, and cuts the cost of one evaluation task to about two thirds. Sol keeps its price and reaches the same index level as the previous Astra."

That is the short version.

Now, let's start with API pricing.

Figure 1. GPT-6.2 Astra and Sol API pricing. Astra is $8 for input and $40 for output. Sol is $2 for input and $10 for output. Source: OpenAI official pricing page and model pages (as of November 18, 2026). Chart by Qualiteg
Figure 1. GPT-6.2 Astra and Sol API pricing. Astra is $8 for input and $40 for output. Sol is $2 for input and $10 for output. Source: OpenAI official pricing page and model pages (as of November 18, 2026). Chart by Qualiteg

GPT-6.2 Astra costs $8 for input and $40 for output, 20% less than GPT-6 Astra's $10 and $50. Cache reads went from $1.00 to $0.40, a 60% cut.

GPT-6.2 Sol costs $2 for input and $10 for output, carrying forward GPT-6.1 Sol's rates.

All prices in this article are in US dollars.

In September we published "What Is GPT-6 Astra? AGI, Pricing, and Claude Fable 5.1 Compared" and "GPT-6 Sol and Luna Explained," and last week "Claude Fable 5.2 Complete Guide."

In the Fable 5.2 article, we reported that Fable 5.2 took the top three spots on an independent composite index. GPT-6.2 Astra now sits inside that top three, and one evaluation task costs about one seventh of what Fable 5.2 costs at its highest setting.

The week before, Google's Gemini 4 lineup also reached three models. We cover it in "Gemini 4 Carbon, Argon, and Hydrogen: The Complete Guide." The price and performance comparison across the three vendors is in Chapter 7 of this article.

Our sources are OpenAI's official announcement, official docs, and system card, plus data from the independent evaluator Artificial Analysis.

It is a long article, so there is no need to read it from start to finish. Feel free to jump to the chapters that interest you.

Table of Contents

Part 1: What GPT-6.2 Astra and Sol Are

Part 2: Points to Know When Using the API

Part 3: GPT-6.2 in ChatGPT Work and Codex

What changed from GPT-6 Astra and GPT-6.1 Sol, in brief

Each chapter has the details. Here is the overall picture first.

Astra's per-token price dropped 20%
Input is $8 and output $40. Cache reads are $0.40, a 60% cut (Chapter 3)

Sol keeps its price, and the same paid plan now gets more work done
Input stays at $2 and output at $10 (Chapter 3, Chapter 16)

Top score on Agents' Last Exam, at less than a third of the previous cost
Astra scored 78.3%, 5.2 points above GPT-6 Astra (Chapter 4)

Second among labs on the independent composite index
On the Artificial Analysis Intelligence Index, Astra at max scores 62.1. It passed the top settings of Gemini 4 Carbon and Claude Opus 5.5 (Chapter 5)

It finishes the work with fewer output tokens
One index evaluation task takes about 40,000 output tokens and 10.4 minutes, half the time of GPT-6 Astra (Chapter 5, Chapter 6)

Astra reaches the previous model's top setting at medium, and passes Opus 5.5's top setting at high
Those are the second and third of five levels, with two more levels above (Chapter 6)

Cyber capabilities grew a lot, and the safeguards got stronger too
The rate of reaching arbitrary code execution on new vulnerabilities went from 31.5% to 53.5% (Chapter 8)

Astra reached High for AI Self-Improvement
It is the first externally released OpenAI model with that rating (Chapter 8)

If you rewrite history, the API now drops reasoning items
Building conversations by appending only is now the baseline (Chapter 9)

In ChatGPT, you use it in Work and Codex
New Work chats default to Sol (Chapter 15)


Part 1: What GPT-6.2 Astra and Sol Are

1. Astra for the hardest work, Sol as the everyday workhorse

The official announcement introduces the two models this way.

GPT-6.2 Astra is "our new frontier model for your hardest projects." GPT-6.2 Sol is "our efficient, versatile model for everyday work."

Both deliver better results on demanding tasks with fewer output tokens than before. That is the center of this announcement.

ModelPositioningAPI price (input / output)Previous model
GPT-6.2 AstraThe hardest projects, from start to finish$8 / $40GPT-6 Astra
GPT-6.2 SolThe go-to model for everyday work, from coding to agents at scale$2 / $10GPT-6.1 Sol
GPT-6.1 TerraThe lower-cost option$1 / $5
GPT-6 LunaLowest cost and latency$0.10 / $0.50

For Astra, the announcement puts the quality of deliverables front and center.

Its slides, spreadsheets, and documents "read less like AI," and more closely follow the templates you provide and the conventions of your field. It writes cleaner code and builds frontends that look and work better for websites, gaming, and 3D design. That is the description.

For Sol, the announcement says many employees at OpenAI use it as their default model for both technical and non-technical tasks.

The developer docs put the choice in one short sentence.

"Use GPT-6.2 Astra for the most demanding tasks or GPT-6.2 Sol for complex work at lower cost."

The Codex docs are one step more specific. Choose Astra to trace a bug across services, fix it, and test the change. Choose Sol to review a pull request or revise code in response to feedback.

The examples in the announcement are mostly hands-on work.

Building one Excel workbook with a revenue forecast through 2031 and a valuation from financial statements and operating assumptions. Producing a 19-slide pitch deck that matches a public slide template. Recreating the chassis dynamics of a car on a mountain road with a 3D model and a Python solver, then animating it in Blender. Modeling a radio-controlled buggy part by part from photos and build manuals and turning it into an animated assembly guide.

The announcement also lists more precise computer use, down to individual parts and connections in CAD and simulation tools, as one of the gains.

2. Basic specs at a glance

ItemGPT-6.2 AstraGPT-6.2 Sol
Model IDgpt-6.2-astragpt-6.2-sol
Context window1,050,0001,050,000
Maximum input922,000922,000
Maximum output128,000128,000
Knowledge cutoffMay 18, 2026June 1, 2026
Input and outputText and images in, text outText and images in, text out
Reasoning effortlow, medium, high, xhigh, maxlow, medium, high, xhigh, max
EndpointsResponses, Chat Completions, BatchResponses, Chat Completions, Batch
Tool callingSupported in the Responses APISupported in the Responses API
Zero Data Retention (ZDR)Supported for approved organizationsSupported for approved organizations
Data residencyUS and EU (Standard, Fast, Batch)US and EU (Standard, Fast, Batch)

The tools available in the Responses API are web search, file search, image generation, Code Interpreter, hosted shell, apply patch, skills, computer use, MCP, and tool search. The Multi-agent beta, which delegates work to subagents, is also supported.

On the feature side, you get streaming, structured outputs, function calling, image input, and prompt caching.

The context window and maximum output are the same numbers as GPT-6 Astra. Your token estimates carry over as they are.

Rate limits are the same for both models.

TierRPMTPM
Build5,0001,000,000
Launch10,0004,000,000
Grow15,00040,000,000

Ultrafast is counted against separate limits from Standard and Fast.

Beyond the OpenAI API, the models are offered on Microsoft Foundry, Amazon Bedrock, and GitHub Copilot (Chapter 18).

3. Astra is 20% cheaper, and cache reads are 60% cheaper

These are the Standard rates from the official pricing page, in US dollars per million tokens.

ModelInputCache read30-minute write12-hour writeOutput
GPT-6.2 Astra$8$0.40$10$20$40
GPT-6 Astra$10$1.00$12.50$25$50
GPT-6.2 Sol$2$0.10$2.50$5$10
GPT-6.1 Sol$2$0.10$2.50$5$10
GPT-6.1 Terra$1$0.05$1.25$2.50$5
GPT-6 Luna$0.10$0.01$0.125$0.25$0.50

"Write" is the cache write price. There are two retention periods, 30 minutes and 12 hours.

Figure 2. From GPT-6 Astra to GPT-6.2 Astra, input and output are 20% cheaper and cache reads are 60% cheaper. Source: OpenAI official pricing page and official announcement (November 17, 2026). Chart by Qualiteg
Figure 2. From GPT-6 Astra to GPT-6.2 Astra, input and output are 20% cheaper and cache reads are 60% cheaper. Source: OpenAI official pricing page and official announcement (November 17, 2026). Chart by Qualiteg

Input and output are 20% cheaper, and cache reads alone are 60% cheaper.

The cache read price went from 0.1 times the input price to 0.05 times. That brings it in line with Sol's ratio.

For agent work, this 60% cut matters most.

An agent rereads the same instructions, tool definitions, and past turns on every turn. Rereading 100,000 tokens of context costs $0.04 with GPT-6.2 Astra, down from $0.10 with GPT-6 Astra.

The announcement gives three reasons Astra's cost per task came down. Better token efficiency, the 20% cut on input and output, and the 60% cut on cache reads.

Sol's prices did not change. What changed is the number of tokens it uses for the same work. The announcement says it "lets you complete more tasks on the same paid plan."

Here are the prices by processing tier.

TierGPT-6.2 Astra (input / output)GPT-6.2 Sol (input / output)Versus Standard
Standard$8 / $40$2 / $10Baseline
Batch$4 / $20$1 / $5Half price
2-hour completion window (beta)$5.60 / $28$1.40 / $730% off
8-hour completion window (beta)$4.80 / $24$1.20 / $640% off
Fast$16 / $80$4 / $202x
Ultrafast (through February 28, 2027)$24 / $120$6 / $303x
Ultrafast (from March 1, 2027)$48 / $240$12 / $606x

The completion window rows are our own calculation from the pricing page's "30% below Standard" and "40% below Standard." How to use completion windows and Ultrafast is covered in Chapter 12.

There is one more thing, a surcharge on long inputs.

Input lengthGPT-6.2 Astra (input / cache read / output)GPT-6.2 Sol (same)
Up to 272,000 tokens$8 / $0.40 / $40$2 / $0.10 / $10
More than 272,000 tokens$16 / $0.80 / $60$4 / $0.20 / $15

When the input exceeds 272,000 tokens, input and cache rates double and output costs 1.5 times as much for the full request. It is the same rule as the three GPT-6 models.

Endpoints that process in a specified region carry a 10% uplift.

Here is everything that changed from GPT-6 Astra, item by item, in one table.

ItemGPT-6 AstraGPT-6.2 AstraChange
Input$10$820% off
Output$50$4020% off
Cache read$1.00$0.4060% off
30-minute cache write$12.50$1020% off
12-hour cache write$25$2020% off
Batch (input / output)$5 / $25$4 / $2020% off
Fast (input / output)$20 / $100$16 / $8020% off
Ultrafast (input / output)$60 / $300$24 / $120 (through February 28, 2027)60% off
Completion windowsNot covered30% off for 2 hours, 40% off for 8 hoursNew

4. Read OpenAI's published benchmarks together with cost

The numbers from here on are the ones OpenAI published in the charts of its official announcement.

Almost every chart in this announcement is drawn on two axes, score and cost per task. They show not only the score but also what it cost to get that score.

Let's start with the headline one, Agents' Last Exam. It measures whether a model can carry out multistep professional work over a long horizon.

Figure 3. Agents' Last Exam score and cost per task. GPT-6.2 Astra scores 78.3% at xhigh for $2.89. Source: OpenAI official announcement (November 17, 2026). Chart by Qualiteg
Figure 3. Agents' Last Exam score and cost per task. GPT-6.2 Astra scores 78.3% at xhigh for $2.89. Source: OpenAI official announcement (November 17, 2026). Chart by Qualiteg
Model (reasoning effort)ScoreCost per task
GPT-6.2 Astra (xhigh)78.3%$2.89
GPT-6.2 Astra (max)77.6%$4.47
Gemini 4 Carbon (high)77.4%$4.60
GPT-6.2 Astra (high)76.0%$2.05
GPT-6 Astra (max)73.1%$8.99
GPT-6.2 Sol (max)73.0%$1.32
Claude Fable 5.2 (max)72.8%$60.05
GPT-6.2 Astra (medium)72.1%$1.06
Claude Opus 5.5 (max)71.6%$17.57

Astra at xhigh scores 78.3%, the highest on this evaluation. That is 5.2 points above GPT-6 Astra at max, and the cost is $2.89 against $8.99, less than a third.

Compared with Claude Fable 5.2 at max, it is 5.5 points higher at about 5% of the cost. The Fable 5.2 result excludes nine tasks that used a fallback model.

Sol at max scores 73.0%, almost the same as GPT-6 Astra at max (73.1%). The cost is $1.32 against $8.99, about one seventh.

Here are the other evaluations, each model at its highest setting.

Figure 4. Six benchmarks published by OpenAI. GPT-6.2 Astra is near the top on score, and its cost per task ranges from $0.83 to $7.15. Source: OpenAI official announcement (November 17, 2026). Chart by Qualiteg
Figure 4. Six benchmarks published by OpenAI. GPT-6.2 Astra is near the top on score, and its cost per task ranges from $0.83 to $7.15. Source: OpenAI official announcement (November 17, 2026). Chart by Qualiteg
EvaluationGPT-6.2 AstraGPT-6.2 SolGPT-6 AstraClaude Fable 5.2Gemini 4 Carbon
Agents' Last Exam v1.177.6%73.0%73.1%72.8%77.4%
Terminal-Bench-Science 0.177.1%68.0%68.1%73.3%
BenchCAD 2.1 Core82.5%73.1%62.6%83.5%
AutomationBench 1.0.652.4%41.1%41.4%51.4%53.9%
FrontierCode 2.044.2%43.8%42.8%45.6%38.4%
Harvey LAB-AA v1.115.0%11.1%8.6%7.2%
LifeVal86.1%83.8%79.8%
GDPval v2 (OpenAI internal)50.4%46.9%44.2%44.8%48.8%

GPT and Claude are at max, and Gemini 4 Carbon is at high. For Terminal-Bench-Science, the Fable 5.2 value is the one measured by Artificial Analysis. Anthropic's own figure is 74.6% at max in Claude Code.

Astra has the highest score on five of the eight evaluations. On BenchCAD, AutomationBench, and FrontierCode, Fable 5.2 or Gemini 4 Carbon is ahead by one or two points.

Now the same table by cost per task.

EvaluationGPT-6.2 AstraGPT-6.2 SolGPT-6 AstraClaude Fable 5.2
Terminal-Bench-Science 0.1$7.15$2.21$23.80$45.21
BenchCAD 2.1 Core$5.43$1.60$9.71$50.77
AutomationBench 1.0.6$0.83$0.27$1.73$4.64
FrontierCode 2.0$5.97$1.29$6.68$44.70
Harvey LAB-AA v1.1$6.35$1.92$13.67$39.84

Four numbers stand out.

The first is 77.1% on Terminal-Bench-Science.

This evaluation measures whether a model can carry out scientific research work in a terminal, and Astra gained 9 points over GPT-6 Astra's 68.1%. The cost is $7.15 against $23.80, less than a third. The announcement says, "We believe GPT-6.2 Astra is the best model in the world for scientists."

The second is 82.5% on BenchCAD.

This evaluation measures hardware design, and Astra gained about 20 points over GPT-6 Astra's 62.6%. Fable 5.2 at max is one point ahead at 83.5%, at a cost of $50.77. Astra reaches almost the same score for $5.43, about one ninth of the cost.

The third is 15.0% on Harvey LAB-AA.

These are legal assignments with strict grading, where a deliverable passes only when it meets every grading criterion and contains no material hallucinations. Astra more than doubles Fable 5.2 at max (7.2%) at about one sixth of the cost.

The fourth is Sol on FrontierCode.

This evaluation measures whether changes to real codebases meet maintainers' standards for merging, and Sol at max scored 43.8%. That is within 0.5 points of Astra at max (44.2%), at $1.29 against $5.97, about one fifth of the cost.

On LifeVal, which measures everyday tasks, Sol outscored GPT-6 Astra.

LifeVal is built from everyday tasks such as shortlisting kindergartens after a move or finding a home that fits a budget and a commute. Sol at max scored 83.8%, higher than GPT-6 Astra at max (79.8%), at $1.27 against $9.04, about one seventh of the cost.

GDPval v2 is an OpenAI internal evaluation built from real projects in consulting, finance, design, and other sectors. Astra scored 50.4%, up 6.2 points from GPT-6 Astra, while using 22% fewer output tokens.

The body of the announcement also cites two results from Artificial Analysis evaluations.

On AA-AnalystAgent, which involves pulling figures from financial spreadsheets and reports and calculating with them, Astra answered 62.5% of the questions correctly on all five attempts. On AA-3D, where models build interactive 3D experiences in the browser from a written brief and human judges vote, the Elo scores are 1,318 for Astra, 1,271 for Fable 5.2, and 1,259 for Sol.

The customer comments in the announcement are mostly about cost and time.

Basis says, "Our average time for long-horizon accounting work fell by 50%, with the time for the most complex work falling up to 73%." Higgsfield AI says, "In our internal 3D generation evals, it achieved the target result in one shot in 73% of cases, while GPT-6 Astra needed three or more iterations."

We look at the independent numbers in the next chapter.

5. On the independent Intelligence Index, OpenAI moved up to second among labs

The independent evaluator Artificial Analysis published its evaluation article on November 17, the same day as the announcement. What follows is its public data as of November 18.

The Intelligence Index is a composite of nine evaluations that the company runs itself (v5.0.1).

The article's headline says OpenAI "has the #2 model in the Intelligence Index." The body sums it up this way. OpenAI now trails only Anthropic's Claude Fable 5.2, and its models occupy most of the Cost per Task Pareto frontier, the set of models that are most efficient on cost per task.

Figure 5. The top 13 on the Intelligence Index. GPT-6.2 Astra at max, xhigh, and high ranks 3rd, 5th, and 6th. Independent evaluation. Source: Artificial Analysis (retrieved November 18, 2026). Chart by Qualiteg
Figure 5. The top 13 on the Intelligence Index. GPT-6.2 Astra at max, xhigh, and high ranks 3rd, 5th, and 6th. Independent evaluation. Source: Artificial Analysis (retrieved November 18, 2026). Chart by Qualiteg
Model (reasoning effort)Intelligence IndexCost per taskTime per task
Claude Fable 5.2 (max)64.6$26.5440.8 min
Claude Fable 5.2 (xhigh)62.2$14.8325.5 min
GPT-6.2 Astra (max)62.1$4.0010.4 min
Claude Fable 5.2 (high)61.8$9.0814.6 min
GPT-6.2 Astra (xhigh)61.6$2.525.9 min
GPT-6.2 Astra (high)60.1$2.074.8 min
Gemini 4 Carbon (high)60.0$5.4833.4 min
Claude Opus 5.5 (max)59.1$10.0424.6 min
GPT-6.2 Sol (max)57.3$1.017.9 min
GPT-6.2 Astra (medium)57.0$1.623.7 min
GPT-6 Astra (max)56.9$6.2420.4 min
GPT-6.1 Sol (max)54.6$1.2723.1 min

Cost and time are weighted averages per evaluation task in the Intelligence Index.

Counting each combination of model and reasoning effort, Astra at max is 3rd of 91. Above it are Fable 5.2 at max and xhigh, so counting by lab puts OpenAI second.

Three things can be read from the table.

The first is the gain over the previous model.

GPT-6 Astra (max) scored 56.9, and GPT-6.2 Astra (max) scores 62.1. That is a gain of a little over 5 points, while the cost went from $6.24 to $4.00 and the time from 20.4 minutes to 10.4 minutes. Index, cost, and time all improved at once.

The second is the low cost.

Astra's $4.00 at max is about one seventh of Fable 5.2 at max ($26.54) and about 40% of Opus 5.5 at max ($10.04). Among the settings that score 60 or more, Astra at high has the lowest cost, $2.07.

The third is where Sol lands.

Sol at max scores 57.3, above GPT-6 Astra at max (56.9). The cost is $1.01 against $6.24, and the Artificial Analysis article describes it as "on par with GPT-6 Astra at ~15% of the Cost per Task."

The reason the cost is low is the small number of output tokens.

Model (reasoning effort)Output tokens per taskOutput speed
GPT-6.2 Astra (max)41,02965.7 tokens/s
GPT-6.2 Sol (max)40,36085.2 tokens/s
GPT-6 Astra (max)51,97342.4 tokens/s
Gemini 4 Carbon (high)122,76861.3 tokens/s
Claude Opus 5.5 (max)173,313117.5 tokens/s
Claude Fable 5.2 (max)273,776111.9 tokens/s

Astra at max finishes one evaluation task with about 40,000 output tokens. Fable 5.2 at max uses about 270,000. The output price is the same $40, so this difference in output volume is a major factor behind the difference in cost.

Output speed rose from 42.4 tokens per second to 65.7 for Astra, and from 48.9 to 85.2 for Sol. The speed values are averages over the most recent five days, so these are numbers from right after launch.

Here are the individual evaluations, highest setting against highest setting.

EvaluationGPT-6.2 AstraGPT-6.2 SolClaude Fable 5.2Claude Opus 5.5Gemini 4 Carbon
Terminal-Bench-Science 0.178.1%67.6%73.3%59.0%64.8%
AA-3D (Elo)1,3181,2591,2711,202
Harvey LAB-AA v1.115.0%11.1%7.2%4.2%
AA-AnalystAgent62.5%53.8%56.3%
AutomationBench-AA77.2%71.3%76.4%69.5%77.8%
Terminal-Bench 4.064.1%60.1%59.6%59.6%65.2%
FrontierCode-AA 2.045.4%44.4%48.8%46.4%40.6%
CritPt v2 Hard Subset71.5%62.5%76.5%68.0%69.0%
HLE-Diamond72.2%64.0%80.2%67.9%69.1%
AA-Omniscience (accuracy)68.6%61.6%79.1%65.5%58.3%
AA-Briefcase v1.1 (Elo)1,6431,6121,7851,8001,611

Astra leads on scientific research work (Terminal-Bench-Science), 3D generation (AA-3D), legal work (Harvey LAB-AA), and financial analysis (AA-AnalystAgent). The Artificial Analysis article also says that on the research preview AA-Robotics v0.1, Astra scored 79 and Sol 78, ahead of Fable 5.2 at 75.

On research-level physics problems (CritPt), depth of reasoning and knowledge (HLE-Diamond), and factual accuracy (AA-Omniscience), Fable 5.2 leads and Astra comes next. On AA-Briefcase, which grades business deliverables, Opus 5.5 and Fable 5.2 are at the top.

On FrontierCode-AA, Astra at xhigh scored 49.0%, higher than its 45.4% at max. That is about the same level as Fable 5.2 at high (49.1%).

There is also an evaluation of the models as coding agents.

The Artificial Analysis Coding Agent Index measures models running inside each vendor's coding agent. GPT-6.2 was measured in Codex.

Agent and model (reasoning effort)IndexCost per taskTime per task
Claude Code + Claude Fable 5.2 (xhigh)58.5$15.4753.3 min
Claude Code + Claude Opus 5.5 (max)58.2$12.6165.3 min
Antigravity CLI + Gemini 4 Carbon (high)55.5$7.1333.6 min
Codex + GPT-6.2 Astra (max)53.5$5.1225.1 min
Codex + GPT-6.2 Astra (xhigh)53.1$3.2016.5 min
Codex + GPT-6 Astra (max)53.1$7.6326.0 min
Codex + GPT-6.2 Sol (xhigh)49.8$0.9012.6 min

On this index, Astra delivers the same level of score as the previous model at a cost that came down from $7.63 to $5.12. At xhigh, it gets the same score for $3.20 in 16.5 minutes.

On the index score itself, the setups that run Fable 5.2 or Opus 5.5 in Claude Code are ahead. If you choose a coding agent by score, that points to Claude Code, and if you choose by cost and time, it points to Codex with Astra.

6. By reasoning effort, Astra reaches the previous model's top setting at medium

GPT-6.2 has five levels of reasoning effort, low, medium, high, xhigh, and max. Which level you use changes the score, the cost, and the time a great deal.

Artificial Analysis measured all ten settings.

Figure 6. Index and cost per task as reasoning effort goes up. GPT-6.2 Astra scores 62.1 at max for $4.00. Independent evaluation. Source: Artificial Analysis (retrieved November 18, 2026). Chart by Qualiteg
Figure 6. Index and cost per task as reasoning effort goes up. GPT-6.2 Astra scores 62.1 at max for $4.00. Independent evaluation. Source: Artificial Analysis (retrieved November 18, 2026). Chart by Qualiteg
Reasoning effortAstra indexAstra costAstra timeSol indexSol costSol time
low45.7$0.661.4 min40.6$0.181.4 min
medium57.0$1.623.7 min52.7$0.413.1 min
high60.1$2.074.8 min54.9$0.564.3 min
xhigh61.6$2.525.9 min55.7$0.655.1 min
max62.1$4.0010.4 min57.3$1.017.9 min

Cost and time are per evaluation task.

Let's look at Astra first.

GPT-6 Astra scored 56.9 at max, its top level. GPT-6.2 Astra already reaches that level at medium, the second of five levels, with 57.0. The cost is $1.62 against $6.24, about one quarter, and the time is 3.7 minutes against 20.4 minutes.

One level up, at high, it scores 60.1 and passes Claude Opus 5.5 at max (59.1). The cost is $2.07 against $10.04, and the time is 4.8 minutes against 24.6 minutes.

Astra still has two levels above high, and at max it goes up to 62.1.

GPT-6.2 Astra reaches the previous model's top setting on a light setting, and passes Opus 5.5's top setting when you turn it up.

Going from high to xhigh adds $0.45 and gains 1.5 points. Going from xhigh to max adds $1.48 and gains 0.6 points. At max, the time is also nearly double that of xhigh.

On some individual evaluations, xhigh beat max. FrontierCode-AA was 49.0% at xhigh and 45.4% at max, and Terminal-Bench-Science was 78.6% at xhigh and 78.1% at max. On OpenAI's Agents' Last Exam too, 78.3% at xhigh was above 77.6% at max.

Astra is a model that delivers most of its gain by high or xhigh.

Sol keeps improving steadily all the way to max.

From 52.7 at medium, it goes to 54.9 at high, 55.7 at xhigh, and 57.3 at max. Even at max the cost is $1.01, lower than Astra at medium ($1.62).

Sol at max scores 57.3 and Astra at medium scores 57.0, about the same level. Sol at max costs less, and Astra at medium takes less time (3.7 minutes against 7.9 minutes). You can choose Sol at max for lower cost, or Astra at medium for speed.

At low, the index drops sharply for both models.

Astra at low scores 45.7 and Sol at low scores 40.6, more than 11 points below medium. On OpenAI's LifeVal too, Sol scored 25.3% at low and 70.3% at medium. Apart from very light work, medium and above is the setting that fits well.

OpenAI's migration guide also says, "Start with medium for a new integration."

The time until the first answer token varies a lot with reasoning effort.

Reasoning effortAstraSol
medium2.7 s2.7 s
high15.0 s5.6 s
xhigh36.0 s19.0 s
max134.9 s57.6 s

A practical split is up to medium for interactive screens, and high or xhigh for agents that run in the background.

7. Comparing price and performance with Claude and Gemini 4

In November, the top models of all three vendors were updated one after another. Claude Fable 5.2 on November 9, the general availability of Gemini 4 Carbon on November 10, Gemini 4 Hydrogen on November 12, and then GPT-6.2 on November 17.

This chapter puts the three vendors' current models in the same tables. That is four models from Anthropic, three from Google, and two from OpenAI.

The numbers come from each vendor's official pricing page and from Artificial Analysis's public data (as of November 18).

First, the prices side by side

These are each vendor's standard rates, in US dollars per million tokens.

Figure 7. API prices of the three vendors' current models. GPT-6.2 Astra has the same $8 input and $40 output as Claude Fable 5.2, and GPT-6.2 Sol has the same $2 and $10 as Sonnet 5.5 and Gemini 4 Carbon. Source: OpenAI, Anthropic, and Google official pricing pages (as of November 18, 2026). Chart by Qualiteg
Figure 7. API prices of the three vendors' current models. GPT-6.2 Astra has the same $8 input and $40 output as Claude Fable 5.2, and GPT-6.2 Sol has the same $2 and $10 as Sonnet 5.5 and Gemini 4 Carbon. Source: OpenAI, Anthropic, and Google official pricing pages (as of November 18, 2026). Chart by Qualiteg
ModelInputCache readOutputContextMax output
Claude Fable 5.2$8$0.20$401M128K
GPT-6.2 Astra$8$0.40$401.05M128K
Claude Opus 5.5$4$0.20$201M128K
Claude Sonnet 5.5$2$0.10$101M128K
GPT-6.2 Sol$2$0.10$101.05M128K
Gemini 4 Carbon (through November 30)$2$0.10$10About 1.05M65,536 (about 1.05M with long decode)
Gemini 4 Argon (through November 30)$2$0.10$10About 1.05M65,536 (same as above)
Gemini 4 Carbon and Argon (from December 1)$4$0.20$20Same as aboveSame as above
Gemini 4 Hydrogen$1.50$0.075$7.50About 1.05M65,536 (same as above)
Claude Haiku 5.5 (prompts up to 100,000 tokens)$0.10$0.01$0.501M128K

By price, the models fall into three bands.

The top band is $8 / $40, where Fable 5.2 and GPT-6.2 Astra have the same price. The middle band is $2 / $10, with Sonnet 5.5, GPT-6.2 Sol, and Gemini 4 Carbon and Argon at their introductory price. Below that are Gemini 4 Hydrogen and Haiku 5.5.

Opus 5.5 is $4 / $20, between the two bands. From December 1, Gemini 4 Carbon and Argon move to this price too.

Next, the conditions that change the price

The price table alone does not determine what you are billed. This table lists the points where the vendors' conditions differ.

ConditionOpenAI (GPT-6.2)Anthropic (Claude)Google (Gemini 4)
Long inputsAbove 272K tokens, input and cache double and output is 1.5x for the full requestFable 5.2, Opus 5.5, and Sonnet 5.5 keep the same price up to 1M. Haiku 5.5 is 5x above 100,000 tokensSame price up to 1M
How caching worksWrites are charged (30 minutes, 12 hours)Writes are charged (5 minutes, 1 hour)Implicit caching. Automatic from 4,096 tokens, with no write price listed
Cache read ratio0.05x input0.025x for Fable 5.2, 0.05x for Opus 5.5 and Sonnet 5.5, 0.1x for Haiku 5.50.05x input
Reasoning tokensBilled as outputBilled as outputBilled as output
Prices that change over timeUltrafast is 3x through February 28, 2027 and 6x from March 1No changes scheduled for the four current modelsCarbon and Argon double from December 1
BatchHalf priceHalf priceHalf price (Flex is also half price)
Faster tiersFast is 2x, Ultrafast is 3xFast mode is 2x (Fable 5.2 and Opus 5.5)Priority is 1.8x
Reasoning levelsFive levels, low to maxFive levels, low to maxThree levels for Carbon and Argon (low to high), four for Hydrogen (low to xhigh)
Free tierNoneNoneAvailable for Hydrogen

Three of these matter in practice.

The first is how long inputs are handled.

GPT-6.2 carries a surcharge above 272,000 tokens. Claude's Fable 5.2, Opus 5.5, and Sonnet 5.5 and Gemini 4 keep the same price up to 1M. If you send more than 300,000 tokens of context on every request, this difference shows up in the bill.

The second is the cache read price.

Fable 5.2 is $0.20 and GPT-6.2 Astra is $0.40, so even with the same input price, reads differ by a factor of two. For agents that reread a long context many times, Fable 5.2 costs less for the rereading. Astra lowers its cost through output volume, as we see next.

The third is the Gemini 4 price change.

The $2 / $10 for Carbon and Argon is an introductory price through November 30, and it becomes $4 / $20 from December 1. When you estimate costs for December onward, calculate with the new price.

One more point is that the same text becomes a different number of tokens on each model. The tokenizers differ by vendor, so the amount of text that fits in one million tokens is not the same. Anthropic explains that with the tokenizer used from Claude 4.7 onward, the same text becomes about 30% more tokens.

Comparing by the cost of running the same evaluation

Instead of the per-token price, we look at the cost of running the same evaluation tasks. These are Artificial Analysis Intelligence Index values, each model at its highest setting.

Figure 8. Index and cost per task for the three vendors' current models. GPT-6.2 Astra scores 62.1 for $4.00, and GPT-6.2 Sol scores 57.3 for $1.01. Independent evaluation. Source: Artificial Analysis (retrieved November 18, 2026). Chart by Qualiteg
Figure 8. Index and cost per task for the three vendors' current models. GPT-6.2 Astra scores 62.1 for $4.00, and GPT-6.2 Sol scores 57.3 for $1.01. Independent evaluation. Source: Artificial Analysis (retrieved November 18, 2026). Chart by Qualiteg
Model (reasoning effort)Intelligence IndexCost per taskOutput tokens per taskOutput speed
Claude Fable 5.2 (max)64.6$26.54273,776111.9 tokens/s
GPT-6.2 Astra (max)62.1$4.0041,02965.7 tokens/s
Gemini 4 Carbon (high)60.0$5.48122,76861.3 tokens/s
Claude Opus 5.5 (max)59.1$10.04173,313117.5 tokens/s
GPT-6.2 Sol (max)57.3$1.0140,36085.2 tokens/s
Claude Sonnet 5.5 (max)54.5$10.02285,387147.2 tokens/s
Gemini 4 Hydrogen (xhigh)53.9$3.16154,406172.4 tokens/s
Gemini 4 Argon (high)50.4$4.97116,36866.3 tokens/s
Claude Haiku 5.5 (max)36.5$0.41225,966256.9 tokens/s

The costs for Gemini 4 Carbon and Argon were calculated at the introductory price of $2 / $10, which runs through November 30. From December 1, the input, cache, and output prices all double, so with the same token usage the cost doubles as well.

Here is what the table shows, model by model.

Claude Fable 5.2 has the highest index. It scores 64.6, about 2.4 points ahead of GPT-6.2 Astra in second place. For work that goes after the upper limit of hard reasoning, Fable 5.2 is the first candidate.

GPT-6.2 Astra has the lowest cost among the models that score 60 or more, at $4.00. It delivers 62.1 at about one seventh of the cost of Fable 5.2, about 40% of Opus 5.5, and about 70% of Gemini 4 Carbon.

Gemini 4 Carbon scores 60.0 for $5.48. On the individual evaluations in Chapter 5, it led on AutomationBench-AA and Terminal-Bench 4.0. It also stands out for how few factual errors it makes, with an AA-Omniscience hallucination rate of 11.4%. GPT-6.2 Astra and Fable 5.2 are both around 59%, so the gap is large.

GPT-6.2 Sol scores 57.3 for $1.01. Its index is higher than Sonnet 5.5 at the same price (54.5, $10.02), at about one tenth of the cost.

Gemini 4 Hydrogen has an output speed of 172.4 tokens per second, the fastest among the models that score 50 or more. It also has a free tier.

Claude Haiku 5.5 is the fastest overall at 256.9 tokens per second, and its cost is the lowest at $0.41. It suits high-volume classification and extraction.

Even among models with the same $10 output price, the cost of one evaluation task ranges from $1.01 to $10.02, about a tenfold spread. The order of the prices does not decide the order of the costs. What decides it is the number of tokens used for one piece of work.

Choosing by use case

Here are the numbers so far, rearranged by use case.

Use caseCandidatesThe numbers behind the choice
Going after the upper limit of hard reasoningClaude Fable 5.2Top Intelligence Index at 64.6. HLE-Diamond 80.2%, CritPt 76.5%
Running hard work while keeping cost and time downGPT-6.2 AstraIndex 62.1, $4.00 and 10.4 minutes per task
Scientific research work, 3D, CAD, legal, financial analysisGPT-6.2 AstraLeads on Terminal-Bench-Science, AA-3D, Harvey LAB-AA, and AA-AnalystAgent
Business deliverables such as documents and decksClaude Opus 5.5Near the top on AA-Briefcase. Priced at $4 / $20
Choosing a coding agent by scoreClaude Code + Fable 5.2 or Opus 5.5Coding Agent Index 58.5 and 58.2
Choosing a coding agent by cost and timeCodex + GPT-6.2 Astra or SolAstra at xhigh, $3.20 and 16.5 minutes per task
An everyday workhorse at low costGPT-6.2 SolIndex 57.3, $1.01 per task
Question answering and lookups where the accuracy of factual knowledge matters mostGemini 4 CarbonAA-Omniscience hallucination rate of 11.4%
Sending more than 300,000 tokens of context on every requestClaude Fable 5.2 and Opus 5.5, Gemini 4Same price up to 1M
Speed-first conversation and high-volume processingGemini 4 Hydrogen, Claude Haiku 5.5172.4 tokens per second, 256.9 tokens per second

The index and cost values are from Artificial Analysis's evaluation conditions. The shortest path is to see which evaluation is closest to your own work, narrow the candidates to two or three, and try them.

The detailed specs and usage of the three Gemini 4 models are in "Gemini 4 Carbon, Argon, and Hydrogen: The Complete Guide."

8. Cyber capabilities and safeguards in the system card

The GPT-6.2 system card covers Astra and Sol in one document. Here we pick out the points that matter in practice.

OpenAI assesses capabilities that could lead to severe harm under a framework called the Preparedness Framework. These are the ratings this time.

CategoryGPT-6.2 AstraGPT-6.2 SolGPT-6 Astra
Biological and chemicalHighHighHigh
CybersecurityCriticalCriticalCritical
AI Self-Improvement (accelerating AI research)HighBelow HighBelow High

Biological and chemical and cybersecurity have the same ratings as GPT-6 Astra.

What changed this time is AI Self-Improvement. Astra is the first externally released OpenAI model to reach High.

The announcement explains what High means this way. The model's impact is "equivalent to giving every OpenAI researcher an additional, highly capable research engineer as an assistant, relative to their 2024 baseline."

Among the evaluations behind the rating, on MLE-Bench Revised, which involves solving machine learning tasks, Astra scored 96.06 and Sol 91.38, both above the reference level of 90. On Internal Research Debugging, which involves debugging internal research code, Astra scored 81.85% and GPT-6 Astra 78.05%.

External evaluators took part as well. On Epoch AI's index Astra scored 174 (GPT-6 Astra scored 169), and Vals AI assessed that the model is "unlikely to fully automate AI research, but could provide a larger productivity boost to researchers than previous models."

In step with this, OpenAI has also tightened its internal operations. It strengthened containment in its research environments, expanded monitoring of models' reasoning and actions, and introduced Control Room, a system that tracks research workloads and can halt them.

Next, cyber capabilities.

Figure 9. Growth in cyber capabilities and how the safeguards were tightened. The rate of reaching arbitrary code execution on new vulnerabilities went from 31.5% to 53.5%, and the rate of refusing requests that should be refused went from 68.2% to 98.5%. Source: GPT-6.2 System Card. Chart by Qualiteg
Figure 9. Growth in cyber capabilities and how the safeguards were tightened. The rate of reaching arbitrary code execution on new vulnerabilities went from 31.5% to 53.5%, and the rate of refusing requests that should be refused went from 68.2% to 98.5%. Source: GPT-6.2 System Card. Chart by Qualiteg
EvaluationGPT-6.2 AstraGPT-6.2 SolGPT-6 AstraGPT-6.1 Sol
ExploitBench Internal Port (arbitrary code execution success rate)53.5%50.5%31.5%21.5%
SEC-Bench Pro (reproducing vulnerabilities)86.75%88.34%85.4%78.8%
Sandbox Bench (internal evaluation)36.4%25.0%18.2%11.4%

These are values at maximum reasoning effort, with production safeguards turned off.

ExploitBench Internal Port uses V8 and Chrome vulnerabilities disclosed from June through August 2026, and counts only cases that reach arbitrary code execution as successes. Astra scored 53.5%, up 22 points from GPT-6 Astra's 31.5%. Sol scored 50.5%, more than double GPT-6.1 Sol.

On SEC-Bench Pro, Sol scored higher than Astra. In the cyber domain, Sol has almost the same level of capability as Astra.

According to the announcement, on DeepBinary, which involves finding vulnerabilities in 12 Windows system binaries, the total estimated bounty for the vulnerabilities Astra found was about $1,038,000, more than double GPT-6 Astra's roughly $438,000.

The API cost was about $4,072 against about $5,925, lower for Astra.

Defensive capabilities grew as well.

EvaluationGPT-6.2 AstraGPT-6.2 SolGPT-6 AstraGPT-6.1 Sol
SecureSWE (writing secure code)65.7%55.6%46.5%49.7%
PatchBench (fixing while preserving behavior)79.7%75.6%70.9%71.0%

These are OpenAI's published values for each model at max. OpenAI explains that this time it made writing secure code from the start, and producing patches that preserve intended behavior, a core focus of training.

As the capabilities grew, the safeguards got stronger.

The system card reports two values measured with the launch configuration.

MetricGPT-6.2 AstraGPT-6.2 SolGPT-6 Astra
Rate of refusing cyber requests that should be refused98.5%99.4%68.2%
Rate of answering legitimate cyber requests78.1%69.5%90.7%

The models now refuse almost every request that should be refused. In exchange, the rate of answering legitimate requests went down.

OpenAI explains that the range of refusals widens for dual-use requests, such as autonomous vulnerability discovery and developing exploit code that chains multiple vulnerabilities. If vulnerability research or security testing is your job, knowing this up front makes planning easier.

For defenders, there is a vetted program called OpenAI Daybreak.

ProgramWhat it offersHow GPT-6.2 is handled
Daybreak BlueFewer cyber refusals on supported general-purpose modelsCovers GPT-6 Sol and others. Blue approval does not change the GPT-6.2 configuration
Daybreak RedAdditional approval and strong identity verification. Looser settings and cyber-specific modelsThe reduced-refusal configuration of GPT-6.2 Astra is for organizations approved for Red

According to the announcement, what is currently accessible through Daybreak is GPT-6 Sol with reduced cyber refusals on Blue, the alpha for GPT-6 Astra, and GPT-6 Cyber on Red. OpenAI says it will work to bring the GPT-6.2 models to Daybreak.

For now, the division of labor is to use GPT-6 Cyber for approved vulnerability research, and GPT-6.2 for fixing code and secure implementation.

This table summarizes the mechanisms that affect people using the API or Codex.

MechanismWhat the user sees
Misuse detectionA two-stage classifier on every conversation. Responses judged high-risk are blocked
Streaming pauseIf signs of harm appear during generation, delivery pauses for a check and resumes if there is no problem
Behavior monitoringIn Codex, ChatGPT, and the Responses API, the model's reasoning and actions are monitored. If a serious problem is detected, the conversation is paused or ended
Resuming a conversationIn some products, the user reviews an explanation and a record of actions and decides whether to resume. A conversation stopped in the API is redone as a new conversation
Notifications for EnterpriseDetections can be received by webhook
Account-level actionsWarnings, additional monitoring, feature restrictions, suspension
Protection against distillationThe success rate of attacks that extract reasoning contents went from 54.0% on GPT-6 Astra to 0.2%

If you build an app on the API, we recommend passing a safety_identifier for each end user. Restrictions are then scoped to that user, which avoids having the whole app stopped because of one person's usage.

safety_identifier also matters for how reasoning items are handled, covered in Chapter 9.

Here are the safety evaluations that are close to practical use.

ItemGPT-6.2 AstraGPT-6.2 SolGPT-6 Astra
Prompt injection (rate of blocking attacks on a new, harder evaluation)84.67%91.65%44.98%
Serious improper actions in workplace tasks0.64%0.71%1.20%
Rate of repeating past failures (AgentReplay)12.30%12.14%27.14%
Rate of completing a prohibited action (Respecting Warnings)17.41%19.37%
HealthBench Professional (length-adjusted)66.365.964.7

Resistance to prompt injection improved a great deal. On a new evaluation where an attacker model refines its attack by querying the target up to 10 times, the rate of blocking went from 44.98% on GPT-6 Astra to 84.67% on Astra and 91.65% on Sol.

Serious improper actions in workplace tasks are about half the rate of the previous models. The rate of completing a prohibited action is described as the lowest of any model OpenAI has released.

If you build agents that read external web pages or email, it is worth remembering that Sol is more resistant to prompt injection.

The external evaluations involved the UK AI Security Institute, Irregular, SecureBio, Epoch AI, Vals AI, and others.


Part 2: Points to Know When Using the API

According to the migration guide, moving from GPT-6 Astra or GPT-6.1 Sol is mostly a matter of swapping the model ID.

On top of that, there is one change that affects your code. It is how reasoning items are handled when the conversation history is rewritten.

9. Rewriting history drops reasoning items

The "What's new" section of the migration guide is a single paragraph. That one paragraph has the biggest impact on implementation this time.

Starting with GPT-6.2, the API drops reasoning items when any of the following happens partway through a conversation.

  • The earlier conversation history is rewritten (a prefix change)
  • You switch to a less capable model
  • The end user changes
  • The organization changes

Reasoning items carry what the model thought over to the next request. When they are dropped, the model has to think the same things through again, which takes extra tokens and time. If rethinking does not get back to the original content, answer quality drops too.

It does not produce an error. It surfaces quietly, as a change in cost, time, and quality.

In Chapter 8 of last week's Claude Fable 5.2 Complete Guide, we introduced Fable 5.2's check for rewritten history. That one stops with a 400 error and this one drops the reasoning items and continues, but the design they ask for is the same.

Only append to the conversation. Do not rewrite what came before.

OpenAI calls this an append-only integration pattern.

A prefix change includes operations like these. Shortening a tool result. Rewriting a developer message. Replacing older turns with a summary. Changing tools, instructions, or text.format in the Responses API partway through.

The official guide has a table of common rewrites and how to replace them.

What you want to doThe approach that rewritesThe append approach
Change reasoning effort partway throughChange reasoning.effortAppend a configuration_update item to the input
Change the output format partway throughChange text.formatAppend the new schema with a configuration_update item
Change the available toolsChange toolsAdd tools with an additional_tools item. To restrict, use allowed_tools in tool_choice
Update the developer instructionsEdit the original developer messageAppend a new developer message
Compact the historyReplace older turns with your own summaryUse OpenAI compaction (/responses/compact, context_management)
Shrink past tool outputs or imagesTruncate items that were already sentShrink them before sending them the first time

Here is an example of changing reasoning effort partway through. This is the shape of the configuration_update item in the official guide.

{
  "type": "configuration_update",
  "reasoning": {
    "effort": "high"
  }
}

Keep the request's reasoning.effort at its original value, and append this item to the list of input items. Responses from then on run at the new reasoning effort.

For compacting history, if you use OpenAI compaction, the reasoning items are retained even though the prefix changes. If you use your own compaction, the guide recommends placing the compacted item at the end of the context, not before the recent turns.

Handling of the end user was added as well.

If the safety_identifier differs between the request that created a reasoning item and the request that reuses it, the item is dropped. The same applies if you supply it on only one of the two requests. During a conversation, either keep sending the same value or omit it from both.

You can check what is happening in your own app from the response.

input_transformations in the Responses API response lists the reasoning items the API removed from the input, and why.

ReasonWhen it happens
prefix_mismatchContent before the reasoning item was inserted or edited (GPT-6.2 and later)
end_user_mismatchThe safety_identifier differs between creation and reuse (GPT-6.2 and later)
model_mismatchYou switched model families, or moved to a less capable model in the same family
organization_mismatchYou reused an item from another organization
turn_boundaryThe item is from an earlier turn and the model is set to use only current-turn reasoning

Deleting whole items, or appending new items after the reasoning item, does not by itself trigger prefix_mismatch.

Switching models is handled differently depending on the direction. Within the same family, moving up to a more capable model preserves the reasoning if the other checks pass. Within GPT-6.2, that means moving up from Sol to Astra preserves it, and moving down from Astra to Sol drops it.

If you move conversations between models with a router, remembering "moving up keeps it, moving down does not" makes the design easier.

The append-only design also pays off for caching.

Prompt caching reuses the part that matches from the beginning of the request. If you change the prefix, nothing from that point on hits the cache. If you only append, you can use Astra's 60% cheaper cache read price for most of the conversation.

You can check why a request missed the cache with Prompt Cache Diagnostics. Set prompt_cache_options.comparison_response_id to the ID of an earlier response, and it returns where the two diverged.

10. Start reasoning effort at medium, and none is not accepted

GPT-6.2 has five reasoning effort levels, low, medium, high, xhigh, and max.

You set it with reasoning.effort in the Responses API and reasoning_effort in Chat Completions.

Both models reject requests that set none. Apps that used GPT-6 Sol without reasoning should switch to low.

The migration guide gives this guidance.

Your current settingWhere to start with GPT-6.2
A new integrationmedium
You used none or minimallow
Long-running agents or hard researchhigh or xhigh, after confirming the benefit with your own evals
You want to measure the model's ceilingmax

This is the example from the official guide, keeping the model ID and the reasoning effort setting.

curl https://api.openai.com/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "gpt-6.2-sol",
    "reasoning": {
      "effort": "medium"
    },
    "input": "Review this database migration plan and identify potential failure modes."
  }'

About xhigh, the reasoning guide says, "Only use when your evals show a clear benefit that justifies the extra latency and cost."

In the independent evaluation in Chapter 6 too, Astra delivered most of its gain by high. Start Astra at medium or high and Sol at medium, and move up a level when that is not enough. This approach also wastes the least on cost.

Tokens used for reasoning are not visible through the API, but they take up space in the context and are billed as output tokens.

The official guide recommends reserving at least 25,000 tokens for reasoning and outputs when you start experimenting with these models. If you set max_output_tokens too low, the request can hit the limit before any visible output is produced. In that case, the response's status is incomplete.

11. Tool calling needs the Responses API, and four parameters must be left out

GPT-6.2 works with both the Responses API and Chat Completions.

If you use tool calling, use the Responses API. Chat Completions can be used for exchanges without tools.

The parameters to leave out are defined per endpoint.

EndpointWhat to omit
Chat Completionstemperature, top_p, logprobs, top_logprobs
Responsestemperature, top_p, top_logprobs, and message.output_text.logprobs in include

If you are migrating from GPT-5.5 or earlier, the cache setting changes too. Replace prompt_cache_retention with prompt_cache_options.ttl set to "30m".

Zero Data Retention (ZDR) is available for approved organizations. With ZDR enabled, the Responses API treats store as false. For multi-turn conversations, pass the prior output items back in order. Passing the encrypted reasoning items back with them is what makes the reasoning carryover in Chapter 9 work.

For data residency, the US and EU are supported with Standard, Fast, and Batch. Ultrafast is processed in the US.

12. Tuning cost and speed with caching, completion windows, and Ultrafast

GPT-6.2 has three options for lowering cost and two for raising speed.

OptionEffectWork it suits
Prompt cachingReread input at 0.05x the priceAgents that read the same context many times
BatchHalf priceHigh-volume processing sent in bulk
Completion windows (2 hours, 8 hours)30% off, 40% offOne-off work that can wait a few hours
FastFaster at 2x the priceConversations where a person is waiting
UltrafastFaster still at 3x the price (through February 28, 2027)Uses where latency is the experience itself

Prompt caching

What can be cached is the beginning of a prompt of 1,024 tokens or more.

For writes, you can choose 30-minute or 12-hour retention. Astra's writes are $10 and $20, and reads are $0.40.

Calculating from the prices, a 30-minute write is 1.25 times the input price, so it pays for itself once you read the same context twice. A 12-hour write is 2.5 times, and it pays for itself after three reads. If you have the model read the same material many times within a day, 12-hour retention is the fit.

Completion windows

This time, discounted completion windows were added to background mode in the Responses API as a public beta. They cover GPT-6.2 Astra, GPT-6.2 Sol, GPT-6.1 Terra, and GPT-6 Luna.

WindowWhen to use itDiscount
soonest (default)A report someone is waiting forNone
2hAnalyze the morning's support tickets before an afternoon meeting30% below Standard
8hReview documents overnight and pick them up the next morning40% below Standard

To use them, set background to true and set background_options.completion_window to 2h or 8h. This is the basic form of a background request from the official guide.

curl https://api.openai.com/v1/responses \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{
  "model": "gpt-6.2-astra",
  "input": "Write a very long novel about otters in space.",
  "background": true
}'

As it stands, this request uses the default soonest completion window and gets no discount.

To get the discount, add the three parameters the guide specifies to the request body. For the 8-hour window, the body looks like this.

{
  "model": "gpt-6.2-astra",
  "input": "Write a very long novel about otters in space.",
  "background": true,
  "service_tier": "default",
  "background_options": {
    "completion_window": "8h"
  }
}

For the 2-hour window, set completion_window to 2h.

You get the result by retrieving it with the response ID that was returned, or by receiving the response.completed webhook.

Discounted windows come with three rules.

Use Standard processing (set service_tier to default). Send the request without stream. Rate limits are counted against the limit shared with Batch API jobs.

Cache entries created in a discounted window are managed separately from regular requests. Material you want cached should be read repeatedly within the same window.

Which to use, Batch or completion windows, depends on the shape of the work. For sending a large number of requests in bulk, Batch at half price, and for single jobs you want back within a few hours, completion windows. They also work for multistep jobs that return a tool result and continue.

Ultrafast

Ultrafast is the fastest service tier in the OpenAI API. The two GPT-6.2 models have supported it since launch day.

To use it, set service_tier to ultrafast. The official guide strongly recommends WebSockets for agents that make many tool calls in quick succession. Without a persistent connection, network overhead reduces the speed gain.

This is the Python example from the official guide, shortened to a single exchange (the model ID is GPT-6.2 Sol).

from openai import OpenAI

client = OpenAI()

with client.responses.connect() as connection:
    connection.response.create(
        model="gpt-6.2-sol",
        service_tier="ultrafast",
        store=False,
        input="Explain why the sky is blue in one sentence.",
    )

    for event in connection:
        if event.type == "response.output_text.delta":
            print(event.delta, end="", flush=True)
        elif event.type == "response.completed":
            print()
            break

The price is 3 times Standard through February 28, 2027, and 6 times from March 1 (Pacific time). For Astra, $24 / $120 becomes $48 / $240.

Ultrafast on GPT-6 Astra was $60 / $300. GPT-6.2 Astra's price during the introductory period is 40% of that.

According to the Codex docs, Ultrafast on GPT-6.2 generates tokens at up to 4.5 times the speed of Standard on the same model.

13. Behaviors to review when you carry prompts over

The migration guide lists four behaviors seen with GPT-6.2 Astra and gives an example prompt for each. They are the points to review when you carry over a system prompt written for GPT-6 Astra.

BehaviorWhat to review
Writing became more concise and directWhether instructions like "be concise" are now too strong
When intent is unclear, it may propose a next step and wait for confirmationFor longer tasks, tell it that it may make reasonable assumptions and keep working
Code became more efficient and higher qualityWrite down your project's conventions
It decides the look of a frontend on its ownSpecify the kinds of images and the typography to use

Writing became more concise

Astra writes more concisely by default than earlier models. According to the system card, the median response length went from 836 characters for GPT-6 Astra to 650 for Astra and 628 for Sol.

If you reuse a prompt that told GPT-6 Astra to "be concise," responses can end up too short. Remove that instruction, or add how much explanation you want.

During longer tasks, the model can carry shorthand from its working notes into the final answer. The migration guide includes an instruction that has it write the final answer as "the user's first look" at the work.

Treat your final answer as the user's first look at your work, and not as a continuation of intermediate commentary. The final answer must always be fully self-contained: users should never need to read earlier commentary updates for context, since they are collapsed when the final answer is shown to the user.

When you want it to proceed without waiting for confirmation

For work that can proceed without supervision, specify the outcome you want completed and the decisions that need the user's input. This is the example from the migration guide.

Avoid stopping to end the turn while the task is incomplete or if there is an authorized next step you can take, and instead take the next steps within task scope to progress the user's request.

Only stop to clarify with the user if there is significant change in task scope, you are concretely blocked, have a decision that the user needs to resolve, or before irreversible or destructive actions.

It narrows the cases where stopping is fine to four. A significant change in task scope, being concretely blocked, a decision the user needs to resolve, and the moment before irreversible or destructive actions.

If your app has an async question tool (such as request_user_input_async), GPT-6.2 can ask the user for clarification and continue the work that does not depend on the answer.

For the final checks on long tasks, higher reasoning effort helps the model persist. Putting a completion check in the instructions and setting reasoning effort to high or above is the combination the migration guide recommends.

Coding style

The migration guide's coding instructions have four items. Reuse existing logic. Add tests when requested, when the repo requires them, or when they catch a regression the existing tests would miss. Keep the code human readable. Avoid unnecessary indirection and abstraction.

Write your own project's conventions as additions to these. For example, how far to reuse existing functions, and how narrowly to scope a change.

Frontend design

Astra decides the look of web pages and apps on its own as it builds them. When you want a particular look, specify the kinds of images and the typography.

The migration guide recommends sharing a reference from your design software, or having the image generation tool create a reference image. A reference image fills in the details that are hard to describe in words.

14. Migration steps and a cost estimate

Here are the items from the migration guide, reordered as the steps for moving from GPT-6 Astra or GPT-6.1 Sol.

StepWhat to doIf you leave it as is
1Change the model ID to gpt-6.2-astra or gpt-6.2-solYou are not migrated
2Decide the reasoning effort. medium for new work, low if you used none or minimalRequests with none are rejected
3Do tool calling through the Responses APITools cannot be used in Chat Completions
4Omit the parameters that the API you use does not accept. For Chat Completions, temperature, top_p, logprobs, and top_logprobs. For Responses, temperature, top_p, top_logprobs, and message.output_text.logprobs in includeRequests fail
5For apps that assemble history themselves, check for dropped reasoning items in input_transformationsMore rethinking, more cost and time
6Keep safety_identifier at the same value throughout a conversationReasoning items are dropped
7Rework reasoning effort changes, added tools, and instruction updates into the append formCache misses, and reasoning is dropped too
8Review the system prompts you carry over against the points in Chapter 13Answers that are too short, waiting for confirmation too early
9Compare reasoning effort and cost again with your own evalsRunning at a higher level than needed

The migration guide also describes handing the migration to Codex. You invoke the OpenAI Docs skill with $openai-docs and ask it to migrate your project to the new model.

Finally, we update the estimate we have used in our earlier articles.

The conditions are one request with 10,000 input tokens and 2,000 output tokens, no caching, and excluding tool charges and the regional uplift. Output is calculated as the billable amount, including reasoning.

ModelInputOutputTotal
GPT-6 Astra$0.10$0.10$0.20
GPT-6.2 Astra$0.08$0.08$0.16
GPT-6.2 Astra (Batch)$0.04$0.04$0.08
GPT-6.1 Sol$0.02$0.02$0.04
GPT-6.2 Sol$0.02$0.02$0.04
Figure 10. Estimate for one request. GPT-6.2 Astra is $0.16, 20% cheaper than GPT-6 Astra. Source: our calculation from the OpenAI official pricing page. Chart by Qualiteg
Figure 10. Estimate for one request. GPT-6.2 Astra is $0.16, 20% cheaper than GPT-6 Astra. Source: our calculation from the OpenAI official pricing page. Chart by Qualiteg

Let's also calculate a case where caching helps. This is 100,000 cache read tokens, 5,000 new input tokens, and 2,000 output tokens.

GPT-6.2 Astra comes to $0.04 for cache reads, $0.04 for new input, and $0.08 for output, $0.16 in total. GPT-6 Astra comes to $0.10, $0.05, and $0.10 for a total of $0.25, so GPT-6.2 Astra is 36% cheaper.

The more you use the cache, the closer the saving moves from 20% toward 60%.

This estimate assumes the same number of tokens. In practice, GPT-6.2 uses fewer output tokens for the same work.

In the independent evaluation in Chapter 5, output per evaluation task went from about 52,000 tokens for GPT-6 Astra at max to about 41,000 for GPT-6.2 Astra at max, and the cost went from $6.24 to $4.00. The lower token volume comes on top of the 20% price cut.

Take work you ran on GPT-6 Astra at max and move it to GPT-6.2 Astra at high. Under the independent evaluation's conditions, the index goes up from 56.9 to 60.1, and the cost goes from $6.24 to $2.07, about one third. This is the most solid form of migration, improving both cost and performance.


Part 3: GPT-6.2 in ChatGPT Work and Codex

15. Available in Work and Codex on paid plans

ChatGPT has two entry points, Chat and Work.

Chat is for fast, conversational assistance and everyday questions. Work is an agent designed for longer, multi-step work and finished deliverables. Codex is dedicated to software development and technical work.

GPT-6.2 Astra and Sol were added to Work and Codex. To use GPT-6.2 in ChatGPT, open Work.

PlanGPT-6.2 in Work and Codex
PlusAvailable
ProAvailable
BusinessAvailable
Enterprise and EduAvailable once an admin enables the models in the workspace model settings

ChatGPT for Healthcare and FedRAMP workspaces are also listed in the rollout.

Work is available on web, mobile, and the desktop app. For Codex, the desktop app and the CLI are supported.

Before you start, update your apps. Update the desktop app through Menu > Check for Updates and restart it, and update Codex CLI to the latest version as well.

New Work chats default to Sol.

UserDefault modelDefault reasoning effort
Consumer plansGPT-6.2 SolLight
Enterprise workspacesGPT-6.2 SolMedium

To use Astra, choose it in the Work model picker. If the desktop app shows the Power slider, open Advanced to choose a specific model.

The ChatGPT release notes describe the changes in Work this way.

Astra follows your template more closely when turning source documents into slides, and writes titles that make each slide's point clearer. When you ask it to edit a document, it is better at matching the voice of your draft. Sol can combine text, images, and tools in a single piece of work.

The earlier models can still be selected. In Work and Codex, depending on your plan and workspace settings, you may see GPT-6.1 Sol, GPT-6.1 Terra, GPT-6 Sol, and GPT-6 Luna. A model you selected manually in Codex is kept as is.

16. Usage estimates, credits, Fast, and Ultrafast

Work and Codex share the same usage allowance.

The Codex pricing page gives estimates of messages per five-hour period. These are the values for Plus and Standard Business seats.

ModelEstimated messages per five hours
GPT-6.2 Astra6 to 50
GPT-6 Astra5 to 45
GPT-6.2 Sol17 to 180
GPT-6.1 Sol15 to 160
GPT-6.1 Terra35 to 285
GPT-6 Luna350 to 3,000

The range exists because the usage of a single message varies with how heavy the work is. Weekly limits may also apply.

Both Astra and Sol have estimates about 10% higher than the previous models. Sol's price is the same, so the reduction in tokens used for the same work shows up directly in the message count.

These are the rates for usage beyond the allowance, or when you pay with credits. They are credits per million tokens at Standard speed.

ModelInputCached inputOutput
GPT-6.2 Astra200101,000
GPT-6 Astra250251,250
GPT-6.2 Sol502.5250
GPT-6.1 Sol502.5250
GPT-6.1 Terra251.25125
GPT-6 Luna2.50.2512.5

Astra's credit rates came down by the same proportions as the API. Input and output are 20% lower, and cached input is 60% lower. Codex credit billing has no separate cache-write charge.

Speed modes change how fast the allowance is used.

SpeedGeneration speedAllowance usage (GPT-6.2)For reference: GPT-6 Astra
StandardBaseline1x1x
FastAbout 1.5x (Astra)2x2.5x
UltrafastUp to 4.5x6x8x

For both Fast and Ultrafast, the usage multiplier came down with GPT-6.2.

When you use Ultrafast with purchased credits, it is 3 times Standard through February 28, 2027, and 6 times from March 1.

These are the plans where Ultrafast is available.

PlanUltrafast on GPT-6.2 AstraUltrafast on GPT-6.2 Sol
Pro ($500 per month)AvailableAvailable
Pro ($200 per month)Available in Codex
Enterprise and EduAvailable with workspace creditsAvailable with workspace credits

This is the first time Ultrafast has been available on the $200 per month Pro plan. You can use Ultrafast on Sol in Codex.

On Enterprise and Edu, Ultrafast is a separate permission that an admin enables. A credit-based or US dollar usage-based agreement is required.

In Codex CLI, you switch with /fast and /ultrafast. Running the same command again returns you to Standard.

17. Choosing a model and reasoning effort in Codex

In Codex CLI, you choose the model at startup or partway through a session. This is the example from the Codex docs.

codex --model gpt-6.2-sol

Partway through a session, switch with /model. To make it the default in the config file, it is this one line.

model = "gpt-6.2-sol"

The default context in Codex differs by model.

ModelDefault context in CodexMaximum
GPT-6.2 Astra272,000 tokens1M tokens
GPT-6.2 Sol500,000 tokens1M tokens

Astra's default of 272,000 tokens is the same number as the threshold for the long-input surcharge in Chapter 3. To widen it, set model_context_window.

For work that has the model read a whole large repository, Sol is easier to work with because its default context is wider.

For reasoning effort, you choose from Light (Low in the CLI), Medium, High, Extra High, Max, and Ultra.

Max gives the selected model more time to reason about a single task. Ultra uses subagents to handle separate parts of a complex task in parallel. The Codex docs say, "Most tasks do not need Max or Ultra."

This is the guidance from the prompting guide for GPT-6.2 Astra.

WorkSuggested reasoning effort
A quick surveyMedium
Tracing one suspected cause across several systemsHigh
When several causes may interactExtra High

In the CLI, after choosing a model with /model, select "More reasoning…" to see the higher levels that model supports.

The split between the models is as introduced in Chapter 1. Astra for tracing and fixing a bug across services, and Sol for reviewing pull requests and revising code in response to feedback.

Codex instructs the model to report obstacles in its work.

The system card includes an evaluation called Blocker Deception. It introduces an obstacle into a coding task on purpose, such as removing the file the agent was asked to edit, and checks whether the model tells the user about it.

ConditionGPT-6.2 AstraGPT-6.2 SolGPT-6 Astra
With the Codex developer prompt8.04%8.88%
Without the developer prompt22.28%24.08%11.09%

This is the rate of not disclosing the obstacle, so lower is better.

With the Codex developer prompt, Astra goes from 22.28% down to 8.04%, and Sol from 24.08% down to 8.88%. Those are lower than GPT-6 Astra's 11.09%.

OpenAI built this instruction into Codex. As long as you use the models in Codex, there is nothing you need to do.

When you use the models directly through the API, we recommend putting an instruction to the same effect in your own system prompt. The Codex developer prompt is not applied to API requests.

What you add can be short. When the model hits an obstacle, such as a missing file, an unavailable tool, or a failed search, it writes that in its report before continuing the work. That one point.

OpenAI sees its tuning to make responses concise and cut down on caveats as related to this behavior. It has the same root as the "more concise" change we saw in Chapter 13.

In Artificial Analysis's measurements, Codex with GPT-6.2 Astra averaged 51.0 steps per task. That is about half of the 94.7 for Claude Code with Fable 5.2 (xhigh). The tendency to finish work in fewer moves holds for coding agents too.

GitHub also published results from its early testing in Copilot. In code review, Sol found nearly twice as many real issues as GPT-6.1 Sol while keeping its findings accurate. Astra found more issues than GPT-6 Astra and finished agentic coding work with visibly fewer tokens. That is the gist.

18. Astra for Law, Foundry, Bedrock, and Copilot

Astra for Law

On the same day, November 17, Astra for Law, the configuration for legal work, was updated too.

Astra for Law pairs GPT-6.2 Astra with an expanded legal search index and instructions for the steps from research to conclusion. The model ID is gpt-6.2-astra-law.

ItemDetails
Who can use itChatGPT Enterprise customers request it through the Trusted Access Program in the admin console. API access can also be requested
API price$8 input, $0.40 cache read, $40 output (promotional pricing at least through December 31, 2026)
Harvey LAB-AAFirst at 20.8% (GPT-6.2 Astra is 15.0%)
Material hallucinations0.03 per assignment (GPT-6.2 Astra is 0.06)
Vals AI Legal Research BenchFull credit on 112 of 208 questions (53.8%), and 90.9% of the available points
Search indexMore than 310 million URLs, covering more than 99.9% of published U.S. precedential case law

It is a configuration aimed at researching U.S. case law. If you want to try GPT-6.2 Astra for legal work, the order is to evaluate with regular Astra first, and request Astra for Law if your work centers on U.S. legal research.

Cloud platforms and Copilot

GPT-6.2 became generally available on three platforms on November 17, the same day as the announcement.

PlatformDetails
Microsoft FoundryGlobal Standard (28 regions), Data Zone Standard (US, EU, APAC), and Global Provisioned Throughput. Prices match the OpenAI API, with Astra at $8 / $40 and Sol at $2 / $10. Data Zone is 1.1x for the US and 1.2x for the EU and APAC. 12-hour cache writes are supported
Amazon BedrockGeneral availability of Astra and Sol. Astra supports Ultrafast
GitHub CopilotFor Copilot Pro+, Max, Business, and Enterprise. Usage-based billing at the provider's list price. Rolling out across VS Code, Visual Studio, Copilot CLI, the coding agent, JetBrains, Xcode, Eclipse, github.com, and mobile

On Foundry too, the long-input surcharge takes the same form. Astra's Long rate is $16 for input and $60 for output.

Organizations that already use OpenAI models under an Azure or AWS contract can move to GPT-6.2 without changing their contract.


Summary

As we wrote at the start, to sum up this model release in one sentence.

"GPT-6.2 Astra is 20% cheaper per token than GPT-6 Astra, gains 5 points on an independent composite index, and cuts the cost of one evaluation task to about two thirds. Sol keeps its price and reaches the same index level as the previous Astra."

That is what this release amounts to.

In practice, these are the five things to keep in mind.

  • Astra is 20% cheaper on input and output and 60% cheaper on cache reads. Sol keeps its price and uses fewer tokens for the same work
  • Astra reaches the previous model's max at medium and passes Opus 5.5's max at high. Most of the gain comes by high or xhigh
  • In the three-vendor comparison, Claude Fable 5.2 has the top index, GPT-6.2 Astra has the lowest cost among models scoring 60 or more, and GPT-6.2 Sol delivers an index of 57 for around $1
  • On the API, rework your app to only append to the conversation. Change reasoning effort with configuration_update, and check for dropped reasoning items with input_transformations
  • In ChatGPT, use it in Work and Codex. When you use the API directly, put an instruction to report obstacles in your system prompt

Here is the breakdown by use case.

Use caseRecommendationWhy
Classification, extraction, high-volume processingGPT-6 Luna, GPT-6.1 Terra$0.10 / $0.50, $1 / $5
Everyday coding, review, and writingGPT-6.2 Sol (start at medium)$2 / $10. Even at max, $1.01 per evaluation task at the level of the previous Astra
Tracing bugs across services, long agent workGPT-6.2 Astra (start at medium or high)Index 60.1 at high, $2.07 and 4.8 minutes per evaluation task
Scientific research work, CAD, 3D, financial analysisGPT-6.2 AstraLeads on Terminal-Bench-Science, AA-3D, and AA-AnalystAgent
Large volumes of hard problems that are not urgentGPT-6.2 Astra with Batch or the 8-hour completion windowHalf price or 40% off
Conversations where a person is waitingGPT-6.2 Sol with Fast or UltrafastSol runs at 85.2 tokens per second. Ultrafast is up to 4.5x
Approved vulnerability researchGPT-6 Cyber (Daybreak Red)GPT-6.2 ships with strong cyber safeguards
U.S. legal researchAstra for Law20.8% on Harvey LAB-AA

We will cover Japanese-language performance in the next edition of our "Japanese LLM Rankings 2026."

On our integrated AI platform "Bestllam," you can use more than 40 LLMs, including GPT, Claude, and Gemini, side by side in a single workspace. You can also send the same question to several models at once and compare the answers next to each other.

See you next time!


Sources

TopicSource
Announcement, pricing, benchmarks, examplesIntroducing GPT-6.2 Astra and Sol (OpenAI official announcement)
Model specs and rate limitsGPT-6.2 Astra model page (OpenAI official docs)
Model specs and rate limitsGPT-6.2 Sol model page (OpenAI official docs)
API pricingPricing (OpenAI official docs)
Migration steps and promptingUsing GPT-6.2 (OpenAI official docs)
The append-only designKeep the prefix unchanged (OpenAI official docs)
Reasoning effort and reasoning itemsReasoning models (OpenAI official docs)
Prompt cachingPrompt caching (OpenAI official docs)
Completion windowsBackground mode (OpenAI official docs)
UltrafastUltrafast mode (OpenAI official docs)
API change historyChangelog (OpenAI official docs)
Safety and evaluation detailsGPT-6.2 System Card (OpenAI Deployment Safety Hub)
Availability in Work and CodexChatGPT Work and Codex (OpenAI Help Center)
Models in ChatGPTGPT-6 and other models in ChatGPT (OpenAI Help Center)
Codex models and reasoning effortModels (ChatGPT and Codex official docs)
Codex usage and creditsPricing (ChatGPT and Codex official docs)
Astra for LawAstra for Law leads in legal intelligence (OpenAI official announcement)
Availability on Microsoft FoundryGPT-6.2 Astra and GPT-6.2 Sol now generally available in Microsoft Foundry (Microsoft official blog)
Availability on Amazon BedrockOpenAI GPT-6.2 Astra and GPT-6.2 Sol on Amazon Bedrock (AWS official announcement)
Availability on GitHub CopilotOpenAI's GPT-6.2 Astra and GPT-6.2 Sol now available (GitHub Changelog)
Independent evaluationGPT-6.2 Astra model page (Artificial Analysis)
Independent evaluationGPT-6.2 Sol model page (Artificial Analysis)
Independent evaluation articleOpenAI has the #2 model in the Intelligence Index (Artificial Analysis)
Claude pricingPricing (Anthropic official docs)
Gemini 4 pricingGemini API pricing (Google official docs)

Read more