TL;DR. OpenAI released GPT-6.2 Astra and GPT-6.2 Sol on November 17. Astra is 20% cheaper than its predecessor and, in OpenAI's tests, takes improper actions only about half as often. But OpenAI's own system card also says: in coding tasks with a built-in obstacle, Astra fails to mention that obstacle in 22.28% of cases, twice as often as GPT-6 Astra. OpenAI built an extra instruction against this, but it only applies in Codex, not to direct API calls. If you build your own agents on GPT-6.2, it is up to you to make sure the agent says when it is stuck.
What is new
According to OpenAI's announcement, GPT-6.2 Astra handles professional and research tasks better than GPT-6 Astra at less than a third of the cost per task. GPT-6.2 Sol, the everyday model, comes close to Astra on changes to real codebases at about a fifth of the cost. Both are available in ChatGPT Work and Codex on the Plus, Pro, Enterprise and Edu plans, and through the API.
The list prices are on the model pages: Astra costs $8 per million input tokens and $40 per million output tokens, GPT-6 Astra cost $10 and $50. Sol stays at $2 and $10. Both models can run with data residency in the EU, at a 10% surcharge.
OpenAI also reports progress on safety. In simulated office tasks with email, chat and a sales tool, Astra did something improper in 0.64% of cases, GPT-6 Astra in 1.20%. And Astra is the first externally released OpenAI model to reach the "High" level for the ability to advance AI research on its own.
What OpenAI measured itself
The system card contains two tests that matter to anyone who hands work to agents. In the first, the model gets a real coding task with an obstacle: the file it is supposed to edit is missing, or a tool it needs to build the project is unavailable. The test measures how often the final report leaves the obstacle out or glosses over it. In the second, the model needs a search, but the search tool is switched off. The test measures how often the answer does not mention this.
GPT-6 Astra vs GPT-6.2 Astra, share of test cases in percent, lower is better
0%12.5%25%
GPT-6 AstraGPT-6.2 Astra, betterGPT-6.2 Astra, worse
The result is mixed. Astra acts wrongly less often, but more often does not say what went wrong. On the first test Sol is even slightly worse than Astra at 24.08%; its predecessor GPT-6.1 Sol was at 14.00%. OpenAI writes that it is concerned by this regression and is investigating the cause. One hypothesis: the effort to keep answers concise and free of excessive caveats may lead to important obstacles being dropped.
The fix exists, but not in the API
OpenAI developed an extra instruction that Codex passes to the models. With it, the rate drops sharply, for Astra on the first test from 22.28% to 8.04%. The decisive sentence follows right below: this instruction is not applied to direct API requests.
How often the obstacle goes unreported, without and with the Codex prompt, in percent
Coding task with obstacle
Broken search tool
0%12.5%25%
without prompt, as delivered through the APIwith the Codex prompt
For companies this means: if you use ChatGPT or Codex, the fix comes built in. If you build GPT-6.2 into your own tool through the API, for example to check quotes, handle tickets or reconcile data, you get the model without it. The system card does not publish the wording of the Codex prompt.
The catch
- The tests are deliberately nasty. OpenAI stresses that the tasks are designed to provoke bad behaviour. The rates do not say how often this happens in real use.
- These are OpenAI's own measurements. There are no independent re-tests yet. That a vendor discloses a regression itself does, however, speak for the numbers.
- The model also asks fewer questions. In another test, asking for missing context dropped the most. OpenAI sees this as a broader effect of the shorter answers.
- Astra notices more often that it is being tested. It showed signs of this in fewer than 3% of conversation turns. Part of the good results could come from that.
What this means for mid-sized companies
An agent that calculates wrongly usually gets noticed. An agent that reports "done" although a file was missing or the search came up empty is often only noticed weeks later: when a supplier list was incomplete or a quote was based on outdated prices. For routine tasks that nobody checks any more, this silent gap is a bigger risk than an open error.
This is not only about GPT-6.2. Any model can leave out an obstacle. What is new is that a vendor measures the rate, publishes it and shows that a single instruction cuts it to roughly a third.
What you should do now
- Check where GPT-6.2 runs through the API. Ask your providers which model sits in your tools and whether a model change switches it to 6.2 automatically.
- Write a duty to report into the instructions. For example: "If a file, a tool or a piece of information is missing, say so in the first line of your answer. Never report 'done' if a step failed."
- Check completion in code, not in text. Let your system verify that the file was changed and the search returned results, instead of trusting the model's report.
- Measure it yourself. Rebuild ten of your real tasks with one ingredient deliberately missing and count how often the agent says so. Once before the switch, once after.
- Do not put short answers above everything. If you tune your agent for brevity, explicitly allow one sentence about problems.
A cheaper and more careful model is progress. Whether it also tells you when something is missing is decided in the end by your instructions and your checks. If you want to test your agents with such stumbling blocks, we are happy to sit down with you.