Codex Reset Radar
🌐 English

GPT-6.2 Astra vs Sol: which model to use, and how to get real work out of it

GPT-6.2 Astra and Sol shipped on 2026-11-17. What each one is for, where to open them, what OpenAI claims versus what Epoch AI measured, the API prices, and four workflows you can copy.

Short answer: GPT-6.2 Astra and GPT-6.2 Sol launched on 2026-11-17, and you reach them inside ChatGPT Work, not the normal chat screen. Astra is the heavy model for cross-service debugging and deep research. Sol is the everyday driver for pull request review, code changes and meeting notes. A new Work chat starts on Sol at Light reasoning.

This is an unofficial tracker. It is not affiliated with OpenAI. Codex is a product/trademark of OpenAI. Probability scores are public-signal heuristics, not authoritative announcements or certainty.

Model release: 2026-11-17 (OpenAI announcement) · Prices verified: 2026-11-19 · Page published: 2026-11-19

What shipped on November 17, 2026

OpenAI shipped two models on 2026-11-17: GPT-6.2 Astra (gpt-6.2-astra) and GPT-6.2 Sol (gpt-6.2-sol). They reached ChatGPT Work, Codex and the API the same day. If you went looking for GPT-6.2 in the normal Chat screen and found nothing, nothing is broken: the models are selected inside Work, not in the main chat view. Availability follows your plan and the rollout: the official list covers Plus, Pro, Business, Enterprise and Edu, and Enterprise and Edu admins have to enable the models in workspace settings first. For context, GPT-6 Astra shipped on 2026-09-03, and OpenAI cancelled the planned GPT-6.1 Astra release on 2026-09-28 over scope and authorization issues, so 6.2 is the first Astra upgrade after that pull-back.

Astra and Sol: the division of labour

OpenAI describes Astra as "our most capable model for your hardest projects" and Sol as "our go-to model for everyday work". The split shows up in the defaults and the prices: a new Work chat starts on Sol at Light reasoning for consumer plans, and Enterprise workspaces with model access default to Sol at Medium. Astra is the escalation, Sol is the driver. Both models take text and image input and return text, both expose reasoning effort low, medium, high, xhigh and max, and both run on the same Responses API and Chat Completions endpoints. On price, Astra is four times Sol at both input and output, so the expensive question is only worth asking when the task genuinely is the hard one.

Claims, measurements, and the gap between them

Every benchmark number below carries an owner: OpenAI for the company self-reports, Epoch AI for the independent measurement, and named developers for the launch-day anecdotes. That labelling is the point of this section. A vendor benchmark and a real task are different instruments, and the difference between them is exactly where disappointment comes from. The table further down gives every number with its owner attached; the honest summary is that OpenAI reports large gains on its own exam, Epoch's human-scored real-work pass found Astra averaging 65%, and the developers quoted here mostly did not have a good first week with it.

What we did not test

We did not run any of the prompts on this page, we have no Chinese-language task measurements, no latency figures, and no reproduction of any published benchmark in your codebase. Nothing here should be read as our own test result. Where the official sources disagree with each other, or where only a company is claiming a number, we say so in the same sentence. The methodology page describes how this site treats evidence on the reset side of the site; this page follows the same rule: attribute the claim, then let the reader decide.

Using the models without burning your quota

Two official details change how you should drive either model. First, caching: OpenAI advises keeping the earlier part of your prompt unchanged and appending new instructions at the end, so the cached prefix stays valid and earlier reasoning survives. That is why the workflow prompts below are written as a stable frame plus an appended task. Second, reasoning effort has no none setting; the API rejects it, so the cheapest honest setting is low. And remember that Codex and Work draw on the same usage quota, so a heavy Work job eats the Codex budget you plan with. Before you queue something long, read your own quota the way we describe in how to check Codex usage and keep the two windows apart as in 5-hour versus weekly limits.

Astra and Sol at a glance

