Direct answer: OpenAI released GPT-6.2 Astra and GPT-6.2 Sol on November 17, 2026. According to the official report, both improve over their respective predecessors on GDPval v2, and Astra also cut output tokens by 22%.For model selection, prioritize Astra for complex, high-value professional tasks where mistakes are costly; prioritize Sol for high-frequency, speed- and cost-sensitive tasks. Note that this rollout is only gradually opening to ChatGPT Work, Codex, and the API. Regular ChatGPT conversations are not part of this round. So if you only use regular Chat, you don’t need to change your workflow because of this release for now.
What you’ll learn from this article:
- When GPT-6.2 Astra and Sol were released, the official sources, and where they’re available.
- What the official GDPval v2, ALE, and FrontierCode 2.0 data actually show—and what they don’t show.
- The input/output capability boundaries of the two models, plus the official API standard pricing structure.
- How regular users and developers should choose between Astra and Sol.
Index: The rest of the article first uses a concept table to explain terms such as benchmark names and cached billing, then uses an impact overview to explain how this release relates to different groups. The first main section focuses on official facts, including 1.1 rollout scope, 1.2 official benchmarks, 1.3 capability boundaries, and 1.4 pricing. The second section is editorial judgment, discussing what the upgrade actually means, how the two models divide the work, selection recommendations, and integration validation methods.

To Know: Understand These Concepts First
The terms below appear in both the official materials and this article. Getting clear on what they mean up front will help you avoid misreading benchmark data and pricing.
| Concept | Brief explanation |
|---|---|
| GPT-6.2 Astra | In this release, the model positioned toward complex professional tasks, with higher official API pricing |
| GPT-6.2 Sol | In this release, the model positioned toward speed and cost, with official API pricing at about one-quarter of Astra’s |
| GDPval v2 | One of the benchmarks used officially by OpenAI; the main comparison data for Astra and Sol this time comes from it |
| ALE | Another benchmark in the official report; this time only Astra’s improvement score was published |
| FrontierCode 2.0 | The coding benchmark in the official report, used this time to compare the gap between Sol and Astra at the max reasoning tier |
| Percentage points | The difference between two percentages; for example, going from 50% to 56.2% is a 6.2 percentage point increase |
| Reasoning tier (max) | A configurable reasoning-intensity tier for the model; max means the setting that puts in the most reasoning compute |
| Output tokens | The billing unit consumed by model-generated content; the more concise the output, the lower the cost is usually |
| Cache reads | The portion of reused prompt content that hits cache and is billed at a lower price |
| Cache writes | Tokens written to cache are billed at the write rate for the corresponding retention period; the same batch of tokens is not charged the regular input fee again |
| 272K long-context threshold | When a single request’s input exceeds about 272,000 tokens, the entire request is billed at a higher rate |
| ChatGPT Work | OpenAI’s ChatGPT product for work scenarios, one of the launch entry points in this release |
| Codex | OpenAI’s product for coding scenarios, one of the launch entry points in this release |
GPT-6.2 Astra vs Sol: Quick Impact Overview for Different User Groups
- Regular ChatGPT users: The standard Chat tier isn’t part of this rollout, so your day-to-day experience won’t change directly in the short term.
- ChatGPT Work users: You’ll get access to the new models as they roll out gradually — the main decision is which tasks to hand to Astra and which to Sol.
- Codex users and programmers: Official FrontierCode 2.0 data shows Sol comes close to Astra on that benchmark, so it’s worth running your own comparison against your codebase.
- API developers: The price gap between the two models is significant, and there are caching plus 272K long-context billing rules — model routing and prompt design will directly affect your bill.
- Creators who need video generation: The new models take text and images as input and output text. They aren’t native video generation models, so this use case isn’t directly affected.
1. The Objective Facts About the GPT-6.2 Astra and Sol Release
This section presents only publicly available official information. All benchmark data in this article comes from OpenAI’s official report — these aren’t hands-on tests by the APIYI team, and we haven’t run any benchmarks or conducted any interviews.
1.1 GPT-6.2 Astra and Sol: Release Date and Rollout Scope
OpenAI released GPT-6.2 Astra and Sol on its official page on November 17, 2026; the information in this article was verified on November 18, 2026. The official announcement page, the help center documentation, and the developer model page are currently the most direct sources — see the references at the end of this article for the exact URLs.
| Item | Details |
|---|---|
| Release date | November 17, 2026 |
| Publisher | OpenAI |
| Models released | GPT-6.2 Astra, GPT-6.2 Sol |
| Access points | ChatGPT Work, Codex, API — rolling out gradually |
| Out of scope this round | Standard ChatGPT chat (Chat) |
| Input modalities | Text, images |
| Output modalities | Text |
| Official sources | openai.com announcement page, help.openai.com documentation, developers.openai.com model page |
“Rolling out gradually” means not every account will see the new models on launch day. If you can’t find the entry point in ChatGPT Work or Codex just yet, that’s normal for a phased rollout — see the official help documentation for details.
1.2 Official Benchmark Data for GPT-6.2 Astra and Sol
The official report provides three sets of numbers. They come from different evaluations and use different baselines, so you can’t compare them head to head. The table below keeps them in their original form.
| Evaluation | Model | Official reported result | Baseline |
|---|---|---|---|
| GDPval v2 | GPT-6.2 Astra | Up 6.2 percentage points, 22% fewer output tokens | GPT-6 Astra |
| GDPval v2 | GPT-6.2 Sol | Up 5.3 percentage points | GPT-6.1 Sol |
| ALE | GPT-6.2 Astra | Up 5.2 points | Previous-generation Astra |
| FrontierCode 2.0 (max reasoning setting) | GPT-6.2 Sol | Within 0.5 points of Astra, task cost about 1/5 of Astra’s | GPT-6.2 Astra |
Three things are worth noting here. First, Astra and Sol use different baselines on GDPval v2 — Astra is compared against GPT-6 Astra and Sol against GPT-6.1 Sol — so the 6.2 and 5.3 figures can’t be directly compared to see which one improved more. Second, ALE uses “points” while GDPval v2 uses “percentage points,” so both the units and the evaluation methods differ. Third, the FrontierCode 2.0 conclusion only holds at that test’s max reasoning setting. OpenAI didn’t claim Sol stays within 0.5 points of Astra on every task, nor that Sol needs only 1/5 the cost in every scenario.

