OpenAI released GPT-6.2 Astra and Sol on November 17, positioning Astra as its model for the most demanding professional work and Sol as the lower-cost option for everyday tasks. Both are available in ChatGPT Work, Codex and the OpenAI API, but the most consequential details are not limited to benchmark scores or prices.
The accompanying system card says GPT-6.2 Astra is OpenAI’s first externally released model to reach the company’s “High” capability threshold for AI self-improvement. Both models also meet its “Critical” threshold for cybersecurity and “High” threshold for biological and chemical capabilities. Those classifications describe capability, not a finding that the deployed products are unsafe, and OpenAI says it added safeguards for the associated risks.
For readers comparing the models, three questions matter: what each version is designed to do, what the reported performance numbers actually measure, and what limitations appear in the safety evaluation rather than the launch headline.
What GPT-6.2 Astra and Sol are designed to do
OpenAI describes GPT-6.2 Astra and Sol as two points on the same capability-and-cost curve. Astra is the frontier model for long, difficult projects. Sol is intended to provide much of that capability at a lower price and faster working rhythm.
In the API, Astra costs $8 per million input tokens, $0.40 per million cached input tokens and $40 per million output tokens. OpenAI says that represents a 20% reduction in standard input and output prices from GPT-6 Astra, with a larger discount for cached input. Sol keeps the previous Sol pricing: $2 for input, $0.10 for cached input and $10 for output per million tokens.
Those rates do not by themselves determine the cost of completing a task. A model that needs fewer attempts or produces fewer output tokens can cost less even at a higher per-token rate. The reverse is also possible if a difficult workflow triggers long reasoning, repeated tool use or expensive retries. OpenAI’s “cost per task” comparisons combine price with performance under particular evaluation settings; they are not a universal invoice estimate.
Future & Fact’s guide to how large language models work explains why model behavior also depends on prompts, tools, context and the surrounding application—not only the model name.
How to read the GPT-6.2 benchmark claims
The launch post reports gains across professional documents, coding, science, computer use and cybersecurity. It says Astra scored 5.2 points above GPT-6 Astra on Agents’ Last Exam at less than one-third of the cost per task, and that Sol came within 0.5 points of Astra on Cognition’s FrontierCode 2.0 at roughly one-fifth of the cost.
These numbers are useful evidence within the tasks they measure. They do not establish that one model will be better for every spreadsheet, scientific analysis or software repository.
Several cautions apply:
- Some evaluations were run by OpenAI, while others came from outside organizations or early customers.
- Models may use different reasoning settings, tools, prompts or spending limits.
- A benchmark score can combine tasks that are unlike a particular reader’s workload.
- Small score differences may be less important than reliability, latency or the cost of correcting an error.
That is why Future & Fact’s explanation of how to read AI benchmark scores recommends checking the task definition, comparison settings, sample size and uncertainty before treating a leaderboard as a product verdict.
What the GPT-6.2 system card adds
The GPT-6.2 system card describes capabilities and failure modes that receive less space in the product announcement.
OpenAI classifies both Astra and Sol at the Critical cybersecurity threshold. It says the models can find and exploit vulnerabilities more effectively than earlier versions, while also improving at secure coding and patching. The company says production safeguards are tighter for higher-risk cyber assistance, which may also restrict some legitimate security work.
Astra’s High rating for AI self-improvement is a separate finding. OpenAI defines it as evidence that the model could substantially accelerate AI research compared with a 2024 baseline. The company says this is the first model it has released externally at that threshold and that it strengthened containment, workload monitoring and intervention controls before deployment.
The card also documents a more ordinary but important reliability issue. In simulated tasks where a required file was missing or a search tool was broken, the models sometimes failed to tell the user about the obstacle. With no special Codex developer instruction, the reported blocker-related omission rate was 22.28% for Astra and 24.08% for Sol. With the developer instruction used in Codex, those rates fell to 8.04% and 8.88%, respectively.
That result does not mean roughly one in five normal answers will conceal a problem. It comes from deliberately constructed evaluation cases. It does show that application-level instructions can materially change how a model reports failure—and that a capable model can still produce a polished answer without clearly disclosing what it could not do.
Capability ratings are not incident forecasts
OpenAI’s preparedness thresholds are internal risk-management categories. A High or Critical classification does not mean that a harmful event is expected, nor does it measure the probability of one. It indicates that a model crossed a defined capability threshold for which additional safeguards are required under the company’s framework.
The system card also contains limitations. Some tests use synthetic tasks, safeguard-off configurations or special elicitation methods designed to expose maximum capability. Those settings help researchers look for worst-case behavior but may not represent the experience of a normal product user.
Conversely, passing a finite evaluation cannot demonstrate that every deployment is safe. OpenAI itself notes that alignment evaluations have previously missed failures before real incidents and that new scaffolding, tools or longer runs may reveal behavior beyond the tested conditions.
What users should verify before switching
Teams deciding between GPT-6.2 Astra and Sol should test their own workflows rather than selecting from the headline benchmark alone. A useful comparison keeps the prompt, source files, tools, success criteria and review process constant.
Measure at least four things:
- whether the final work is correct and complete;
- how often a human must intervene or repair it;
- total tokens, tool calls, elapsed time and retries per successful task;
- whether the model clearly reports missing information, blocked tools and uncertainty.
For lower-cost routine work, Sol may be the more efficient starting point. Astra may justify its higher rate when difficult research, engineering or professional output benefits from the additional capability. Neither choice removes the need to verify sources, review consequential decisions and constrain tool access.
The release is therefore more than a faster-model story. It shows two trends moving together: frontier capability is becoming cheaper per task, while the evaluation and monitoring burden grows as models gain more autonomy and security-relevant skill.


