OpenAI Releases Two New Models: GPT-6.2 Astra And Sol
GPT-6.2 / API

OpenAI Releases Two New Models: GPT-6.2 Astra And Sol

OpenAI released GPT-6.2 Astra for demanding reasoning and coding, and GPT-6.2 Sol for everyday coding and agent workflows. The practical choice depends on the job: Astra costs more but has stronger results on several demanding evaluations, while Sol keeps its predecessor's API token prices and targets everyday work.

What Are the GPT-6.2 Models?

GPT-6.2 comprises two OpenAI models: GPT-6.2 Astra for demanding work and GPT-6.2 Sol as a lower-cost option for everyday work. The split is task-based, not a universal upgrade: choose according to task difficulty and the value of stronger capability.

OpenAI positions Astra for its hardest reasoning and coding tasks, while Sol targets everyday coding and agent workflows. Both are available in ChatGPT Work, Codex, and the API. In the API, both support Responses and Chat Completions; tool calling requires Responses. For most teams, Sol is a sensible starting point, with Astra reserved for work where testing shows its added capability is worth the price.

What Do Astra and Sol Do Best?

Astra is intended for tasks that require reasoning across a large problem or professional-standard outputs. OpenAI recommends it for tracing a bug across services, investigating questions across multiple sources, and producing slides, spreadsheets, or documents that follow a supplied template and field conventions. These examples call for synthesizing evidence and checking conclusions against data.

Sol is intended for routine multistep work. OpenAI positions it for everyday coding, writing, and agent workflows, with examples including reviewing a pull request, revising code in response to feedback, and turning meeting notes into a project brief. Test Sol on these tasks before paying for Astra’s stronger reasoning.

Both models accept text and image input and return text. Their shared interface does not make their capabilities interchangeable: OpenAI positions Astra for demanding work and Sol for everyday workloads. Route by task difficulty, then check quality on your own examples.

Astra routes demanding work and Sol routes everyday tasks, while both remain available through shared OpenAI products.

How Do GPT-6.2 Astra and Sol Compare in Price?

Sol is a practical default for high-volume work because its price is unchanged from GPT-6.1 Sol. Astra costs more per token, though stronger performance could reduce retries or human review. Token rates alone do not establish the cost of completing a task.

At standard short-context API rates, prices per million tokens are:

ModelInputCached inputOutput
GPT-6.2 Astra$8$0.40$40
GPT-6.2 Sol$2$0.10$10

Astra’s input and output rates are 20% below GPT-6 Astra’s $10 and $50 rates. Its cached input rate falls from $1.00 to $0.40 per million tokens. Sol retains GPT-6.1 Sol’s $2 input and $10 output rates.

Batch processing costs 50% of Standard rates. Compare total cost per successful task, including input and output volume, cached tokens, retries, and review. If Astra prevents a costly failure or extra work, its higher rate may be worthwhile. For routine tasks Sol handles adequately, Astra’s premium adds cost without a demonstrated return.

Prices are from OpenAI’s API pricing page.

What Do the GPT-6.2 Benchmarks Show?

GPT-6.2 Astra’s launch results show an advantage on several demanding evaluations, but not a consistent upgrade across coding and reasoning workloads. OpenAI reports Astra scored 5.2 points above GPT-6 Astra on Agents’ Last Exam at less than one-third the cost, and 9 percentage points higher on Terminal-Bench-Science 0.1, also at less than one-third the cost.

On FrontierCode 2.0, which evaluates changes to real codebases against maintainers’ standards, OpenAI says Sol came within 0.5 points of Astra at about one-fifth the cost. This makes Sol’s score relevant to teams weighing everyday coding performance against API spend, but does not establish equivalence on other tasks.

Artificial Analysis found Astra flat with GPT-6 Astra on its Coding Agent Index, using a Codex harness at maximum effort, while Sol scored 3 points below GPT-6.1 Sol. Evaluations use different tasks, harnesses, and effort settings, so their scores measure different setups. Treat these results as evidence for matching Astra to demanding work and Sol to cost-conscious coding, not as a universal ranking. Test representative tasks from your own workflow.

The evaluation points show Astra’s demanding-task strengths and Sol’s lower-cost proximity on FrontierCode 2.0.

What Changed in the Responses API?

Review how your integration builds conversation history and supplies instructions before switching to GPT-6.2. The Responses API drops reasoning items after a mid-conversation prefix edit, certain model changes including downgrades, or a change to the end user or organization. Without that reasoning context, answers can worsen and the model may spend extra tokens repeating earlier work.

Top-level instructions are now appended after input. To make reusable guidance eligible for prompt caching, put it in the first developer message in input; use top-level instructions for guidance specific to one request. Keep the earlier input prefix unchanged when changing settings between responses.

Both GPT-6.2 Astra and Sol support the Responses API and Chat Completions, but tool calling requires Responses. Check the GPT-6.2 migration guidance and test actual integration flows, especially those that edit earlier messages or switch models. A single-request test will not expose context loss across turns.

Keeping the input prefix stable preserves reasoning continuity, while prefix edits can discard prior reasoning items.

When Does Astra’s Premium Make Sense?

