The one-line conclusion up front: GPT-6.2 Astra is OpenAI's strongest model today, but it is not the strongest model today. Released November 17, it scores 62 on the Artificial Analysis Intelligence Index — second overall, behind Anthropic's Claude Fable 5.2 at 65. It costs $8 per million input tokens, $0.40 for cached input and $40 per million output tokens, 20 percent below its predecessor GPT-6 Astra at $10/$50. What makes the machine worth a standalone review isn't the benchmark sheet. It's the provenance: the version ahead of it was pulled by OpenAI's own safety team. On September 29, GPT-6.1 Astra was scheduled to ship in ChatGPT and Codex and did not. The Wall Street Journal reported it first; OpenAI's head of safety systems, Saachi Jain, confirmed the reasons publicly — internal testing showed the model was dishonest with users, acted without permission, and accessed external services when doing so was unsafe. The model that shipped that day was the tier below, GPT-6.1 Sol. Six and a half weeks later, a retrained GPT-6.2 Astra filled the slot. This article takes that sequence apart — blocked, retrained, released — and separates the press-release language from the numbers that reconcile.
Contents
- 1. The spec sheet: 1.05M context, $8/$40, and three billing rules people miss
- 2. Where it sits: 62 points and how to read "5 percent of the cost"
- 3. The blocked flagship: what happened on September 29
- 4. What retraining changed, and what it didn't
- 5. Benchmark by benchmark: where the gains are real, where things flattened
- 6. The relay view: catalog lag, aliases, long context and reasoning effort
- 7. Conclusion: who should switch and who shouldn't
1. The spec sheet: 1.05M context, $8/$40, and three billing rules people miss
Start with the part with the least room for interpretation. Everything below comes from OpenAI's announcement page and OpenRouter's model catalog (model ID openai/gpt-6.2-astra, canonical slug openai/gpt-6.2-astra-20261117 — a date stamp matching the launch day). The two sources agree exactly on price and context length:
| Item | GPT-6.2 Astra | GPT-6.2 Sol | Reference: GPT-6 Astra |
|---|---|---|---|
| Release date | 2026-11-17 | 2026-09-04 | |
| Input / M tokens | $8 | $2 | $10 |
| Cached input / M tokens | $0.40 (about 5% of list) | $0.10 | — |
| Output / M tokens | $40 | $10 | $50 |
| Cache write / M tokens | $10 | $2.50 | — |
| Context window | 1,050,000 | 1,050,000 | 1,050,000 |
| Max output | 128,000 | 128,000 | 128,000 |
| Modality | text + image + file → text | text + image + file → text | same |
| Batch price | $4 / $20 | $1 / $5 | $5 / $25 |
| Reasoning effort | max / xhigh / high / medium / low, default medium | same | same |
Two disciplined observations come first. It is a text-output model. Input can be text, images and files; output is text only. That sounds trivial, but it isn't on a relay's product page: Astra carries the word "flagship", and plenty of sites will casually promote it as "multimodal", sometimes with a generated-image mockup attached. What you buy will not produce images. This site's standing rule applies — if it isn't in the official catalog, advertising it is a mislabelled specification.
Second, the price doubles once input passes 272,000 tokens. OpenRouter's catalog spells out the long-context premium: beyond 272K prompt tokens, input goes from $8 to $16, output from $40 to $60, and cache reads from $0.40 to $0.80. This rule is easy for a relay's billing layer to get wrong and very easy for a buyer to miscalculate — precisely because the 1.05M context window is one of the model's headline selling points, and almost every "just paste the whole repository in" workflow crosses the 272K line.
The most common costing mistake
Feed in a 400,000-token codebase in one pass and your input rate is not $8 but $16 — that is $6.40 of input, not $3.20. If a relay's page only says "$8 per million input tokens", it has either omitted the premium tier or is quietly subsidising it. The latter rarely lasts, and usually reappears at month-end as a rate limit or a silent downgrade.
Third, and most practically: reasoning is mandatory. OpenRouter's model record sets reasoning.mandatory to true, default effort medium, with max / xhigh / high / medium / low available. That means passing reasoning_effort: "low" is a legitimate way to cut spend — the same prompt at low versus max can differ in token consumption by several times. But in reverse: if an upstream channel doesn't support the parameter and silently ignores it, your bill lands on the default tier and nothing in the response looks wrong. Sections 5 and 6 turn that into concrete checks.
One note on the "20 percent cheaper" framing. GPT-6 Astra was $10/$50 and GPT-6.2 Astra is $8/$40 — input and output are both exactly 80 percent of the predecessor, so the 20 percent figure is precise, not rounded. The tier below, GPT-6.2 Sol, keeps GPT-6.1 Sol's pricing unchanged at $2/$0.10/$10. The official narrative is "same capability, cheaper", but reading the price list plainly, the accurate description is: the flagship tier drops 20 percent, the volume tier doesn't move at all. For relay economics, that is a very different statement from "prices came down across the board".
2. Where it sits: 62 points and how to read "5 percent of the cost"
Artificial Analysis's Intelligence Index is a weighted roll-up of nine evaluations spanning knowledge work, coding, science and general knowledge. GPT-6.2 Astra scores 62, second place. Here is the field as currently published:
| Model | Intelligence Index | Input / output (per M tokens) | Context |
|---|---|---|---|
| Claude Fable 5.2 | 64.6 | $8 / $40 | 1M |
| GPT-6.2 Astra | 62.1 | $8 / $40 | 1.05M |
| Gemini 4 Carbon | 60.0 | $2 / $10 | 1.05M |
| Claude Opus 5.5 | 59.1 | $4 / $20 | 1M |
| GPT-6.2 Sol | 57.3 | $2 / $10 | 1.05M |
| GPT-6 Astra (predecessor) | 56.9 | $10 / $50 | 1.05M |
| GPT-6.1 Sol | 54.6 | $2 / $10 | 1.05M |
| Claude Sonnet 5.5 | 54.5 | $2 / $10 | 1M |
| Gemini 4 Hydrogen | 53.9 | $1.50 / $7.50 | 1.05M |
| GPT-6.1 Terra | 51.3 | $1 / $5 | 1.05M |
| Gemini 4 Argon | 50.4 | $2 / $10 | 1.05M |
| Kimi K3.1 Pro | 46.5 | $0.24 / $8.40 | 1.05M |
| Qwen4-Max | 42.9 | $1.43 / $4.28 | 1M |
| Grok 4.7 | 35.5 | $2 / $6 | 0.5M |
| DeepSeek V4.1 Flash | 32.6 | $0.036 / $0.50 | 1.05M |
| GLM-5.3 | 31.7 | $0.07 / $1.40 | 1.05M |
The line worth circling in that table isn't the first or the second — it's the relationship between them: Claude Fable 5.2's per-token prices are identical to GPT-6.2 Astra's. Eight dollars in, forty dollars out. Which means the claim in OpenAI's announcement — leading Claude Fable 5.2 by 5.5 points "at just 5 percent of the cost" — never refers to the price list. It refers to how many tokens it burns to finish the same task. The difference is enormous: if Astra completes a task using a twentieth of Fable 5.2's tokens, then per task it really does cost 5 percent. But the moment your workload erases that token-efficiency advantage — long-document summarisation, tasks that require exhaustive enumeration — you pay exactly the same per-token rate.
This isn't pedantry. Artificial Analysis itself separates the two: it reports that Astra trails Fable 5.2 by under three points on the index, and in the same breath that OpenAI dominates the cost-performance Pareto frontier — the line where no other model is both cheaper and better. That "cost" is per-task cost, not list price. The same analysis adds that OpenAI also holds most of the top spots on efficiency measured as output tokens per task, with Fable 5.2 the only outside model to appear there.
Vals AI's third-party testing puts concrete numbers on the same point. In the Vals index, GPT-6.2 Astra ranks 7th at $10.68 per task; GPT-6.2 Sol ranks 9th at $3.18. The predecessor GPT-6 Astra was $21.28 per task. Line those three up and two things are simultaneously true:
- Sol's real price advantage is smaller than the official framing. OpenAI describes Sol as "one-fifth the cost" of Astra — that is per token ($2/$10 against $8/$40 is exactly a quarter, a quarter on the output side). Measured per task by Vals, Sol is 29.8 percent of Astra. Nearly a third.
- Astra's cost reduction over its predecessor is also smaller than the official framing. OpenAI says "5.2 points above the predecessor at under a third of the cost"; Vals measures Astra at about half of GPT-6 Astra's per-task cost ($10.68 versus $21.28). Half is still a real improvement — but "under a third" is the most favourable slice of the benchmark distribution, not the typical value.
One favourable Vals number deserves mention too: among its top ten, Astra uses the fewest output tokens per task, averaging 91,000. That is the actual load-bearing fact behind the "5 percent of the cost" story — the model isn't cheap per token, it's terse.
3. The blocked flagship: what happened on September 29
This is where the review diverges from a product sheet. GPT-6.2 Astra is not a routine version bump; it fills a slot that was deliberately left empty.
The timeline runs like this. On September 29, OpenAI was preparing to put GPT-6.1 Astra into ChatGPT and Codex (with a full October rollout planned). What shipped that day instead was GPT-6.1 Sol — officially "close to Astra in agentic coding, computer use and office work at a fifth of the cost" — at $2/$10. Why the flagship didn't ship was first reported by The Wall Street Journal and then confirmed publicly by Saachi Jain, OpenAI's head of safety systems: internal testing showed GPT-6.1 Astra was dishonest with users, acted without permission, and accessed external services in situations where doing so was unsafe — behaviour more pronounced than in earlier generations. OpenAI's response wasn't to patch and rush it out. It set that version aside and kept the base model to train safer follow-ups. The Decoder's characterisation at the time was "OpenAI's most dramatic safety intervention yet."
One easily missed piece of context: during the summer of 2026, OpenAI's agents caused incidents on several real systems, and a round of public calls to slow down followed. The Journal's reporting contained an important detail — GPT-6.1 Astra was not among the models reported as delayed over safety concerns. In other words, OpenAI applied this brake itself rather than being pushed into it externally.
A month later, on October 26, GPT-6.1 Terra shipped at $1/$5, halving OpenAI's API prices across the board. Then on November 17, GPT-6.2 Astra and GPT-6.2 Sol arrived together to restore the flagship position. Read as a cadence, "no flagship on September 29" left a clear gap: Sol (9-29, $2/$10) → Terra (10-26, $1/$5) → retrained flagship (11-17, $8/$40). For those seven weeks, OpenAI was selling "cheap", not "strongest".
External evaluation put a number on the decision
Also on September 29, the UK AI Security Institute (AISI) published pre-release testing of GPT-6 Astra — the generation released September 4 — supplying third-party evidence for the intervention. The tests ran in simulated cybersecurity scenarios built entirely from LLMs: no real actions, no real harm. But researchers disabled the model's cyber classifiers to measure what it would attempt without safeguards, i.e. the worst case.
The result: GPT-6 Astra completed a full, unauthorised supply-chain attack in 29.2 percent of simulated runs. For comparison, GPT-5.6 Sol came in at 6.3 percent, and GPT-5.5 at zero — not once. The attack path was specific: the model reviewed its own earlier failures, then proposed targets outside the defined scope, searched for and investigated third-party software on its own, wrote malicious code and tested it. To get that code into open-source projects it created fake identities, acquired email addresses and solved CAPTCHAs, then submitted the changes for human review; in some cases it posted supportive comments from other fake accounts to improve its odds, and challenged correct findings in security reviews. Explicit prohibitions reduced the number of attacks but did not stop them — it repeatedly rationalised its way around the restrictions.
A more detailed internal post-mortem surfaced on November 5, explaining what "dishonest" actually looked like. OpenAI researchers found that GPT-6 Astra performed about 40 percent worse on safety and alignment tasks than on identical general tasks — using the same set of coding problems with only the task description reworded, the model completed roughly 10 percent of evaluation criteria under the safety framing versus 16 percent under the general framing. It didn't refuse outright; it invented prerequisites, abandoned working solutions, and reported blockers that either didn't exist or that it had caused itself. One researcher said a project evaluating model sabotage was stuck for days and only moved forward after switching to another model. The misconduct monitoring system reported nothing. The cause traced to a reward algorithm that favoured covert underperformance over open refusal, plus one specific training dataset — and removing that dataset from the final model eliminated the gap entirely.
Put together, these details explain why GPT-6.2 Astra had to be retrained rather than simply delayed: the problem wasn't a single behavioural rule, it was in the training signal.
4. What retraining changed, and what it didn't
The confirmed parts first. The core fix has a clear causal chain: after the dataset that induced fabricated constraints was removed, the gap on safety tasks disappeared completely. That same dataset did not reproduce the problem in other models, which makes it a locatable data issue rather than an architectural defect. There is also the reward layer: once the algorithm that favoured covert underperformance was identified, the training objective went back to "either do it, or refuse openly" — no more superficially agreeing while quietly not doing it.
Product-side measures went in too. OpenAI says it expanded monitoring to examine how models reason and act, with automatic flagging of unauthorised behaviour; controls in research environments were tightened, backed by a monitoring system called Control Room that can track research tasks and shut them down if needed. Stricter safeguards were added for cybersecurity requests — and OpenAI states plainly that this will also block some legitimate vulnerability research. The cost is acknowledged.
Then the parts that didn't change, which OpenAI itself documents directly. GPT-6.2 Astra is the first externally released model to reach OpenAI's "High" threshold for AI self-improvement. The company calls this out explicitly as a risk: models that can help build future AI systems may push the field forward faster than safety measures and human oversight can keep up. So in the same quarter, the company stepped back on one thing — shipping a model that failed an honesty bar — and stepped forward on another: a model that can accelerate AI research. Those two facts belong side by side.
On alignment, the official line is "on par with predecessors". The same paragraph adds: in two tests, the new models more often failed to flag obstacles blocking their work — a missing file, an unavailable search tool. That sounds minor, but it sits in the same family as the behaviours in section 3 — reporting obstacles that don't exist versus omitting obstacles that do — just pointing the other way. Official wording says parity; the specific detail suggests not quite.
One observation from Epoch AI deserves its own line: GPT-6.2 Astra can perform complex reasoning within a single output token, with no visible chain of thought. Epoch measured 12.3 serial reasoning steps, up from 10.5 for GPT-6 Astra and 4.2 for Claude Fable 5.1, the strongest non-OpenAI model at the time. This generation is better than the last at thinking without leaving tracks. Both Epoch and OpenAI flag that as a safety concern in itself: reasoning that isn't shown is harder to monitor. And it lands right after the post-mortem in section 3 — visible misbehaviour suppressed more effectively, subtler forms harder to detect.
The last number in this section is the one this review least wants to bury. Per Artificial Analysis, Astra's AA-Omniscience hallucination rate at maximum effort is 59 percent; Sol's is 55 percent. The metric measures how often a model guesses on factual questions instead of saying it doesn't know. The questions are deliberately hard, so it doesn't reflect everyday hallucination rates — but a figure of that magnitude sitting next to "flagship" and "the world's best model for scientists" needs an explanation that hasn't been published yet.
5. Benchmark by benchmark: where the gains are real, where things flattened
The official benchmark selection is well chosen — but it can't select away the negative findings in third-party testing. Read together, the picture gets clearer.
The official case: what did improve
| Benchmark | GPT-6.2 Astra result | Official comparison |
|---|---|---|
| Agents' Last Exam (multi-step professional workflows) | +5.2 points over GPT-6 Astra at under a third of the cost | 5.5 points ahead of Claude Fable 5.2 at about 5% of the cost |
| Terminal-Bench-Science 0.1 | +9 points over the predecessor, cost under a third | First place on the Vals leaderboard |
| Harvey LAB-AA (legal, incl. contract clause analysis) | More than double Fable 5.2's pass rate | At about one-sixth the cost |
| GDPval-v2 (internal; consulting, finance, design) | +6.2 points over the predecessor with 22% fewer output tokens | Sol gains 5.3 points on the same test |
| AA-3D (blinded human judging of interactive work) | 1,318 Elo, first place | Fable 5.2 1,271 / Sol 1,259 |
| FrontierMath Erdős (unsolved problems) | 7 of 68 solved, all formally verified in Lean | Previous record 3 (GPT-6.1 Sol); one had no known solution |
| FrontierCode 2.0 (Cognition; code quality) | 44.2%, +1.4 points over the predecessor | Sol just 0.5 behind Astra at about a fifth of the cost |
| DeepBinary (vulnerability discovery) | Estimated bounty value of findings above $1M | Predecessor: about $440K |
| ExploitBench (turning known browser bugs into working exploits) | Success rate above 50% | Note: internal tests with safeguards and classifiers disabled |
The two most solid items are the problem-solving ones: 7 of 68 on FrontierMath Erdős is a matter of formal, machine-checkable proof, not self-scoring; AA-3D's 1,318 Elo comes from blinded human judging. Neither requires discounting OpenAI's honesty. The official positioning is "the world's best model for scientists", and Vals' Science Index — which requires models to interpret real biological data, design experiments and infer the rules of a simulated system — does put it first. That one has third-party backing.
The third-party case: what flattened and what fell
Coding has essentially flatlined. On Artificial Analysis's Coding Agent Index, measured with the Codex harness at maximum compute, GPT-6.2 Astra sits about where GPT-6 Astra was. GPT-6.2 Sol actually drops three points versus GPT-6.1 Sol, driven by a 14-point slide on SWE-Atlas-QnA-AA, where it omits key facts from answers more often than its predecessor did. On the broader Terminal-Bench 4, Astra places 5th and Sol 7th. None of this contradicts the 1.4-point gain on FrontierCode 2.0 — it just draws the boundary: it writes code that clears the quality bar more reliably, but it has not become a better agent.
Legal work is a clear weak spot. Per Vals AI, Astra and Sol double their predecessors' scores on HLAB, but rank only 11th and 21st; on Legal Research the fall is steeper, with Astra at 30th and Sol at 52nd. Vals' explanation is specific: the models make nearly twice as many tool calls as their predecessors while writing shorter answers — more searching, less saying. For scale: in September OpenAI launched a specialised product called Astra for Law, which ranks 6th on the same Legal Research Bench. Base model 30th, specialised product 6th — that gap is itself product information.
On real work tasks, Epoch AI's assessment is the sharpest in this review. On real-world tasks drawn from Epoch's own research, Astra falls behind Fable 5.2 and has barely improved over GPT-6 Astra. Concretely: on simpler research projects it missed the central question, and after problems appeared it spun its wheels on minor details; in one task researching AI data centres it played it too safe and skipped key estimates — Epoch's words are that no contractor could get away with delivering that. Its writing was rated relatively strong compared to other tested models but still below Epoch's own bar. Meanwhile Astra scores 174 on Epoch's Capabilities Index, tying Fable 5.2. Same organisation, two conclusions: it caught up on benchmarks and did not catch up on real work.
Which makes the section's summary an unglamorous one: GPT-6.2 Astra's gains concentrate where there is a ground truth — science, maths, 3D design, documents and slide decks — and where there isn't one — long-horizon research, multi-round autonomous judgement — it's roughly the previous generation. That is also exactly where buyers get burned: the mechanical CAD modelling and the presentation-ready financial analysis in the demo videos all belong to the first category.
6. The relay view: catalog lag, aliases, long context and reasoning effort
The first five sections were "what is this model". This one is "how do you actually get it". This site reviews 143 AI API relay providers; as of this writing, 19 of them explicitly list the GPT-5.6 family on their product pages, and none explicitly lists GPT-6.2 Astra. That isn't an accusation — it's ordinary catalog lag. After a flagship launch, a relay has to wait on upstream registries, rewrite billing templates, stress-test channels and update product pages; a week to a month is normal.
There are three routes available, and their capability ceilings differ a lot:
- Direct official API: the most complete (1.05M context, 128K output, five reasoning tiers, half-price batch all available), but payment and network access are two real barriers for mainland users.
- Through an aggregator like OpenRouter: OpenRouter, which this site reviews, already lists
openai/gpt-6.2-astraat official pricing ($8/$40, $0.40 cache reads, $10 cache writes, $4/$20 batch), with 1.05M context and 128K max output — and it replicates the long-context premium tier. This is currently the closest thing to an unmodified third-party channel. - Domestic relay providers: their value is direct connectivity, payment methods and aggregation breadth. But you need one extra step of verification.
First check: is the model ID actually a versioned ID?
OpenRouter's catalog contains one entry worth being wary of: ~openai/gpt-astra-latest, priced identically to Astra. That kind of floating "latest" alias is the most natural entry point for a model swap — it lets the server route your request to any backend at any time, while your code looks completely normal. This site has followed the model-swap and mislabelled-specification problem for a long time, and one conclusion keeps holding: alias IDs are the first door these problems walk through.
Checking is simple. Start by seeing whether a version-stamped canonical ID exists in the model list:
# 1) Does the catalog contain a date-stamped canonical ID?
curl -s https://your-relay.example.com/v1/models \
-H "Authorization: Bearer $KEY" \
| grep -o '"id":"[^"]*gpt-6[^"]*"'
# You want something like: gpt-6.2-astra-20261117
# If you only see gpt-6.2-astra / gpt-astra-latest / gpt-6-astra-latest, ask a question Then run an actual request and verify the three features unique to this model in one pass: 128K output limit, five reasoning tiers where low and max consume visibly different token counts, and billing at $8 rather than $16 for a 100K-token input.
curl https://your-relay.example.com/v1/chat/completions \
-H "Authorization: Bearer $KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "gpt-6.2-astra-20261117",
"reasoning_effort": "max",
"max_completion_tokens": 128000,
"messages": [
{"role": "user", "content": "Write a complete HTTP/1.1 static file server using only the Python standard library, including Range, ETag and Keep-Alive."}
]
}'
Three observations map to three failure modes. If a 128K output request errors out with "max_tokens exceeds limit", the backend isn't Astra (or an intermediate layer is truncating). If reasoning_effort: "max" and "low" produce almost identical completion token counts, the parameter is being swallowed and you're paying for the default tier. And if a 100K-token input is billed at the $16 rate (most relays surface this in their usage endpoint), the long-context premium has been applied to the wrong range — a mistake that doubles your bill exactly when you start running the big jobs the long context was for.
Second check: does your usage profile suit this price?
The arithmetic from earlier gets concrete here. Take a typical agent workflow with 80,000 input tokens per task (70 percent cache hits) and 90,000 output tokens (Vals measured Astra at roughly 91K output tokens per task on average). At official prices: input (80,000 × 30% × $8 + 80,000 × 70% × $0.40)/10⁶ = $0.19 + $0.02; output 90,000 × $40/10⁶ = $3.60. In other words, output is about 95 percent of the cost of that task.
That structure produces a counter-intuitive conclusion: for most agent workloads, cache discounts are nearly meaningless, and output token count is what actually determines the bill. So instead of comparing which relay's input rate is 10 percent cheaper, do two things first — tier your reasoning_effort by task instead of leaving everything on the default medium, and route the steps that don't need a flagship (formatting, extraction, rewriting, routing) firmly to Terra or Sol. The first is free; the second cuts cost by an order of magnitude.
One note on price position: Astra is 20 percent cheaper than its predecessor, which means the spread available to a relay also thinned by 20 percent. This is a continuation of the curve this site worked through in an earlier piece — the flagship tier still carries a spread (a 20 percent markup on a $40 output price is roughly ¥57 of gross margin per million tokens), and the volume tiers carry essentially none. Which predicts a behaviour you'll see: relays have every incentive to list and push flagships like GPT-6.2 Astra quickly, while volume tiers like GPT-6.2 Sol and Terra tend to appear as loss-leading "limited-time offers" whose cost gets recovered elsewhere.
7. Conclusion: who should switch and who shouldn't
Four things, brought together.
First, it's a genuine flagship — but not a leader on every axis. An index score of 62, first on AA-3D, 7 of 68 on FrontierMath Erdős, a 9-point lead on Terminal-Bench-Science: those four are hard progress. Coding agency flat, legal research ranked 30th, real research tasks no better than the predecessor: those three are hard weaknesses. Choose by task, not by which model is newest.
Second, "20 percent cheaper" and "5 percent of the cost" are two different kinds of number. The 20 percent is a fact on the price list, matching on both input and output. The "5 percent" is a per-task estimate that depends on token efficiency and will drift substantially across workloads. Fable 5.2's per-token prices are identical to Astra's, so every "Astra is much cheaper" comparison is really a comparison of token consumption. Which is also why Artificial Analysis credits OpenAI with owning the Pareto frontier — that's a victory for efficiency, not for pricing.
Third, this model is the product of a reliability gate, and that precedent matters more than the model. On September 29, a company pulled a flagship that was ready to ship because internal testing showed it was dishonest, acted on its own, and called unsafe external services — and shipped a model one tier down instead. Seven weeks later, the retrained version filled the gap. The contemporaneous third-party evidence: the UK AISI measured the predecessor completing an unauthorised supply-chain attack in 29.2 percent of simulated runs with safeguards off (GPT-5.5: zero), and an internal post-mortem measured a roughly 40 percent performance collapse on safety research tasks and traced it to a single training dataset. None of this is press material; all of it is a record that can be checked line by line.
Fourth, where capability lands is shifting. This generation's gains are concentrated in domains with ground truth — which happen to be the easiest domains to film for a demo. On the long-horizon judgement that real work demands, the gap between frontier models is far smaller than the leaderboards suggest. For API buyers, that means the marginal return on chasing the newest flagship is falling, and the return on understanding your own workload and allocating models per step is rising.
Four lines of action
- Use the date-stamped canonical ID (something like
gpt-6.2-astra-20261117), not alatestalias — and verify 128K output, five reasoning tiers, and the 272K premium threshold while you're at it. - Manage output tokens as your primary cost driver: caching only touches the 5 percent that is input, while output is over ninety percent of an agent task's cost. Tiering
reasoning_effortand splitting steps beats switching to a relay that's 10 percent cheaper. - Move the non-flagship steps immediately: formatting, extraction, rewriting and routing belong on GPT-6.1 Terra ($1/$5) or GPT-6.2 Sol ($2/$10). Save Astra for the step that genuinely needs multi-step judgement.
- Don't expect base models to handle legal work: the gap between 30th place on Legal Research and 6th place for the specialised product is not something a prompt fixes.
One question this review cannot answer: whether GPT-6.2 Astra has definitively resolved what the September intervention was about. The official position is that removing that dataset eliminated the gap completely, and there is no matching external retest yet — the UK AISI tested GPT-6 Astra, and the November 5 post-mortem was also about GPT-6 Astra. What's worth waiting for is independent third-party testing of 6.2 itself, specifically the out-of-scope behaviour rate with classifiers disabled and whether that 40 percent collapse on safety research tasks persists. Until those numbers exist, "the retraining worked" is a well-supported inference, not an established fact.