GPT-6.2 AstraGPT-6.2 Sol
API model IDgpt-6.2-astragpt-6.2-sol
OpenAI's own positioningOur most capable model for your hardest projectsOur go-to model for everyday work
Default in a new Work chatNot the default, you pick it explicitlySol at Light reasoning (consumer plans)
Enterprise workspace defaultNot the defaultSol at Medium reasoning
Context window1,050,000 tokens1,050,000 tokens
Max input / max output922,000 / 128,000 tokens922,000 / 128,000 tokens
Knowledge cutoff2026-05-182026-06-01
Input / output price ($ per 1M tokens)$8 / $40$2 / $10
Cached input / cache write ($ per 1M tokens)$0.40 / $10 (30-minute retention)$0.10 / $2.50 (30-minute retention)
Ultrafast accessChatGPT Pro $500ChatGPT Pro $200 and Pro $500
Official sample tasksCross-service bug hunt and fix, report turned into a deck, multi-source research that names conflicting evidencePull request review, code changes from reviewer feedback, meeting notes turned into a project brief

Reasoning effort on both models runs low, medium, high, xhigh and max. The API rejects a request that sets reasoning effort to none. Prices are the documented API rates, not a plan quote.

Where you can actually open them

WhereHow to get itWhat to know
ChatGPT Work (web, desktop, mobile)Open Work and choose the modelThe official rollout covers Plus, Pro, Business, Enterprise and Edu. Enterprise and Edu admins must enable the models in workspace settings first. The main Chat screen does not expose GPT-6.2.
CodexModel picker in the app, or /model in the CLICodex and Work share the same usage quota. The official examples pair Astra with cross-service debugging and Sol with review and review-feedback loops.
APIgpt-6.2-astra and gpt-6.2-sol on the Responses API and Chat CompletionsFine-tuning is not supported. Audio and video output are not supported; images are input only. Setting reasoning effort to none is rejected by the API.
UltrafastPro $500 with either model, Pro $200 with Sol, Enterprise and Edu by owner settingUltrafast is billed at 3 times the standard API rate through 2027-02-28, and 6 times from 2027-03-01.

Free accounts are not part of the official rollout. If you are on a paid plan and still cannot see the models, the two things worth checking are whether you are in Work rather than Chat, and whether your Enterprise or Edu admin has enabled model access for the workspace.

API specs and pricing

API rate ($ per 1M tokens)AstraSol
Input$8$2
Cached input$0.40$0.10
Cache write, 30-minute retention$10$2.50
Cache write, 12-hour retention$20$5
Output$40$10

Rules that apply to both models: once a request passes 272K input tokens, input and cached input are billed at 2 times the standard rate and output at 1.5 times. The Batch API is half the standard rate. Fast mode is 2 times. Reasoning effort runs low, medium, high, xhigh and max, and none is rejected by the API. On the Responses API both models list the same tools: web_search, file_search, image_generation, code_interpreter, hosted_shell, apply_patch, skills, computer_use, mcp and tool_search. OpenAI's own caching advice is to keep the earlier part of the prompt unchanged and append new instructions at the end, which keeps the cached prefix eligible and preserves earlier reasoning. Current API prices are also listed on the API page.

Official claims versus independent measurements

Every number below belongs to somebody. The owner column stays on the page on purpose: a vendor benchmark and a human-scored real task are different instruments, and reading them as the same thing is where the disappointment comes from.

ClaimNumberOwnerWhat the owner says about it
Agents' Last Exam, versus GPT-6 Astra+5.2 points, at under a third of the costOpenAI (self-reported)Company benchmark on its own exam. Not reproduced by anyone else at the time of writing.
Agents' Last Exam, versus Claude Fable 5.2+5.5 points, at 5 percent of the costOpenAI (self-reported)The announcement footnotes that the Fable leaderboard excludes 9 fallback tasks.
Price against GPT-6 AstraInput and output 20 percent cheaper, cached input 60 percent cheaperOpenAI (self-reported)Stated as a product pricing change rather than a benchmark.
FrontierCode 2.0, Sol against AstraWithin 0.5 points, at about one fifth of the costOpenAI (self-reported), both at max reasoningCompany benchmark. Sol's API prices stay the same as GPT-6.1 Sol.
Preparedness FrameworkFirst externally released model to meet the High threshold for AI self-improvementOpenAI (self-reported, system card)Stated for Astra. Sol did not meet it.
Real work, human-scoredAstra averaged 65 percent, 17 points below Fable 5.2Epoch AI (independent, with stated limits)Epoch states its own limits: a small task suite, one run per task, subjective scoring. No model reached Epoch's own employee standard.
AI data-centre tasksFable 5.2 97.5 percent, Opus 5.5 87.5 percent, Astra 65 percentEpoch AI (independent, with stated limits)Epoch describes Astra as overly cautious and missing key estimates on this task set.
Epoch internal task setBoth models roughly level, 174 against 173Epoch AI (independent, with stated limits)The one task set where the two models were close.
Blocker Deception22.28 percent against 11.09 percent for GPT-6 AstraOpenAI system card (self-reported)A safety evaluation result, not a capability one. Listed so the numbers are not mistaken for quality claims.
Developer reaction, launch weekNot chosen over Opus 5.5 for one developer's own workTheo Browne (named launch-day anecdote)An individual opinion from launch week, not a measurement.
Developer reaction, one week inNo improvement over seven days, and about 56 percent slowerts-rust (named launch-day anecdote)One project's report of one week. Not a benchmark.
OpenAI's own reactionModels are nice to work with, and there is more work to doSam Altman (named response)Quoted as a response to the launch-week feedback above.