1.3 Capability Boundaries of GPT-6.2 Astra and Sol
According to the official model documentation, both models accept text and images as input and produce text as output. That means they can read images, analyze screenshots, understand charts, and then answer in text or code—but they aren’t native video generation models themselves.
If your need is video generation, this release doesn’t directly offer that capability. If your need is reading materials, writing reports, writing code, or doing multi-step analysis, then this upgrade is much more closely tied to your work.
1.4 Official API Standard Pricing for GPT-6.2 Astra and Sol
The official developer model page publishes standard pricing, in units per million tokens. The following is official pricing and does not represent quotes from any third-party platform.
| Billing item | GPT-6.2 Astra | GPT-6.2 Sol |
|---|---|---|
| Uncached input | $8 | $2 |
| Cache read | $0.4 | $0.1 |
| Output | $40 | $10 |
| Cache write | Billed at the write rate for the corresponding retention period, with no additional standard input fee | Billed at the write rate for the corresponding retention period, with no additional standard input fee |
| When input exceeds 272K | Input and cache rates ×2 for the entire request, output ×1.5 | Input and cache rates ×2 for the entire request, output ×1.5 |
Don’t add cache billing on top of itself. Input volume should be split into four mutually exclusive parts: standard input, cache reads, 30-minute cache writes, and 12-hour cache writes. Standard input volume = total input volume − cache read volume − all cache write volume. Each part is multiplied by its corresponding rate separately, and the same batch of written tokens is not also charged at the standard input price. For example, with Astra in Standard short context, the 30-minute write price is $10 per million tokens—this is the complete write rate for that portion, not an extra $10 on top of the $8 standard input price. Official prompt caching billing guide
The 272K rule deserves special attention. It doesn’t just apply a surcharge to the portion above the threshold—when a single request’s input exceeds 272K tokens, the input and cache rates for the entire request double, and the output rate becomes 1.5×. Users who are used to stuffing their whole document library into the context in one go may find their bills significantly higher than expected.
2. Analysis and Assessment of GPT-6.2 Astra and Sol
The following is the APIYI editorial team’s interpretation of the official facts covered above. It’s not an official conclusion, nor is it the result of our own testing. Anything touching on trends is a judgment call—please verify it against your own workloads.
2.1 What Did GPT-6.2 Astra and Sol Upgrade This Time?
Looking at the official data, this upgrade comes down to two main threads. One is Astra’s “stronger yet leaner”: it gains 6.2 percentage points on GDPval v2 while cutting output tokens by 22%. That 22% is the change in output-token consumption under that specific benchmark—it can’t be used to directly infer the visible length of each answer or the savings ratio.
The other is Sol’s “catching up.” It gains 5.3 percentage points on GDPval v2, and at the max reasoning tier in FrontierCode 2.0 it trails Astra by less than 0.5 points—a sign that the official push is to make Sol an option that’s not much weaker in capability but far cheaper. That said, the “catching up” judgment currently rests on a single coding benchmark; whether it holds for writing, analysis, long-document tasks, and the like needs more data.

