A lower model bill starts with choosing the right workload, then counting everything it takes to produce an acceptable result.
OpenAI introduced GPT-6.2 Astra and GPT-6.2 Sol on November 17. Its release announcement positions Astra for demanding professional projects and Sol for a wider range of everyday work. Both are available in ChatGPT Work, Codex, and the API, with account and workspace conditions that matter when a team plans a rollout.
For founders, there are two decisions here. One concerns access through a subscription or managed workspace. The other concerns the cost and behavior of an application calling an API. The same model name can appear in both settings without making their billing rules interchangeable.
The useful starting point is the published tariff. From there, a team can calculate a fixed workload and decide what evidence a migration needs. OpenAI’s performance comparisons provide additional context, but they remain evaluations under the conditions the company describes.
Check the product surface before the model picker
The announcement lists Plus, Pro, Enterprise, and Edu access in Work and Codex. Eligible Enterprise and Edu users also depend on their administrator enabling access. OpenAI’s ChatGPT release notes describe the Work and Codex preview separately from the existing model choices in regular Chat.
That distinction helps explain a common source of confusion. A founder may have the right paid account but be looking in a different product surface. A colleague in a managed workspace may have different enabled models from a personal subscriber. Confirm both the account and the interface before treating a missing option as a failed installation.
OpenAI also differentiates Ultrafast access by plan. The release describes both models for Pro 500 subscribers and Sol for Pro 200 subscribers. In the API, the announced model identifiers are gpt-6.2-astra and gpt-6.2-sol, with Ultrafast available at launch.
Use the exact service mode in a cost comparison. A calculation based on standard API rates cannot establish the price of a different service tier or the number of tasks included in a subscription. Keep the subscription decision and the application’s API estimate in separate columns.
Compare a fixed token workload first
The current Astra and Sol model pages list standard API rates. Astra costs $8 per million input tokens and $40 per million output tokens. Sol’s corresponding rates are $2 and $10. Cached input has a separate rate: $0.40 for Astra and $0.10 for Sol per million tokens.
Here is a reproducible short-context Standard-rate example: one million uncached input tokens and 200,000 billable output tokens across multiple requests. It excludes tools, taxes, retries, cache writes, and other service charges.
| Standard API model | Input charge | Output charge | Total for the example |
|---|---|---|---|
| GPT-6.2 Astra | 1 × $8 = $8 | 0.2 × $40 = $8 | $16 |
| GPT-6.2 Sol | 1 × $2 = $2 | 0.2 × $10 = $2 | $4 |
At these fixed counts, Sol’s bill is one quarter of Astra’s. That is tariff arithmetic. It does not measure which model finishes a particular job, how much reasoning it uses, or whether a human accepts the output.
The distinction becomes important for a long coding job. A lower-priced model can spend more tokens on repeated attempts. A higher-priced model can still be uneconomical if its result needs extensive review. The bill for an acceptable result depends on both the rate and the work performed.
A long request changes the tariff
Astra’s model page lists a 1,050,000-token context window, with up to 922,000 input tokens and 128,000 output tokens. A context-window label therefore needs to be read alongside the input and output limits. The one-million-input-token workload above is spread across requests.
The same documentation says that requests above 272K input tokens double Astra’s input and cache rates. Output costs 1.5 times the short-context rate for the full request. This is why the examples specify short-context Standard pricing.
For a separate example, take one Astra request with 300,000 uncached input tokens and 20,000 billable output tokens. At the documented long-context rates, input costs 0.3 × $16, or $4.80. Output costs 0.02 × $60, or $1.20. The total is $6 before other charges.
Applying the short-context prices to that same request would produce $3.20 and understate the bill by $2.80. A token counter alone cannot catch that mistake. The estimate also needs the request size and the tariff that size triggers.
Caching changes the input side of the example
Suppose 80% of the one million input tokens receive the published cached-input rate. The other 20% remain uncached. Keep the same 200,000 billable output tokens.
Astra’s input charge becomes $1.60 for uncached input plus $0.32 for cached input, or $1.92. Add the $8 output charge, and the total is $9.92. Sol’s input charge becomes $0.40 plus $0.08, or $0.48. Its total is $2.48.
Those totals count cached reads and exclude any cache-write charges. The model pages list separate prices for writing retained context. A first run or a newly written prefix can therefore change the bill.
The totals also assume the tokens actually qualify for caching. Repeating a similar-looking prompt does not prove that the service billed it as a cache hit. Read the returned usage and billing records rather than estimating the hit rate from the text alone.
The announcement recommends keeping prompt prefixes stable and appending new instructions. That is a useful design consideration for a repeated workflow. Keep the fixed instructions, source version, and changing request distinguishable so the application can reuse context without silently serving an outdated instruction.
Count accepted tasks and all attempts
An operational comparison needs a denominator that reflects the product’s job. For an invoice extractor, that could be a document whose required fields pass review. For a coding agent, it could be a patch that meets the task’s checks and a maintainer accepts.
Consider an illustrative workload of 100 tasks. If each Sol task attempt costs $4 and reviewers accept 80 results on the first attempt, the initial spend is $400. If the other 20 tasks each need one additional equally priced attempt, spend rises to $480. If all 100 results are then accepted, the average becomes $4.80 per accepted task.
That scenario is a calculation, not a measurement of either model. It shows why the number of attempts belongs beside the token price. A comparison that discards failed runs makes a system look cheaper than the product owner’s bill.
Review time belongs in the decision too. A founder can record model spend and reviewer minutes separately, then apply the team’s own hourly cost. Keep that assumption explicit. The API vendor does not determine what an hour of your team’s review work is worth.
Read benchmark claims within their stated boundaries
OpenAI reports improvements across professional outputs, coding, computer use, and scientific work. It also reports lower cost per task on several evaluations. Those claims use different tasks, effort settings, and scoring rules from the fixed-token examples above.
A benchmark percentage needs its own definition of success. A test of complete professional assignments measures something different from a preference vote on a generated website. An average can also conceal tasks where the model remains unreliable.
Use the benchmark closest to the intended application to choose a starting candidate. Then hold the application’s own acceptance rule steady. Saving the same source files, repository revision, instructions, and review criteria makes a later comparison easier to interpret.
Give a migration a measurable stopping point
A small pilot can make the model choice concrete. Choose a representative set of tasks, record the current system’s accepted outputs and cost, then repeat the work with the candidate model. Keep failed attempts and manual corrections in the record.
Set the product’s limits before examining the results: how much the job may cost, how long it may take, and which mistakes prevent release. A fast response that misses a required field remains a failed result under that rule.
The published rates let you estimate a budget today. An application-level record then shows whether Astra’s extra capability justifies its price or Sol delivers the result at less cost. That is the comparison a founder can use when deciding what to ship.