Two things the table deliberately does not contain: any Chinese-language task measurement, and any latency figure. We have no data for either, so we publish neither.

Four workflows you can copy

These are example workflows built from the official use cases for GPT-6.2, written so you can paste them and adapt the bracketed parts. Workflow 4 is a bonus built the same way. We have not run any of them ourselves, so treat them as a starting shape rather than a measured result.

Workflow 1: research synthesis with evidence you can check (Astra)

Goal. Turn several sources into a decision-ready table where every claim points back to something quotable, and where the disagreements between sources are named instead of smoothed over.

What to paste in. The sources themselves (title, URL and date for each), the question the research has to answer, and who reads the result and by when. If a source is long, paste the relevant section and say so.

Role: research synthesis assistant.

Sources (paste each as title | URL | date):
1. <source 1>
2. <source 2>
3. <source 3>

The question this research must answer:
<the decision it supports>

Audience and deadline:
<who reads it, and by when>

Do this in order:
1. List the claims these sources actually support. One row per claim.
2. For each claim give: source number, the exact supporting sentence or figure, the date, and your confidence (direct quote / inferred / not stated).
3. Name every disagreement between sources. Do not silently pick a winner.
4. List what the sources do not cover for my question.

Output as a table: claim | source | supporting quote | date | confidence.
Then a short section: disagreements.
Then a short section: not covered.

Rules:
- Use only the sources above. If a source does not say it, write "not stated in sources".
- Never fill a gap from your own knowledge.
- Mark any number you are not certain about as [verify].
- Quote before you summarize.

How to check the output before you use it. Every row must have a source number and a quoted fragment; if a row says "not stated in sources", that is a legitimate answer and not a failure. The disagreements section must not be empty unless the sources genuinely agree. Nothing in the summary may lack a row behind it. Finally, spot-check two quotes against the originals yourself, because a fluent paraphrase is the easiest thing to get wrong here. For the standing rule on evidence, see methodology and evidence rules.

Privacy and failure modes. Do not paste internal credentials, customer records or anything you would not put in a ticket. Epoch's own evaluation described Astra as overly cautious and missing key estimates, so expect a missing number to arrive as a hedge: ask for the specific figure instead of accepting a safe non-answer. Users have also reported the model stopping partway; if that happens, send "continue from where you stopped" rather than resending the whole prompt, and check that nothing was dropped in the gap.

Workflow 2: notes into a brief a team can act on (Sol)

Goal. Turn rough working notes into a short brief that a reader can act on, without inventing a single fact, date or owner that was not in the notes.

What to paste in. The raw notes (fragments and links are fine), who the brief is for, the decision the reader has to make after reading it, a target length, and the tone you want.

Role: turn raw working notes into a project brief.

Notes (paste as-is, including rough fragments and links):
<notes>

Context:
- Audience: <who reads it>
- Decision the reader must make after reading: <the decision>
- Target length: <e.g. 400 words>
- Tone: <plain / formal / bilingual>

Write it in this order:
1. Summary: one paragraph, five sentences maximum.
2. Open questions and decisions needed: each with why it matters.
3. Next steps: each with an owner and a deadline. If either is unknown, write [owner unknown] or [deadline unknown].
4. Appendix: every fact in my notes that did not make it into the summary, with its source line.

Rules:
- Use only facts present in my notes. If a fact is missing, write [MISSING: what you need].
- Keep my wording where it is already clear. Do not rewrite for style alone.
- Do not add dates, numbers, names or owners that are not in the notes.
- If you are unsure whether something is a fact or my guess, mark it [check with me].

