GPT-6.2 Astra and Sol: cost per task decides the route

Which model should handle each class of work?
Test GPT-6.2 Sol on routine work and GPT-6.2 Astra on the demanding tasks, and do not lock either route before the evaluation runs. OpenAI introduced GPT-6.2 Astra and Sol on November 17, 2026. Token price matters, but the decision needs the cost per accepted task and the acceptance rate measured in the application that pays the bill.
Decision matrix / Key facts: Sol is a hypothesis for routine tasks, not a guarantee of lower cost per accepted task. Astra deserves a test on demanding work under the same acceptance criteria applied to the alternatives. Cache reads and cache writes are separate billing categories where they apply. The decision combines acceptance rate, spend, latency and fallback behavior.
A rate is not a final cost. A cheap response that needs fresh calls is not necessarily the cheapest delivery, because published prices for input, cache reads and output, plus the cache write charge described in OpenAI documentation, do not replace measuring attempts and quality inside the application that pays the bill.
On the OpenAI API, in Standard text with up to 272,000 input tokens, GPT-6.2 Sol costs US$ 2 per million input tokens and US$ 10 per million output tokens. GPT-6.2 Astra prices the same categories at US$ 8 and US$ 40. The rates read on November 19, 2026 do not show what an application will spend to deliver accepted work: that depends on actual use, on attempts and on the quality bar. Availability and terms on the Nexforce Router require separate confirmation.
What did OpenAI announce with GPT-6.2 Astra and Sol?
OpenAI positions GPT-6.2 Astra for complex professional work and GPT-6.2 Sol for everyday activity. The company presented both models, API prices and benchmark results. The announcement is the source for the vendor's claims, not an independent validation for any single application.
The date deserves precision. The extracted body of the announcement carries no publication date, but a page from OpenAI itself points to the new models in a November 17, 2026 update and shows the announcement card with the same date.
OpenAI positions GPT-6.2 Astra for complex work and GPT-6.2 Sol for everyday activity. Those descriptions set the first test. A class is more demanding for the operation when its verifiable criteria require, for instance, several steps, correct use of sources and consistency across parts of the delivery. The routine class needs its own acceptance criteria, defined before any model comparison.
The company reports access through the OpenAI API. That proves neither availability nor price on the Nexforce Router or through any intermediary. The rates below refer to the OpenAI API and were read on November 19, 2026. They are subject to the conditions of each modality.
Why does this matter to whoever pays for inference?
The gap between rates opens a routing hypothesis, it does not prove a saving. In Standard text with up to 272,000 input tokens, Sol costs less per token in all four categories of the table. To choose between routes, the team has to add attempts, fallback calls and tasks that were never accepted.
On the OpenAI API, GPT-6.2 Sol costs US$ 2 per million regular input tokens and US$ 10 per million output tokens in Standard text with up to 272,000 input tokens. For GPT-6.2 Astra the matching rates are US$ 8 and US$ 40. Cache reads cost US$ 0.10 on Sol and US$ 0.40 on Astra per million tokens under the same conditions. The prices were read on November 19, 2026 and are not a Nexforce Router quote.
The bill does not measure quality.
Cost per accepted task divides the spend of the calls tied to a task set, failures and fallback included, by the number of tasks accepted in that set. The analysis of token price and AI cost per task covers the distinction between a rate and an outcome. Without data on attempts, consumption and acceptance in the application, OpenAI rates do not prove a saving for any specific route.
What do GPT-6.2 Astra and Sol cost on the API?
The rates OpenAI publishes for Standard-mode text and requests up to 272,000 input tokens are the ones in the table, per million tokens. The write row assumes 30-minute retention. The values come from the OpenAI API, not from a Nexforce Router quote.
| Component per million tokens | GPT-6.2 Astra | GPT-6.2 Sol |
|---|---|---|
| Regular input | US$ 8.00 | US$ 2.00 |
| Cache read | US$ 0.40 | US$ 0.10 |
| Cache write, 30-minute retention | US$ 10.00 | US$ 2.50 |
| Output | US$ 40.00 | US$ 10.00 |
Some conditions move the bill. According to the official pages for GPT-6.2 Astra and GPT-6.2 Sol, requests above 272,000 input tokens carry doubled input and cache rates and an output rate multiplied by 1.5 for the entire request. Batch, Fast and Ultrafast have prices of their own as well.
For 12-hour retention, Standard cache writes on short context cost US$ 20.00 per million tokens on GPT-6.2 Astra and US$ 5.00 on GPT-6.2 Sol. The cache documentation describes those rates as total write values, not automatic additions on top of the regular input rate. The team should check prices and contract terms on the day of use.
OpenAI reports that GPT-6.2 Astra input and output rates are 20% below GPT-6 Astra. In Standard text with up to 272,000 input tokens, GPT-6.2 Sol keeps the input, cache read, 30-minute write and output rates of GPT-6.1 Sol. The Ultrafast modalities differ: until February 28, 2027, GPT-6.2 Sol costs three times the Standard rate, while GPT-6.1 Sol costs six times. The comparison is of rates, not of cost per accepted task. The GPT-6 Astra record helps place the change.
What does the Agents' Last Exam show?
OpenAI states that GPT-6.2 Astra scored 5.2 points above GPT-6 Astra and 5.5 points above Claude Fable 5.2 on the Agents' Last Exam. The test evaluates long-running professional workflows. These are results published by the company, with no independent reproduction presented here.
On the Agents' Last Exam, OpenAI states that GPT-6.2 Astra landed 5.2 points above GPT-6 Astra and 5.5 points above Claude Fable 5.2. The evaluation covers long-running professional workflows. The announcement also presents GPT-6.2 Sol for everyday work, without that point comparison establishing its position on the test. OpenAI reports that the Claude Fable 5.2 leaderboard result excludes nine tasks that used a fallback model. The comparison has limits. The company mentions cost reasons in the evaluation, but the excerpt consulted does not define the accepted-task denominator used in this analysis. The published points are not a measurement of the reader's own operation, and Nexforce does not claim to have tested the models on that benchmark. To evaluate an internal class, the team has to log prompts, tools and acceptance criteria. The analysis of cost per task in routing details the comparison against failures and accepted work.
How do you calculate cost per accepted task?
Cost per accepted task is the spend of the calls tied to a task set divided by the number of tasks accepted in that same set. Include failed attempts and fallback. With no accepted tasks the ratio is undefined: record the spend and the failures.
Cost per accepted task divides the spend of the calls in a task set by the number of tasks accepted in that same set. The numerator includes failed attempts and fallback, even when the task is never accepted. The denominator counts accepted tasks, not calls and not every attempted task. Every call carries its own rate. To get inference spend, apply the rates for the model, provider, modality and contract of each call to the billed quantities of regular input, cache read, cache write and output. When prices are per million tokens, divide the products by one million and add the components. Do not count tokens twice: if reads and writes sit inside the input total, subtract those categories to get regular input. Check the usage fields and the invoice, including write rates by retention. With no accepted tasks the ratio is undefined; present spend and failures instead of recording zero cost.
The numerator follows every attempt, not just the final response. Report cost per accepted task next to the acceptance rate, defined as accepted tasks divided by attempted tasks in the same set and attempt horizon. A cost that looks low does not remove an inadequate acceptance rate.
Scope needs a declaration too. External tools, infrastructure and human review join total cost only when they are measured and included in the numerator. Comparing a route with review against another without review produces numbers for different questions.
When does cached input change the bill?
Cache reads change cost when part of the prompt is reused and billed as a cache read. OpenAI recommends keeping prefixes unchanged and adding instructions to the conversation to favor reuse. That guidance does not guarantee a cache hit on any call.
A hit does not measure its own size. In the observed window, the per-request hit rate is the number of requests with any cache read divided by total observed requests. The reused-token share is the number of input tokens billed as cache reads divided by total input tokens recorded in those same requests and that same window.
The two metrics answer different questions. A call with a hit may reuse only part of the prompt, and a high hit rate does not mean most input tokens came from cache. If a report does not carry the denominators or the needed fields, neither indicator can be inferred from the rate.
Writes belong in the diagnosis. A low read rate on its own does not show whether reuse volume paid for the billed writes. Compare the effective cost of the calls, the retention chosen and the observed reuse pattern, without assuming an eligibility rate the provider never disclosed.
The prompt cache described by OpenAI is not automatically the same response and embedding cache mechanism documented by the Nexforce Router. Before crediting a layer with savings, check what each report records and how the charge appears in the matching contract.
What changes in the routing policy?
The launch adds two candidates to the test; it does not determine a universal route. The policy should compare models by class of work and keep acceptance rate, cost per accepted task and latency side by side. Sol for routine tasks and Astra for demanding ones are starting hypotheses.
For routine tasks the team can test GPT-6.2 Sol; for demanding classes it can test GPT-6.2 Astra under the same acceptance criteria applied to the alternatives. These are hypotheses, not settled routes. On the OpenAI API, Sol carries lower rates in the Standard text categories for requests up to 272,000 input tokens, which does not prove a lower cost per accepted task. Each class needs quality requirements, a failure ceiling and latency defined before the comparison. Discard routes that miss those limits; among the rest, compare cost per accepted task with the acceptance rate alongside, in the same set and attempt horizon. Spend must include failed calls and fallback, with the rate that applies to each call. If no candidate satisfies the requirements, keep the current route. Before testing GPT-6.2 Astra or Sol on the Nexforce Router, confirm availability and commercial terms: OpenAI API prices do not prove them.
| Decision | Before per-task measurement | With per-task measurement |
|---|---|---|
| Initial selection | Rank models by per-token rate | Test candidates under the same acceptance criteria |
| Cost | Look only at the final call | Add the billed categories of every call, attempts and fallback |
| Cache | Apply the read rate to the whole prompt on assumption | Separate reads, writes and regular input by actual use |
| Quality | Inspect one response in isolation | Report acceptance rate on a representative set |
| Route change | Swap the model for all traffic | Change the policy by class and track the outcome |
The choice comes after the filters. First discard routes that miss the quality criteria, the failure ceiling and the latency defined for the class; among the rest, compare cost per accepted task with the acceptance rate alongside, using the same cost scope.
The policy can keep the current route for part of the work. The corporate AI gateway guide describes the infrastructure where selection rules and observability support that decision, without turning an announced rate into assumed savings.
How do you test the change without confusing price with outcome?
The test has to tie every task to its calls and to the accepted outcome. Compare candidates on the same representative set with the same acceptance criteria, attempt horizon and cost scope. Record configuration differences you cannot avoid before deciding on any route change.
OpenAI presents GPT-6.2 Sol for everyday work and GPT-6.2 Astra for complex professional work, but that split does not replace an evaluation of the team's own load. The test needs traceability. It starts with representative tasks per class and observable acceptance criteria defined before comparing candidate routes. The team logs prompts, tools, configuration and attempt limits to identify differences that affect results. A standalone average can hide failures in tasks with more steps or larger context. The report therefore separates classes and records the spend of every call, failures and fallback included, plus latency up to the accepted task. Acceptance rate rides next to cost per accepted task. If no task is accepted, the cost ratio is undefined; the report presents spend and failures. Availability and commercial terms for the models on the Nexforce Router need separate confirmation before the test.
The procedure is verifiable:
- Define the class, the acceptance criteria and the configuration. Pick representative tasks and describe the observable requirements of the delivery, including mandatory information and consistency checks. Document prompts, model, tools, processing mode, attempt limits and the evaluation criteria, with context and output size and distribution.
- Tie calls to the task. Include attempts, failures and fallback. Separate regular input, reads, writes by retention and output per billed category; apply each call's rate and record the spend of unaccepted tasks as well.
- Report quality and cost together. Calculate acceptance rate and cost per accepted task for each route on the same set. Declare failure spend, cache data and uncertainty when the sample is small.
- Measure the real wait. Record end-to-end latency up to the accepted task, including attempts and fallback, plus percentiles and observed throughput under comparable concurrency and rate limits.
- Decide by class. Apply the policy filters and keep the current route if no alternative satisfies the constraints. Record the decision and who reviews or reverts the route if acceptance rate falls below the ceiling set for the class.
Set composition matters. An average dominated by easy requests can hide failures in tasks with more steps or larger context, so the report should show the distribution by class rather than a single aggregate. That split also helps identify when a change helps one class and hurts another.
After the change, track the same metrics and the contracted price. If quality, failures or latency leave the defined limits, revise or revert the policy. The announcement consulted sets no acceptance threshold or saving that applies to every workload; each operation has to define and test its own criteria.
Frequently asked questions
Token price does not determine which route delivers the lowest cost per accepted task. The answers depend on applicable rates, recorded use and acceptance criteria; the OpenAI announcement provides a starting point, while the production decision requires measurement on the team's own workload.
GPT-6.2 Sol is not necessarily the cheapest route per accepted task, even when its per-token rates sit below GPT-6.2 Astra in the Standard text and context conditions OpenAI published. The comparison depends on consumption, attempts and the operation's acceptance criteria. Add the spend of the calls tied to the set, failures and fallback included, and divide by the number of tasks accepted in that same set. Acceptance rate uses attempted tasks as the denominator and must ride next to cost per accepted task. If no task is accepted, the cost ratio is undefined; report spend and failures separately. Cache reads and cache writes are separate billing categories where they apply. The OpenAI API rates, read on November 19, 2026, prove neither availability nor commercial terms for the models on the Nexforce Router.
Is GPT-6.2 Sol always cheaper per accepted task?
No. On the OpenAI API, in Standard text and requests up to 272,000 input tokens, GPT-6.2 Sol carries lower rates than GPT-6.2 Astra for regular input, cache reads, cache writes with 30-minute retention and output. Lower rates do not guarantee lower cost per accepted task; with no accepted tasks, that cost is undefined.
What is the difference between a cache rate and a cache hit?
The read rate is the price of each token billed in that category. A cache hit means some reuse happened in a request; the per-request hit rate and the reused-token share have different numerators and denominators. Cache writes carry their own rate where they apply.
Does a benchmark predict my application's bill?
No. OpenAI published Agents' Last Exam results for the evaluation configuration, with a caveat about nine tasks excluded from the Claude Fable 5.2 result. The comparison does not supply a cost per accepted task for the reader's operation, whose prompts, tools and criteria may differ.
How do you measure cost per accepted task when calls fail?
Add the itemized cost of every call, failures and fallback included, and divide by the number of tasks accepted in the same set. Report the acceptance rate alongside, with attempted tasks in the denominator. If none is accepted, the cost ratio is undefined; present spend and failures.
When should the team review a route?
Review when quality, latency or failures stop meeting the class limits, or after a relevant change in prices and configuration. Compare the alternatives on the same set, with identical attempt horizon and cost scope. Recording the acceptance rate keeps the decision from resting on price alone.
References and Further Reading
The announcement is the source for the statements attributed to OpenAI. The rates come from the API. The November 17 date appears on the card and in the update on the company's page about GPT-6 Sol and Luna; the pricing and cache pages were read on November 19, 2026.
OpenAI's announcement presents GPT-6.2 Astra for complex professional work and GPT-6.2 Sol for everyday activity. The company credits GPT-6.2 Astra with a 5.2-point lead over GPT-6 Astra on the Agents' Last Exam, an evaluation of long professional workflows. That result was not independently reproduced in this analysis. OpenAI also reports that the Claude Fable 5.2 leaderboard result excludes nine tasks that used fallback. Each model page details API prices and terms, while the cache documentation separates regular input, reads and writes. The pricing and cache sources were read on November 19, 2026 and may change. None of them proves availability of the models on the Nexforce Router or cost per accepted task for a specific operation. The team should check the applicable terms before the test and measure outcomes with its own acceptance criteria.
- OpenAI: Introducing GPT-6.2 Astra and Sol, the model announcement.
- OpenAI: Introducing GPT-6 Sol and Luna, the dated update and card.
- OpenAI: GPT-6.2 Astra pricing and GPT-6.2 Sol, API terms.
- OpenAI: prompt caching, usage categories and retention.
- Nexforce: cost per task and routing, further reading.
The next decision belongs to the policy, not the model
Pick one class of work and define what counts as an accepted task. Then compare routes with cost per accepted task and acceptance rate in the same report, without excluding failure spend or applying one model's rate to another model's fallback.
The Nexforce Router brings together per-key routing rules and call observability to support that control. The team still has to tie records to each task's outcome and confirm model availability and commercial terms before the test.
Measurement decides the route. GPT-6.2 Sol and GPT-6.2 Astra are candidates to test, not automatic choices for every class of work. For each class the team should define minimum quality, a failure ceiling and latency before comparing routes on the same task set. Cost per accepted task divides the spend of the calls, failures and fallback included, by the number of tasks accepted in that set. With no acceptances the ratio is undefined; the report has to show spend and failures, not zero cost. Acceptance rate belongs next to cost, with the attempt horizon and cost scope recorded for the compared routes. The Nexforce Router supports control with per-key routing rules and call observability, but the team has to tie calls to outcomes. Confirm availability and commercial terms before the test and keep the current route if no candidate meets the limits.

Accelerate your company'sbusiness and operational efficiency
We design the technology of tomorrow to boost your business operational scale
Talk to a SpecialistRelated articles

AI API key theft: what Amazon's own records describe
Records captured by Amazon describe AI API key theft used in the search for more credentials, with the external results unconfirmed.
Read more
OpenAI Control Room puts the stop button at inference
OpenAI placed the agent stop at the inference layer: every request requires authorization and a stopped job is refused on engines configured to fail closed. The transferable part is the placement of the control, not the product.
Read more
Businesses in ChatGPT: OpenAI and B2B software discovery
OpenAI announced Businesses in ChatGPT in beta, with company profiles, product feeds and agents for eligible businesses. For software vendors, the launch raises questions about discovery, commercial information and distribution without confirming agent access in Brazil.
Read more