Start with GPT-6.2 Sol for routine coding and repeatable jobs. Try GPT-6.2 Astra when a failed attempt creates enough rework to justify a higher bill. Both models launched on November 17, 2026. Sol is the cheaper baseline. Astra is worth testing on harder changes, ambiguous instructions, or deliverables that have already failed a clear acceptance check with Sol. OpenAI's launch announcement.
The headline number is 4×. At OpenAI's short-context Standard API rates, Astra costs $8 per million uncached input tokens and $40 per million output tokens. Sol costs $2 and $10. The same ratio applies to cached reads and writes at the same retention period. Actual jobs consume different numbers of tokens and retries. In Cognition's FrontierCode 2.0, OpenAI reports that Max-effort Sol came within half a point of Max-effort Astra at about one-fifth the cost. Later in this guide, there's a short workflow for checking the rates in Tabbit Browser before you build a budget around them. Astra API specification, Sol API specification, OpenAI's FrontierCode disclosure.
One developer reported that both 6.2 models finished overnight projects and reduced back-and-forth on C++ and Rust work. That experience suggests a question to put in a trial: how often do you get a finished result without intervening? Original comment.

Key takeaways
Sol costs 75% less at equal token counts and the same OpenAI API tier. Use it as the baseline for work you can validate with a test, a schema, or a checklist.
Astra gives you another option when Sol repeatedly misses a requirement. Measure the value of the failures it prevents on your own workload.
Both have the same documented API context window. Crossing 272K input tokens raises the price of the whole request for either model.
Codex, ChatGPT Work, and the API are separate ways to use these models. Confirm access and limits in the one you intend to use.
Compare time and cost per accepted result. Include the first attempt, failed runs, review time, and any escalation to Astra.
GPT-6.2 Astra and Sol at a glance
| Decision factor | GPT-6.2 Astra | GPT-6.2 Sol |
|---|---|---|
| OpenAI API ID | gpt-6.2-astra | gpt-6.2-sol |
| Standard short-context input / output, USD per 1M tokens | $8 / $40 | $2 / $10 |
| Cached input read / 30-minute write, USD per 1M | $0.40 / $10 | $0.10 / $2.50 |
| API context window / maximum input / maximum output | 1,050,000 / 922,000 / 128,000 | 1,050,000 / 922,000 / 128,000 |
| Modalities | Text or images in, text out | Text or images in, text out |
| Reasoning effort | Low, Medium, High, Xhigh, Max | Low, Medium, High, Xhigh, Max |
| Typical first trial | Complex changes and work with costly misses | Everyday code changes and repeatable workloads |
| OpenAI access | API, eligible Codex and ChatGPT Work accounts | API, eligible Codex and ChatGPT Work accounts |
Prices and limits were checked on November 19, 2026. The context and output figures apply to the API. A particular client can apply its own limits and tools. Tabbit's Astra model resources and Sol model resources collect examples by workload. The previous Astra pricing guide describes the older release and can help audit a migration budget. Astra API model, Sol API model.
What does each model cost per job?
Standard prices at equal usage
A short-context request with 100,000 uncached input tokens and 20,000 billed output tokens costs $1.60 on Astra and $0.40 on Sol. The input and output each contribute $0.80 on Astra and $0.20 on Sol. This estimate covers only model tokens. The two requests may produce different amounts of billed output even when both return a patch of the same size. Reasoning tokens are billed as output.
If 80,000 of the 100,000 input tokens are billed as cached reads, the same model-token estimate falls to $0.992 on Astra and $0.248 on Sol. This example assumes an existing cache read and excludes any charge for writing the cache. Estimate reads, writes, and the chosen retention window separately when a batch sends a long shared prefix many times. A change near the beginning of the prompt can affect cache reuse. Log the actual cache hit count from the API before turning an idealized case into a monthly forecast. OpenAI API pricing.
Long context and faster processing
With more than 272K input tokens, OpenAI applies the higher rates to the full request. For Standard uncached input and output, the rates rise to $16 and $60 per million on Astra and $4 and $15 on Sol. Input and cache rates double. Output rates rise by 50%. With 300,000 uncached input and 20,000 billed output tokens, model charges are $6.00 on Astra and $1.50 on Sol. Check whether the job can use a smaller evidence set, and run the narrower prompt through the same quality rubric before adopting it.
Discounted Batch costs half of Standard at the same context length. Fast mode costs twice Standard. OpenAI also lists Ultrafast at three times Standard through February 28, 2027, and six times starting March 1, Pacific time. The published multipliers apply to model-token rates, and expedited processing should be tested against the delay that matters in the product. A customer waiting for the first visible answer has a different deadline from a queue that only needs a finished file before morning. OpenAI API pricing and processing tiers.
Count failed attempts and human review
For automated work, divide the total paid model and tool charges by the number of results that pass review. Include prompts that time out and failed runs that incur charges. Treat a job with zero accepted results as a failure to meet the quality target. For a supervised workflow, add the cost of the reviewer's time. A cheap patch that takes half an hour to diagnose can cost more than a pricier run that passes the existing tests.
Suppose Sol costs $0.40 per attempt and Astra costs $1.60 per attempt. If Sol passes 16 of 20 jobs on the first attempt and Astra then passes the other four, the model spend is $14.40 for 20 accepted results, or $0.72 each. Sending all 20 straight to Astra would cost $32 if each passes on the first attempt. This is an illustrative calculation. It depends on a check that can identify the four failures before someone acts on them. Where an error is hard to detect, a human reviewer may need to inspect every output regardless of the model. The Sol pricing guide for the earlier release walks through the underlying API cost categories.
A commenter pointed out that the savings disappear when a failed run leaves another agent to clean up. Count that pass when you compare two workflows. Original comment.