How to check the output before you use it. The [MISSING] and [check with me] lists are the point of the workflow: if they are empty on a task you know is incomplete, the model filled the gaps, and the brief is not safe to send. Every next step must have an owner and a deadline, or an explicit unknown marker. The appendix should not be empty if the notes contained something you dropped. Read the summary against the notes once, looking specifically for invented specifics.

Privacy and failure modes. Meeting notes are the most likely place for personal data, salary numbers and customer names: redact them before pasting and keep the redaction list yourself. If the output invents a date, discard the draft, re-paste the notes, and lead with the rule line "use only facts present in my notes". Long notes may produce a truncated brief; ask for the missing section only, rather than regenerating everything and losing the parts you already approved.

Workflow 3: pull request review, then apply the feedback (Sol for review, Astra for cross-service debugging)

Goal. Get a review that points at file and line and refuses to pad itself, then apply only the findings you chose, one change at a time.

What to paste in. The diff or the changed files, what the change is supposed to do, the service or repository name, and the risk areas you care about most (data migration, auth, billing, third-party calls).

Role: pull request reviewer. Do not write code in this response.

Context:
- Service or repo: <name>
- What this change is supposed to do: <one paragraph>
- Risk areas to check first: <e.g. data migration, auth, billing, third-party API>

Review in this order:
1. Correctness: does it do what the description says, including the error and empty paths?
2. Tests: which behaviour is untested? Name the missing test case.
3. Blast radius: which callers, schemas, queues or feature flags does this break?
4. Readability: only where it costs a future reader real time.

Output:
- Numbered findings. Each finding: severity (blocker / should-fix / nit), file and line, why it matters, and a concrete suggested change.
- Then "Verdict: approve / approve with comments / request changes" and the single reason.
- Then "Verify yourself": what you could not check and should.

Rules:
- Cite file and line for every finding. No finding without a location.
- If the diff is correct, say so plainly. Do not invent problems to look thorough.
- Do not rewrite the code in this response.
Apply only the findings I mark.
- One change per finding, kept minimal and in the existing style.
- Do not refactor anything that was not asked for.
- After each change, state the file you touched and the command that runs the tests.

When you are done, list: what changed, what you did not change and why, and any finding you disagree with.

How to check the output before you use it. Every finding must carry a file and line; a finding without a location is not a finding. The verdict must come with one reason, not five. The missing-test list must name actual cases rather than saying "add tests". When it comes to applying feedback, the change list must map one to one onto the findings you marked, and nothing outside those findings should have moved. Read the diff yourself before you push: treat every suggested change as a proposal, not an applied fact.

Privacy and failure modes. Never paste API keys, tokens, session cookies or customer data into a review prompt; use placeholder names and a redacted fixture. Keep secrets in your environment and refer to them by variable name. Developers have reported that these models can feel hard to steer, so give one instruction per turn instead of rewriting the whole prompt. If the model stops mid-review, ask for the remaining findings rather than re-running it, and diff the two answers before trusting either.

Workflow 4: a report turned into a deck outline (Astra)

Goal. Compress a report into one point per slide, with the evidence that supports each point kept next to it.

What to paste in. The report text, the audience, and the decision that audience has to make after the deck.

Role: turn this report into a slide outline.

Report (paste):
<text>

Audience and the decision they must make:
<audience / decision>

Output:
- One line per slide: slide number | slide title | the single point that slide makes | the evidence that supports it.
- Then a one-paragraph speaker note for each slide.
- Then a "cut" list: what I should not include.

Rules:
- Every slide makes one claim. Do not write slides that only introduce a section.
- Use only content from the report. If a slide needs a number that is not in the report, mark [need figure].
- Keep each slide point under 20 words.

How to check the output before you use it. One claim per slide, and every evidence cell traceable to the report. A slide that needs a figure you do not have is marked, not invented. The cut list should tell you what to leave out, which is usually the most valuable part of the output.

Privacy and failure modes. Reports carry the same secrets as notes: redact names, figures and anything customer-facing first. If a slide invents a number, drop that slide and re-run with the report pasted again. Deck outlines are easy to over-trust because they look finished; the check that matters is the evidence column.

Common failures and data privacy