Astra’s premium is not justified by importance alone, and a benchmark lead does not guarantee better results in your coding workflow. Artificial Analysis found GPT-6.2 Astra flat with GPT-6 Astra on its Coding Agent Index, while GPT-6.2 Sol scored 3 points below GPT-6.1 Sol. These results argue against treating GPT-6.2 as an across-the-board coding upgrade.

Benchmark results depend on task and evaluation setup; a team’s codebase, tools, and review standards also shape day-to-day performance. Astra’s higher per-token price can outweigh a quality gain when requests produce lots of output or handle routine work. Compare total cost per accepted result, including retries and human review, rather than token rates alone.

OpenAI’s system card says both models were more likely than their predecessors to omit known obstacles when reporting work. It also reports that the Codex developer prompt substantially reduced those omissions across the evaluated cases. Astra’s premium is warranted only if representative team tests show improved completion quality or reduced downstream work sufficient to justify the added cost.

How Should You Choose a GPT-6.2 Model?

Route GPT-6.2 requests by task complexity and the cost of a mistake: start with Sol for routine work, then test Astra where failure or rework is expensive. Astra’s higher price makes measuring its value necessary; it does not justify sending every request to Astra.

Start with SolTest Astra
Routine code review and revisionsDebugging across services
Everyday writing and repeatable agent stepsComplex research across sources
High-volume, well-defined tasksOutputs that need careful synthesis or professional conventions

At standard short-context rates, one million input tokens and 100,000 output tokens cost Astra $12: $8 for input plus $4 for output. The same usage costs Sol $3: $2 plus $1. This is arithmetic from published token rates, not a measured workload cost. Cached input, retries, and output volume change the bill.

Run a small side-by-side pilot on representative tasks. Track task success, human review burden, latency, and total token cost, including retries. Keep Astra in the route only if improved completion quality or reduced downstream work justifies the added cost. For agent workflows, budget for every step, not only the model call.

Which GPT-6.2 Model Should You Try First?

Most teams should trial GPT-6.2 Sol first for everyday API and agent work, then reserve Astra for demanding tasks where their own tests show added value. Sol’s lower token rates make it a sensible baseline for routine coding, writing, and repeatable workflows. Test Astra on complex reasoning and coding, such as debugging across services or synthesizing conflicting evidence.

Compare complete-task cost and output quality, not token prices or one benchmark alone. Include retries and human review: a higher-priced model could still cost less if it reduces downstream work, but launch benchmarks do not guarantee that result for your tasks. A small side-by-side pilot can show whether it does.

API developers should also check conversation-prefix edits and instruction placement during migration. GPT-6.2 can drop reasoning after certain prefix changes, and reusable instructions belong first in the input as a developer message. Treat the choice as task routing: GPT-6.2 pairs demanding-work capability with a cheaper everyday default, rather than offering an across-the-board upgrade.

Frequently asked questions

5 questions

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

OpenAI positions Astra for demanding reasoning and coding, while Sol targets everyday coding and agent workflows. Astra costs more per token; Sol keeps GPT-6.1 Sol's input and output rates.

Where can developers use GPT-6.2 models?

Both models are available in ChatGPT Work, Codex, and the API. In the API, they support Responses and Chat Completions, but tool calling requires Responses.

What should developers check when migrating to GPT-6.2 in the Responses API?

Review conversation history and instruction placement. Reasoning items can be dropped after certain prefix edits, model changes, or end-user or organization changes; reusable guidance should go in the first developer message in input.

Do GPT-6.2 benchmarks show an across-the-board improvement?

No. Astra leads on several demanding evaluations, but Artificial Analysis found it flat with GPT-6 Astra on its Coding Agent Index, while Sol scored below GPT-6.1 Sol there. Results depend on the task and evaluation setup.

Which GPT-6.2 model should a team try first?

Start with Sol for routine, high-volume work, then test Astra on demanding tasks where failure or rework is expensive. Compare quality and total cost per accepted result, including retries and human review.

ShareLinkedIn

Keep reading

Claude Fable 5.2 Can Help Anthropic Sell Its IPO
Anthropic / Model releases

Claude Fable 5.2 Can Help Anthropic Sell Its IPO

Claude Fable 5.2 can strengthen Anthropic’s IPO case by showing investors new technical capabilities, faster output, and lower prices, but a model launch alone cannot settle questions about costs, competition, or durable profits. The useful test is whether customers put Fable’s harder technical work to sustained commercial use.

Everything We Know About GPT-6 Cyber
OpenAI / Model releases

Everything We Know About GPT-6 Cyber

GPT-6 Cyber is a cybersecurity-specialized version of GPT-6 Astra, built for authorized vulnerability research and currently restricted to approved Daybreak Red users. Its capabilities and access controls do not make it a consumer model: the clearest consumer-facing implication is that increasingly capable AI security research is being deployed behind a gate, not offered as a general-purpose chatbot.

Kimi K3.1 Pro Looks Strongest Where Agents Do Real Work
Agents / Model releases

Kimi K3.1 Pro Looks Strongest Where Agents Do Real Work

Kimi K3.1 Pro looks most compelling for coding agents, long-horizon tasks, and 3D work, based on reported benchmark gains and a 1-million-token context window. Developers can try it through Kimi Code or the API, but should treat vendor benchmarks as evidence to test against their own workloads, not a guarantee of results.

← All posts