2.2 Positioning and division of labor between GPT-6.2 Astra and Sol
The table below compares the two models side by side across the same dimensions. The “suitable scenarios” column reflects editorial judgment based on pricing and the direction of official benchmarks; it doesn’t mean the other model is completely unusable in those scenarios.
| Dimension | GPT-6.2 Astra | GPT-6.2 Sol |
|---|---|---|
| Positioning tendency | Complex, professional, high-value tasks | Speed- and cost-sensitive tasks |
| Official price (input/output) | $8 / $40 | $2 / $10 |
| Official benchmark highlights | GDPval v2 +6.2 percentage points, output tokens -22%, ALE +5.2 points | GDPval v2 +5.3 percentage points; on FrontierCode 2.0 max tier, within 0.5 points of Astra |
| Suitable scenarios (editorial judgment) | Critical reports, complex code refactoring, multi-step reasoning, decision support where errors are costly | Batch processing, everyday Q&A, routine coding, high-frequency calls, prototype validation |
| Watch out for | High unit price; costs scale up more noticeably in long-context use | Coding benchmark is close to Astra, but that can’t be extrapolated to all tasks |
| Access channels | ChatGPT Work, Codex, official API; for third-party aggregation platforms such as APIYI apiyi.com, refer to their model lists | Same as Astra |
One detail that’s easy to overlook: at official list prices, Sol’s unit price is about 1/4 of Astra’s, while its task cost on FrontierCode 2.0 is about 1/5. It’s normal for those two ratios to differ, because task cost also depends on the number of tokens actually consumed. This is also a reminder that when comparing costs, you should look at “the total cost to complete the same task,” not just the unit price.
Here’s a rough example based on official list prices: for a single request with 100,000 input tokens and 10,000 output tokens, without considering caching, Astra comes to about $0.8 + $0.4 = $1.2, and Sol comes to about $0.2 + $0.1 = $0.3. Actual costs vary with reasoning tier, output length, and cache hits; detailed cost calculations are beyond the scope of this article.
2.3 Should Regular Users Pick GPT-6.2 Astra or Sol?
For regular users working in ChatGPT Work, a good way to decide is by “the cost of one mistake.” If getting a task wrong would mean a long rework cycle, or could affect an important decision—say, pulling together key contract points, doing complex data analysis, or drafting a formal report—start with Astra. If the task is simple, high-volume, and easy to check quickly—like rewriting an email, summarizing meeting notes, or handling everyday queries—Sol is usually enough.
For Codex users, the FrontierCode 2.0 data points to an approach worth trying: use Sol for routine development tasks first, then switch to Astra when you run into cross-module refactoring, a bug that’s hard to pin down, or architecture design. That said, this is only a suggestion based on a single test—ultimately, what matters is how it performs on your own codebase.
If you only use regular ChatGPT chats, this rollout doesn’t include that entry point. Until the official announcement expands availability, you don’t need to do anything to prepare for this release.
2.4 How Developers Can Validate GPT-6.2 Astra and Sol with the API
The safest approach for developers is to take the same batch of real tasks, run them through both models, and compare quality, latency, and actual token consumption. The example below is adapted from the official SDK docs and hasn’t been run or verified yet. It uses the official OpenAI endpoint, and model IDs should be confirmed on the official model page. If you’re using a third-party platform, check that platform’s model list first to confirm the model is actually available — this article hasn’t verified launch status on any third-party platform.
import openai
client = openai.OpenAI(
api_key=__import__("os").environ["OPENAI_API_KEY"] # Official API, key supplied via environment variable
)
response = client.chat.completions.create(
model="gpt-6.2-sol", # Model ID subject to the official or platform model list
messages=[{"role": "user", "content": "用三句话总结这份需求文档的风险点"}]
)
print(response.choices[0].message.content)
View the full comparison code for calling Astra and Sol
import time
import openai
client = openai.OpenAI(
api_key=__import__("os").environ["OPENAI_API_KEY"] # Official API, key supplied via environment variable
)
# Model IDs subject to the official model page or platform model list
MODELS = ["gpt-6.2-astra", "gpt-6.2-sol"]
# Replace with your own real tasks instead of relying on a single public benchmark
TASKS = [
"阅读以下函数并指出潜在的并发问题:...",
"把这段会议记录整理成 5 条待办事项:...",
]
def run(model: str, prompt: str) -> dict:
start = time.time()
try:
resp = client.chat.completions.create(
model=model,
messages=[{"role": "user", "content": prompt}],
)
usage = resp.usage
return {
"model": model,
"seconds": round(time.time() - start, 2),
"input_tokens": usage.prompt_tokens,
"output_tokens": usage.completion_tokens,
"answer": resp.choices[0].message.content,
}
except Exception as e:
return {"model": model, "error": str(e)}
for task in TASKS:
for model in MODELS:
result = run(model, task)
print(result)
At the same time, log total input, cache reads, cache writes broken out by retention period, billable output (including reasoning), and tool usage — then calculate costs using the rates of your actual provider and service tier. Official pricing only works for estimates on the official API. It’s also a good idea to keep each request’s input under 272K tokens so the request as a whole doesn’t trip a higher rate tier.
🎯 Technical tip: If you need to compare multiple models within a single codebase, you can use the OpenAI-compatible endpoint from APIYI apiyi.com — one API key lets you switch between mainstream models like OpenAI, Claude, and Gemini. Whether the GPT-6.2 series is already available on the platform? Check the platform’s model list to confirm.
2.5 GPT-6.2 Astra and Sol: Variables Worth Watching Going Forward
The first variable is rollout scope. Standard Chat isn’t part of this round, and there’s no public information on whether or when the official team will expand access—that will determine when most everyday users can actually get their hands on the new models. The second variable is data on more task types. Whether Sol can approach Astra beyond coding is a question that needs third-party and additional official benchmarks to answer.
The third variable is real-world cost performance. Astra’s 22% reduction in output tokens is a result on GDPval v2, and it won’t necessarily hold at the same ratio when you apply it to your own tasks. I’d suggest keeping a running record of your actual invocation data rather than locking in a long-term plan based on a single launch-day number.
As The Analects (Book XV, Duke Ling of Wei) puts it: “To do a good job, one must first sharpen one’s tools.”
📚 References
OpenAI API changelog (release date verification)
-
OpenAI official launch page: GPT-6.2 Astra and Sol announcement and official benchmarks
- Link: Original announcement
- Notes: Source for the release date, GDPval v2, ALE, and FrontierCode 2.0 data
-
OpenAI Help Center: ChatGPT Work and Codex documentation
- Link: Official documentation
- Notes: Access points and the phased rollout scope
-
OpenAI developer docs – GPT-6.2 Astra: Model details and API pricing
- Link: Official documentation
- Notes: Input/output modalities, standard pricing, long-context billing rules
-
OpenAI developer docs – GPT-6.2 Sol: Model details and API pricing
- Link: Official documentation
- Notes: Input/output modalities, standard pricing, long-context billing rules
Author: APIYI Technical Team
Technical discussion: Feel free to reach us through the homepage of the APIYI apiyi.com website. For more integration materials, visit the docs.apiyi.com documentation center.