Coding, benchmarks, and speed
Merge-ready patches and repository work
OpenAI's FrontierCode 2.0 comparison tests whether maintainers would merge changes to real repositories. At Max, OpenAI reports a gap under half a point and about five times lower cost for Sol. That supports starting a trial with Sol when the acceptance rule is precise, such as fixing one regression with a failing test or implementing a small change against an existing interface. The figure belongs to this benchmark and setup. A patch that builds and passes the visible tests can still miss a requirement the rubric never checked. OpenAI's launch benchmarks.
Artificial Analysis ran a separate evaluation with its own harness. It lists an Intelligence Index score of 62 for Astra Max and 57 for Sol Max in its November 19 snapshot. Its specific coding benchmark is labeled FrontierCode-AA 2.0, and its scores should be read with that harness and effort setting. The aggregate mixes several task types. If your team is choosing a model for one repository, measure patch acceptance directly on a fixed starting commit, with a test suite and a human review rule when the change touches behavior beyond those tests. The earlier Astra review and earlier Sol review provide historical baselines for a team already using those versions. Artificial Analysis's matched model comparison.
Data analysis and instruction following
Plotly's analytics exam recorded 41 of 43 for Astra and 40 of 43 for Sol. The full runs cost $4.11 and $1.22, respectively, through OpenRouter in Plotly's harness. Sol finished the median question in 10.5 seconds, and Astra in 12.4 seconds. Most sections tied. One extra hidden pattern accounted for the score difference. Plotly ran each model once and notes that its repeat runs of other models have varied by up to three points, so treat the one-question gap as an observation about this run. Plotly's benchmark report.
Ranthis found a different kind of gap on a sales-sheet extraction task. Both at High, Astra earned 10/10 on all three runs and Sol earned 9/10 on all three. Sol repeatedly omitted the same row after interpreting a price exception differently from the answer key. The median list-price costs per run were $0.0337 and $0.0085. That specific failure gives a better test idea than an overall ranking. Add rows where an unusual value still qualifies, then check the row count and total before trusting a model to process a whole workbook. Try the same input again before deciding that a dropped row is random. Ranthis's spreadsheet test and method.
Which one is faster?
Sol was quicker on both of those particular tasks. That result does not settle a Codex session with a large repository or an API request at another effort level. Record three timestamps for a local test. Capture when you send the prompt, when the first useful text appears, and when you have a result that passes your check. A model can start quickly and still leave a patch that takes longer to accept. A browser or repo agent may also spend much of its time waiting for a tool.
Run each task at the same stated effort first, then compare the settings you would actually use. High and Max are configuration labels. Equal labels can still produce different amounts of reasoning work. Alternate the order, keep the same tool permissions and time limit, and capture failures alongside successful samples. In an interactive workflow the first answer matters. In a queue the time to accepted result is usually the useful measure. Artificial Analysis's performance and effort data.
A second coding user noted that real work still often takes several prompts. Record those follow-up turns and any corrections you make. Original comment.

Where you can use Astra and Sol
Codex and ChatGPT Work. OpenAI announced both models for eligible Codex and Work accounts. Check the model selector in the product and workspace you plan to use. Availability in a workspace can depend on account access and admin settings. Keep the product name with each test result. For example, a comparison from Codex with repository tools enabled answers a different question from a Work session given a document. API token prices cannot tell you how much of a subscription allowance the same task will consume. OpenAI's rollout and availability.
OpenAI API. Use the explicit model IDs and log the processing tier and reasoning effort. Both model pages say the API rejects none. The Responses API documents compatible tools, including web search and computer use. Tool availability depends on the endpoint and setup. For a fair workflow test, give both models the same approved tools, the same read-only or test environment, and the same finishing condition. The Codex browser setup guide covers a separate example of how tool access changes what a coding agent can verify. Astra documentation, Sol documentation.
If you already use a previous release. Save a handful of accepted outputs and representative failures before migrating. Keep the old model ID, input, effort, and date with the baseline. A reduction in input or output tokens may help cost even when acceptance barely changes. A change in how the model treats exceptions may require a prompt or rubric update. The GPT-6.1 Sol browser-use guide illustrates why the tool setup belongs with the model name whenever behavior is compared across releases.
A developer building learning apps preferred their earlier Sol 6.1 results to Astra 6.2. Their report is a reason to keep a working baseline when switching generations. Original comment.