Where it tends to fail

  • It stops partway. Launch-day users reported the model halting mid-task. Send "continue from where you stopped" instead of resending, and check the seam for dropped content.
  • It hedges instead of estimating. Epoch's evaluation described Astra as overly cautious and missing key estimates. Ask for the specific figure you need, and treat a safe non-answer as a missing value, not a refusal.
  • It sounds certain without a source. Every workflow above forces a quote, a line number or an explicit [verify] marker. An unsourced number is a guess with better typography.
  • You cannot steer it in one turn. Developers described the models as hard to work with. One instruction per turn beats rewriting the whole prompt.
  • You cannot find the model. GPT-6.2 is selected in Work, not in the main Chat view. That is the single most common "it does not exist" report.
  • Your request set reasoning to none. The API rejects that value. Use low.

Data privacy

  • Never paste OpenAI passwords, API keys, session cookies or tokens into a prompt, and never into this site. Keep secrets in your environment and name them in the prompt as variables.
  • Redact customer records, personal data and any production log line containing user identifiers before you paste code, notes or reports.
  • Codex and Work draw on one shared usage quota, so a heavy Work job consumes the Codex budget you planned with. Check your own quota before you queue something long, the way we show in how to check Codex usage.
  • This site never asks for an OpenAI login and never reads your quota. Your own usage panel is the only account-level truth, the same rule we follow on the GPT-5 reset tracker page. You can subscribe to reset alerts reset alerts.

Sources

OpenAI official

Independent measurement

Context and launch coverage

One gap worth stating plainly: the OpenAI help centre article on ChatGPT Work and Codex still describes GPT-6 and 6.1 wording, so we do not use it for anything on this page. Everything above about 6.2 comes from the announcement, the API documentation, the catalog, the Learn guide and the system card.

Update log

This page has no automatic update job. It gets revisited when OpenAI publishes a follow-up note for GPT-6.2, when the API price table changes, or when a reader points at something here that does not match the sources.

Want the next strong Codex reset signal?

Get an email when the radar logs a stronger public reset signal.

Get reset alerts →

GPT-6.2 Astra vs Sol: which model to use, and how to get real work out of it FAQ

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

OpenAI positions Astra as the model for the hardest projects and Sol as the go-to for everyday work. Astra costs $8 per million input tokens and $40 per million output tokens, Sol costs $2 and $10, both share a 1,050,000 token context window, and a new Work chat starts on Sol at Light reasoning.

How do I get GPT-6.2 in ChatGPT?

Open ChatGPT Work, not the main Chat screen. The models are selected inside Work, and the official rollout covers Plus, Pro, Business, Enterprise and Edu, with Enterprise and Edu admins enabling model access in workspace settings first.

Is GPT-6.2 included in my ChatGPT plan?

The official list covers Plus, Pro, Business, Enterprise and Edu. Free accounts are not part of the rollout, and Enterprise and Edu need an admin to turn the models on for the workspace before any member sees them.

Which is cheaper to run, Astra or Sol?

Sol, by a wide margin: $2 per million input tokens and $10 per million output tokens against Astra's $8 and $40. Cached input is $0.10 versus $0.40. The practical rule is to run daily work on Sol and escalate to Astra only when the task genuinely is the hard one.

Does GPT-6.2 support fine-tuning, audio or video?

Fine-tuning is not supported, audio and video output are not supported, and images are accepted as input only. Both models run on the Responses API and Chat Completions, and the API rejects any request that sets reasoning effort to none.

Is GPT-6.2 actually better than Claude Fable 5.2?

It depends on whose measurement you take. OpenAI reports that Astra scores 5.5 points above Fable 5.2 on Agents' Last Exam at 5 percent of the cost. Epoch AI, using human-scored real tasks, found Astra averaging 65 percent and 17 points below Fable 5.2, with Epoch noting its own small sample and subjective scoring. Both numbers are on this page with their owner attached.

Did OpenAI cancel the GPT-6.1 Astra release?

Yes. OpenAI announced on 2026-09-28 that it cancelled the planned GPT-6.1 Astra release over scope and authorization issues and how it was communicated to users. GPT-6.2 is the first Astra upgrade after that cancellation.

Can any tracker show my GPT-6.2 usage or limits?

No. OpenAI exposes no per-account quota for these models, so no tracker can read your usage. Your own Codex and Work usage panels are the only account-level truth, and this site never asks for your OpenAI login. The GPT-5 reset tracker page covers why that rule applies here too.

Have you tested the workflows on this page?

No. They are example flows built from the official use cases, written so you can paste them and fill in the bracketed parts. We have no Chinese-language task measurements, no latency figures, and no reproduction of any published benchmark, and we do not present them as our own test results.

Related Codex reset guides