Check the rate assumptions in Tabbit Browser
Keep the two model specifications and the OpenAI pricing page in one tab group. For this comparison, the source-checking task is to match each API ID to three Standard short-context rates (uncached input, cached input, billed output), then locate the line that changes rates above 272K input tokens. Preserve the URL next to each row. The expected result is Astra at $8 / $0.40 / $40, Sol at $2 / $0.10 / $10, and the same full-request threshold for both. A saved pricing snapshot makes it easier to tell whether a change came from the provider or from your token mix.
Tabbit's multi-model research workflow can organize those sources next to a comparison. In a multi-model chat, select GPT-6.2 Astra and GPT-6.2 Sol. Attach the same two official model pages to the prompt and check whether each answer captures the long-context condition. Use the API to measure actual billable reasoning tokens and retries. The guide to keeping browser research tied to its sources covers the source-checking step in more detail.
Use only the two attached OpenAI model specifications. Return one row per model with the exact API model ID, the Standard short-context price in USD per 1 million tokens for uncached input, cached input reads, and billed output, plus the source URL. Below the table, say at what input size the long-context price starts and whether it applies to the entire request. Mark a value as unavailable if its source does not show it.
A result passes this source check if the three rates are in the right order, both model IDs match, and the threshold is described as applying to the entire request. Make that checklist explicit before reading the two outputs. Links should open the matching specification. Compare the rate card and acceptance notes side by side before using the figures in a forecast.
Which model should you choose?
| Your workload | Start with | What would change the decision |
|---|---|---|
| Small code changes with clear tests | Sol | Astra repeatedly fixes a regression that Sol misses under the same rubric |
| Cross-module changes with hard-to-detect failures | Astra on representative hard cases | Sol matches acceptance and review time on a replay of the same issues |
| Extraction, classification, or batch work | Sol | Missed records keep passing automated validation or require costly manual repairs |
| Source-heavy research or a critical document | Sol for first pass, Astra on flagged cases | Compare completeness, citations, and correction time with human review |
| Large API requests where context price dominates | Sol and a smaller input trial | Astra's accepted results justify the cost at the amount of context you actually need |
| Existing Codex or Work workflow | The cheaper option that passes in your workspace | A measurable improvement in acceptance or a shorter review for the same task |
For a new workflow, try Sol on a few representative tasks and write down which failures matter. Run Astra on those failures and a sample of the tasks Sol passed. If neither model meets the quality target, revise the rubric, inputs, or tools before rolling the change out. For workflows built around source pages, keep the rate cards, model IDs, and results together in Tabbit so someone else can rerun the same check.
FAQ
Which is better, GPT-6.2 Astra or GPT-6.2 Sol?
Start with Sol for everyday coding, structured output, and recurring jobs you can grade. Try Astra on difficult cases where it can reduce expensive rework or help you meet a quality threshold Sol has missed.
How much cheaper is GPT-6.2 Sol than Astra?
At equal token counts and the same OpenAI API tier, Sol costs 75% less in model token charges. The price of an accepted result can differ once you include reasoning tokens, cache behavior, tool calls, and retries.
Can I use GPT-6.2 Astra and Sol in Codex and ChatGPT?
OpenAI launched both in Codex and ChatGPT Work for eligible accounts, as well as in the API. Check the picker in the specific product and workspace you plan to use. API billing and subscription limits are separate.
Do GPT-6.2 Astra and Sol have the same context window?
OpenAI lists a 1,050,000-token API window for both, with up to 922,000 input tokens and 128,000 output tokens. Requests above 272K input tokens move the entire request to higher long-context rates.
Is GPT-6.2 Sol always faster than Astra?
Sol finished sooner in Plotly's analytics test and in Ranthis's spreadsheet check. Latency in your workflow also depends on reasoning effort, processing tier, tools, and retries. Compare time to first visible text and time to an accepted result separately.
What is the fairest way to compare the two models?
Give both the same tasks, context, tools, and acceptance checks. Start with the same reasoning effort, then tune each model and record the setting you would actually ship. Track failures as well as cost and time per accepted result.