GPT-6.2 Astra charges exactly what Anthropic's flagship charges per token, yet finishes a benchmark task for about a sixth of the money, and its sibling Sol for about a twenty-sixth. Critics call Astra unusable. Both are true, and the gap between them is where your real cost per task is decided.
On November 17, 2026, OpenAI released GPT-6.2 Astra and GPT-6.2 Sol in ChatGPT Work, Codex and the API - OpenAI Developer Community. Astra lists at $8 per million input tokens and $40 per million output tokens, exactly what Anthropic charges for Claude Fable 5.2 ($8 and $40). Sol stays at $2 and $10.
Identical rate cards, then. Yet when Artificial Analysis ran both flagships through its Intelligence Index at maximum effort, GPT-6.2 Astra scored 62 for $4.00 per task while Claude Fable 5.2 scored 65 for $26.54 per task - Artificial Analysis. Same price per token, a 6.6x difference in price per task. GPT-6.2 Sol, at a quarter of Astra's token price, scored 57 for $1.01.
That number is the reason this release matters more than its benchmark gains, which are real but modest. It is also not the whole story. Within hours of launch, investor Matt Shumer called the new models "essentially unusable," developer Theo Browne called Astra "the worst model OpenAI has ever released," and Wharton professor Ethan Mollick found it "very uneven & weird" - VentureBeat. A model that is cheap per attempt but has to be babysat, redone, or overruled by a second model is not cheap per finished job.
This guide works through both sides with the numbers. It sets out what OpenAI actually shipped and what it costs in every channel, separates the GPT-6.2 Astra benchmarks OpenAI published from what Artificial Analysis, Vals AI, Epoch AI and ARC Prize measured independently, explains from first principles why two models with the same price can differ six-fold per task, and builds a cost-per-task model you can adapt to your own agents. It ends with a decision guide: when Astra earns its 4x premium over Sol, when Sol or a rival is the better buy, and when neither is.
This guide reflects prices, benchmarks and availability as of November 18, 2026, the day after launch. Leaderboards will move as more runs complete, and several prices on this page have scheduled changes, so check the linked sources before you commit budget.
Contents
- What OpenAI shipped on November 17, 2026
- GPT-6.2 Astra benchmarks: OpenAI's own claims, and how to read them
- What independent evaluators measured
- Why the same token price produces a six-fold difference per task
- Real cost per task on independent harnesses
- Astra vs Sol: when the 4x premium buys anything
- A cost-per-task model you can reuse
- The backlash: "essentially unusable" and what it costs you
- Where you can buy GPT-6.2, and what each channel charges
- The competition: Fable 5.2, Gemini 4 Carbon, MAI Code 2 and the open-weight tier
- Safety gating and the cyber tax
- Which model to run: a decision guide
- Outlook: where prices and capability go from here
1. What OpenAI shipped on November 17, 2026
The release is a pair, and the pairing is the point. OpenAI now sells two current-generation reasoning models with distinct jobs: Astra, which it describes as its frontier model for the hardest projects, and Sol, an efficient model for everyday work and multistep agentic workflows - OpenAI Developer Community. Below them sit the older GPT-6.1 Terra and GPT-6 Luna as the budget tiers, so a developer choosing an OpenAI model in late 2026 is really choosing a position on a four-step price ladder.
Both new models arrived in ChatGPT Work and Codex for Plus, Pro, Enterprise and Edu users, and in the API as gpt-6.2-astra and gpt-6.2-sol. A staff note under the announcement clarifies that the rollout does not add either model to regular Chat, and that availability depends on plan, workspace permissions and rollout progress. Enterprise and Edu administrators have to enable the models before their users see them - TestingCatalog.
OpenAI also widened Ultrafast, its premium low-latency mode. Pro 500 subscribers get it with both models, and for the first time Pro 200 subscribers get it, starting with Sol - The Decoder.
OpenAI's two-minute launch video is the clearest look at what the company wants these models to be known for: professional documents that follow a template, frontends and 3D scenes, and agentic work across real tools.
The emphasis on template-faithful slides, spreadsheets and documents is deliberate. OpenAI positions Astra for law, finance and accounting conventions and for slides that match supplied layouts, fonts and colors, and it calls Astra "the world's best model for scientists" - The Decoder. That framing matters for cost, because the workloads OpenAI is pointing at (long documents, long research runs, long agent sessions) are exactly the ones where token volume, not token price, decides the bill.
The specifications
Both models share the same envelope. The API model pages list a 1,050,000-token context window, a maximum input of 922,000 tokens, and up to 128,000 output tokens, with text and image input and text output - OpenAI API docs. Astra's knowledge cutoff is May 18, 2026, while Sol's is June 1, 2026 - OpenAI API docs. Both are reasoning models that reject a reasoning effort of none, so there is no way to run either one as a cheap non-thinking model; the floor is low.
Both support the Responses API's full tool set: web search, file search, image generation, code interpreter, hosted shell, apply_patch, skills, computer use, MCP and tool search. Neither supports Realtime, fine-tuning or the Assistants API - OpenAI API docs.
The complete rate card
The headline numbers are simple, but the details that decide an agent's bill sit below the headline. Here is everything OpenAI charges for the two models, taken from its pricing page.
| Rate (per 1M tokens) | GPT-6.2 Astra | GPT-6.2 Sol | GPT-6 Astra (previous) |
|---|---|---|---|
| Input (up to 272K) | $8 | $2 | $10.00 |
| Cached input | $0.40 | $0.10 | $1.00 |
| Cache write, 30-minute / 12-hour | $10 / $20 | $2.50 / $5 | $12.50 / $25 |
| Output (up to 272K) | $40 | $10 | $50.00 |
| Long context (over 272K input): input / output / cached | $16 / $60 / $0.80 | $4 / $15 / $0.20 | $20 / $75 / $2.00 |
| Batch (input / output) | $4 / $20 | $1 / $5 | $5 / $25 |
| Fast (input / output) | $16 / $80 | $4 / $20 | $20 / $100 |
| Ultrafast, promotional to Feb 28, 2027 (input / output) | $24 / $120 | $6 / $30 | $60 / $300 |
| Ultrafast, list from Mar 1, 2027 (input / output) | $48 / $240 | $12 / $60 | $60 / $300 |
Source: OpenAI API pricing, retrieved November 18, 2026.
Three things in that table matter more than the headline 20% cut that most coverage repeated.
The first is the cached-input price. Astra's cached input fell from $1.00 to $0.40 per million tokens, a 60% cut, three times larger than the cut to fresh input. For a chatbot that barely matters. For an agent it is the biggest line on the bill, because an agent re-reads its whole accumulated context on every step and most of that context is a cache hit. Section 7 shows that on a typical coding-agent trajectory, this one change makes GPT-6.2 Astra about 36% cheaper than GPT-6 Astra, not 20%.
The second is the 272K-token cliff. When a single request carries more than 272,000 input tokens, input and cache rates double and output rises to 1.5x for the whole request - OpenAI API docs. A model sold on a million-token window therefore charges a premium for actually using it. Anthropic does not: Claude Fable 5.2 and Opus 5.5 bill a 900K-token request at the same per-token rate as a 9K one - Claude pricing docs. For long-context agents this structural difference can outweigh every benchmark point in this article.
The third is that OpenAI now charges for cache writes explicitly ($10 per million for Astra's 30-minute retention), much as Anthropic does. A loop that writes each new turn into the cache pays a 25% premium on its fresh tokens in exchange for the cheap reads that follow. That trade is almost always worth making in an agent, but it has to be in the cost model.
Two smaller details round out the API picture. Eligible background requests get 30% off Standard on a 2-hour window and 40% off on an 8-hour window, and regional data-residency endpoints carry a 10% uplift - OpenAI API pricing. Neither 6.2 model is offered on the cheaper Flex tier.
2. GPT-6.2 Astra benchmarks: OpenAI's own claims, and how to read them
Every lab now launches with charts that plot score against cost per task rather than score alone, which is progress: the cost axis is what a buyer actually needs. But each lab also picks which benchmarks, which effort levels and which rivals go on its charts. Reading a launch chart well means asking three questions of every claim. Which effort setting produced the score? Whose harness ran the competitor? And is the cost axis list price on that lab's own tokens, or something else?
The headline numbers
OpenAI's launch charts compare the new models against their predecessors and against Anthropic and Google. The table below collects the figures that were reported with numbers attached.
| Benchmark (what it tests) | GPT-6.2 Astra | GPT-6 Astra | GPT-6.2 Sol | GPT-6.1 Sol |
|---|---|---|---|---|
| Agents' Last Exam v1.1 (long professional workflows) | 78.3% | 73.1% | 73.0% | 72.5% |
| Terminal-Bench-Science 0.1 (scientific work in a terminal) | 77.1% | 68.1% | 68.0% | 57.0% |
| FrontierCode 2.0 (mergeable changes to real repos) | 44.2% | 42.8% | 43.8% | 39.0% |
| LifeVal | 86.1% | 79.8% | 83.8% | 79.5% |
| Harvey LAB-AA (legal work) | 15.0% | 8.6% | not reported | not reported |
| BenchCAD 2.1 Core | 82.5% | 62.6% | not reported | not reported |
Sources: VentureBeat and iClarified, reading OpenAI's launch charts. One report lists Astra's Agents' Last Exam result at 77.6%, likely its max-effort point; 78.3% is the xhigh peak implied by OpenAI's "5.2 points" claim.
On its own internal GDPval v2 test of extended professional tasks, Astra gained 6.2 percentage points over its predecessor while using 22% fewer output tokens, and Sol gained 5.3 points over GPT-6.1 Sol - iClarified. Across all nine head-to-head benchmarks OpenAI charted, Astra beat GPT-6 Astra every time, and Sol beat GPT-6.1 Sol on eight of nine, losing only on the Vals Science Index (58.5% against 59.6%) - VentureBeat.
The cost claims, and the one that matters most
The more aggressive claims are about cost per task. On Agents' Last Exam, OpenAI says Astra at xhigh effort scores 5.2 points above GPT-6 Astra at max effort for less than half the cost per task - OpenAI Developer Community. Against Anthropic, it claims Astra leads Claude Fable 5.2 by 5.5 points at about 5% of the cost, with Gemini 4 Carbon the only other model that keeps up - The Decoder.
OpenAI's own chart makes the shape of that claim visible. Astra's line climbs steeply at the far left of the cost axis; Fable 5.2 sits alone at the far right.
The chart shows Fable 5.2 at roughly $60 per task and Astra's best point at roughly $3. That ratio is consistent with independent data: on the Agents' Last Exam leaderboard, Fable 5.2 running in Claude Code at max effort used 28.2 million output tokens and 227 hours of runtime across the public task set, against 5.1 million output tokens and 80 hours for GPT-6 Astra in Codex - Snorkel AI. The benchmark is co-led by UC Berkeley's RDI and grades 122 public tasks across 55 sub-industries with hidden references and deterministic graders rather than an AI judge, which makes it harder to game than most.
Two caveats keep the claim honest. First, the 78.3% is the benchmark's score (average graded outcome with partial credit), not its pass rate (tasks fully completed). On pass rate, Fable 5.2 leads the public leaderboard at 46.9% and Gemini 4 Carbon has the highest score of any listed model at 77.4%. Second, GPT-6.2 Astra was not yet on the independent leaderboard the day after launch, so the 78.3% is OpenAI's own run.
The claim that matters most for most buyers, though, is about Sol. On Cognition's FrontierCode 2.0, which grades whether an agent's change is actually mergeable rather than whether it passes tests, OpenAI says Sol nearly matches Astra on merge-ready changes at about one-fifth of the cost - OpenAI Developer Community.
Read the chart from right to left and the story is less flattering to Astra than OpenAI's prose. Claude Fable 5.2 has the highest peak score on this benchmark, 49.1% at xhigh effort according to Anthropic - Anthropic. Astra's best is 44.2%, only 0.4 points above Sol at a fraction of the price. In other words, on the benchmark closest to real software engineering, OpenAI's own chart says the expensive model buys almost nothing over the cheap one, and that neither reaches Anthropic's ceiling.
Why launch charts systematically flatter
Launch charts are not dishonest, but they are selected. Each lab chooses benchmarks where its model's curve looks best and runs rivals at settings that may not be their best. Anthropic's own Fable 5.2 page, for example, reports Fable beating GPT-6 Astra on FrontierCode 2.0, FrontierSWE v2, OSWorld 2.1 and Humanity's Last Exam, while Gemini 4 Carbon beats Fable on AutomationBench - Anthropic. Neither lab's chart is wrong. Both are answers to a question the lab chose. That is why the next section matters more.
3. What independent evaluators measured
Four independent groups had results for the new models within a day, using their own harnesses, their own task sets and the public API at list price. Where they agree, you can treat the result as solid. Where they disagree, the disagreement usually tells you something about the kind of work each benchmark measures.
Artificial Analysis: second overall, first on value
The Artificial Analysis Intelligence Index v5.0.1 averages nine evaluations in four equally weighted groups: knowledge work (AA-Briefcase, AutomationBench-AA, GDP.pdf), coding (FrontierCode-AA 2.0, Terminal-Bench 4.0), science (Terminal-Bench-Science, CritPt v2) and general reasoning (AA-Omniscience, HLE-Diamond) - Artificial Analysis. Its cost per task combines provider-reported token counts with live measurements of each model's typical cache-hit rate, which makes it one of the few public numbers that approximates what an API customer actually pays.
On that index, GPT-6.2 Astra scores 62 at both max and xhigh effort, second only to Claude Fable 5.2's 65. It passes Gemini 4 Carbon (60) and Claude Opus 5.5 (59), and sits five points above GPT-6 Astra. Sol scores 57, two points up on its predecessor, which puts it at GPT-6 Astra's level for about 15% of the cost per task - The Decoder.
| # | Model (effort) | AA Intelligence Index | Cost per index task | Time per task |
|---|---|---|---|---|
| 1 | Claude Fable 5.2 (max) | 65 | $26.54 | 41.1 min |
| 2 | GPT-6.2 Astra (max) | 62 | $4.00 | 11.5 min |
| 3 | Gemini 4 Carbon (high) | 60 | $5.48 | 34.2 min |
| 4 | Claude Opus 5.5 (max) | 59 | $10.04 | 24.5 min |
| 5 | GPT-6.2 Sol (max) | 57 | $1.01 | 7.9 min |
| 6 | Claude Sonnet 5.5 (max) | 55 | $10.02 | 32.3 min |
| 7 | Gemini 4 Hydrogen (xhigh) | 54 | $3.16 | 14.9 min |
| 8 | GPT-6.1 Terra (max) | 51 | $0.96 | 14.3 min |
| 9 | Gemini 4 Argon (high) | 50 | $4.97 | 29.2 min |
| 10 | Kimi K3.1 Pro | 46 | $3.68 | 38.4 min |
Source: Artificial Analysis leaderboard, retrieved November 18, 2026. Muse Wonder Full, which scores 50 but has no public API, is left out of the ranking.
The leaderboard is easier to read as a plot of score against cost, which Artificial Analysis publishes. OpenAI's models now trace most of the efficient frontier, the dotted line along which no other model is both smarter and cheaper.
In the lower panel, GPT-6.2 Astra at xhigh reaches the same 62 as Astra at max at a visibly lower cost, and Claude Fable 5.2 at xhigh also reaches 62, but at several times Astra's price per task. Only Anthropic and Meta models join OpenAI's on the cost-performance frontier - The Decoder.
Artificial Analysis also flagged two weaknesses that OpenAI's charts did not show. On its Coding Agent Index, Astra is flat against GPT-6 Astra and Sol is down 3 points from GPT-6.1 Sol, driven by a 14-point fall on SWE-Atlas-QnA-AA, where Sol more often left out key facts about the codebases it was asked about. And on AA-Omniscience at max effort, the hallucination rate is 59% for Astra and 55% for Sol, on a test that deliberately asks unusually hard questions - The Decoder. Where the models led was science: Astra tops Terminal-Bench-Science and AA-3D, scores 79 on AA-Robotics, and places second on CritPt, AA-Omniscience and HLE-Diamond.
Vals AI: seventh and ninth, and the cheapest model in the top ten
Vals AI weights its index by each sector's share of US GDP: finance (weight 8.0), coding (5.6), legal (1.2) and tax (0.5), each built from agentic benchmarks such as Finance Agent, spreadsheet modeling, Terminal-Bench 4.0, Vibe Code Bench, legal research and tax questions answered with cited authority - Vals AI. It is the most "office work" flavored of the independent indexes, and it is less kind to OpenAI's pair.
| # | Model | Vals Index | Cost per test | Duration per test |
|---|---|---|---|---|
| 1 | Claude Fable 5.2 | 71.31% | $17.94 | 43m 42s |
| 2 | Claude Sonnet 5.5 | 70.85% | $16.18 | 1h 26m |
| 3 | Gemini 4 Carbon | 70.45% | $10.51 | 47m 45s |
| 4 | Claude Opus 5.5 | 70.14% | $24.77 | 1h 25m |
| 5 | Gemini 4 Argon | 69.39% | $13.37 | 44m 58s |
| 6 | Gemini 4 Hydrogen | 68.49% | $9.84 | 32m 05s |
| 7 | GPT-6.2 Astra | 67.66% | $10.68 | 52m 16s |
| 8 | Wonder Full | 66.79% | $6.81 | 59m 19s |
| 9 | GPT-6.2 Sol | 66.06% | $3.18 | 41m 47s |
| 10 | GPT-6 Astra | 65.02% | $21.28 | 33m 39s |
Source: Vals AI, index as of November 16 to 17, 2026.
Sol is the cheapest model in the Vals top ten by a wide margin, and Astra costs about half what GPT-6 Astra did per test while scoring higher. Vals also notes that Astra averages about 91,000 output tokens per task, the fewest in its top ten - The Decoder. But on the Vals Index as a whole, six models from Anthropic and Google score higher than either OpenAI model. The GDP-weighted index rewards finance and legal competence, and that is where GPT-6.2 is weakest: Astra ranks 22nd of 44 on Vals' finance index and 22nd of 42 on its legal index, and 30th of 98 on Legal Research Bench - Vals AI.
The same model page shows where Astra leads outright: first of 27 on the Vals Science Index (68.44%), first of 47 on Terminal-Bench-Science (71.43%), first of 10 on Vibe Code Bench 1-100 (55.16%, building whole apps from a spec), second on MysteryMechanism and third on BioMysteryBench. That profile, strong in science and greenfield building, middling in regulated office work, recurs throughout the independent data.
Epoch AI: a statistical tie at the top
Epoch AI combines dozens of benchmarks into a single Epoch Capabilities Index with uncertainty bands. Its data file lists GPT-6.2 Astra at 174.17 (credible interval 170.29 to 178.58) and Claude Fable 5.2 at 173.5 (170.09 to 177.36), with Gemini 4 Carbon at 169.78, GPT-6 Astra at 169.2 and Claude Opus 5.5 at 168.7 - Epoch AI. The intervals overlap almost completely: on Epoch's aggregate, the two flagships are tied.
Epoch's narrative findings were more critical than its number. On its real-world research tasks, Astra fell behind Fable 5.2 and barely improved on GPT-6 Astra, missing the central question on simpler projects and skipping key estimates on an AI data-center task. On the other hand, Astra solved 7 of 68 FrontierMath Erdős problems with Lean-verified proofs, against a previous record of 3, including one previously unknown solution - The Decoder.
ARC Prize: near the ceiling, except where it is not
On the ARC Prize leaderboard, GPT-6.2 Astra scores 98.5% on ARC-AGI-1 and 95.8% on ARC-AGI-2, the latter slightly ahead of Gemini 4 Carbon (94.2%) and Claude Fable 5.2 (93.8%) - ARC Prize. On the much harder interactive ARC-AGI-3 at its standard setting, however, Astra reaches 70.3% against 81.2% for Fable 5.2, while Sol reaches 54.9%. The listed run costs ($24.2K for Astra, $21.9K for Fable, $5.5K for Sol) are close enough that the gap is a capability gap, not a budget gap.
What the independent data agrees on
Put the four together and a consistent picture emerges. GPT-6.2 Astra is a genuine frontier model, statistically tied with Fable 5.2 on Epoch's aggregate and three points behind on Artificial Analysis. It leads on science and greenfield building, trails on long-horizon office work, legal and finance, and is flat on agentic coding. GPT-6.2 Sol is not a frontier model on its own, but it reaches the level of last quarter's flagship at a fraction of the price. And on every independent harness that reports cost, OpenAI's pair is far cheaper per task than any Anthropic model at comparable scores. The rest of this guide is about why that last point holds, and when it stops holding.
4. Why the same token price produces a six-fold difference per task
The most useful fact in this release is that GPT-6.2 Astra and Claude Fable 5.2 have identical list prices for input and output, yet differ by 6.6x per index task. That gap cannot come from price. It has to come from the other two terms in the only equation that governs AI cost:
Cost per finished task = price per token x tokens per attempt x attempts per success.
Price per token is what a vendor publishes. Tokens per attempt is behavior: how much context the model chooses to read, how many tool calls it makes, how long it thinks before answering, how many times it re-reads a file it has already seen. Attempts per success is reliability: how often the run has to be repeated or rescued. A model that is cheaper per token can lose on either of the other two terms, and a model that is identical per token can win on both.
Measured token volume
Artificial Analysis publishes how many tokens each model consumed to run its entire index. The comparison between the two flagships is stark.
| Model (max effort) | Input tokens to run the index | Output tokens to run the index | Time per task |
|---|---|---|---|
| GPT-6.2 Astra | 2.16 billion | 65.8 million | 11.5 min |
| GPT-6.2 Sol | 2.22 billion | 60.9 million | 7.9 min |
| Claude Fable 5.2 | 28.3 billion | 275 million | 41.1 min |
Sources: Artificial Analysis, GPT-6.2 Astra, Artificial Analysis, GPT-6.2 Sol, Artificial Analysis, Claude Fable 5.2.
To finish the same set of tasks, Fable 5.2 at max effort read 13.1 times as many input tokens and wrote 4.2 times as many output tokens as Astra, and took 3.6 times as long per task.
Why would one model read thirteen times more context to do the same work? Agents accumulate context. Every tool call, every file read and every intermediate result is appended to the conversation, and the whole conversation is sent back to the model on the next step. A model that takes more steps, reads more files per step, or keeps working longer before declaring a task done pays for its entire history again on every step. Input volume grows roughly with the square of the number of steps, which is why a model with a more exploratory style can consume an order of magnitude more input for the same result.
This is a style difference, not a defect. Anthropic's flagship explores more, checks more and keeps going longer, which is part of why it tops the Vals Index and ARC-AGI-3 and why it leads the Agents' Last Exam pass rate. OpenAI tuned the GPT-6.2 pair in the opposite direction: OpenAI says the models produce "better results on demanding tasks with fewer output tokens" so that users can do more within the same limits - TestingCatalog. The 22% output-token reduction on GDPval v2 is the same choice measured from OpenAI's side.
The trade-off this creates
Token frugality is both the source of Astra's cost advantage and the most plausible source of the complaints in Section 8. A model trained to stop sooner and say less will, on some tasks, stop too soon and say too little. Dan Shipper's observation that Astra "often stopped early" on end-to-end builds, and that its push for brevity "sometimes made writing hard to follow," is the qualitative face of the quantitative table above - VentureBeat. So is the system-card finding, discussed in Section 11, that the new models more often failed to report blockers such as a missing file.
The first-principles conclusion is that you cannot compare these models on price per token at all. The only valid comparison is price per finished task on your own workload, because the term that differs most between them (tokens per attempt) depends on the task. On short, well-specified tasks, Astra's frugality is pure savings. On long, ambiguous tasks where thoroughness is what gets the job done, part of the saving comes back as failures and rework.
A hidden multiplier: tokenizers
One more term hides inside "tokens per attempt." Anthropic notes that Claude 4.7 and later models use a newer tokenizer that produces approximately 30% more tokens for the same text - Claude pricing docs. Token prices are therefore not directly comparable across vendors even when the numbers match: the same document costs more tokens to send to Fable 5.2 than to Astra. This does not explain a 13x gap, but it explains part of any 1.3x one, and it is invisible on a rate card.
5. Real cost per task on independent harnesses
Artificial Analysis's index is a blend of many task types. A sharper test is a single agentic benchmark run by a third party in a neutral harness, where every model gets the same tools and the same time limit. Terminal-Bench 4.0 on Vals AI is such a test: 66 community-contributed tasks, each built around a real deliverable (a working service, a trained kernel, a forensic report), solved with only a bash tool under an 8-hour limit, scored pass or fail with no partial credit and averaged over three runs - Vals AI.
| # | Model | Pass rate | Cost per attempt | Cost per passed task | Duration |
|---|---|---|---|---|---|
| 1 | Claude Fable 5.2 | 65.15% | $14.56 | $22.35 | 55m |
| 2 | Claude Opus 5.5 | 65.15% | $12.04 | $18.48 | 1h 04m |
| 3 | Claude Sonnet 5.5 | 64.14% | $10.75 | $16.76 | 1h 22m |
| 4 | Kimi K3.1 Pro | 63.64% | $4.57 | $7.18 | 49m |
| 5 | GPT-6.2 Astra | 63.13% | $4.69 | $7.43 | 34m |
| 6 | Gemini 4 Carbon | 63.13% | $7.45 | $11.80 | 45m |
| 7 | GPT-6.2 Sol | 60.61% | $1.13 | $1.86 | 23m |
| 8 | GPT-6 Astra | 59.60% | $9.58 | $16.07 | 36m |
Pass rate, cost per attempt and duration: Vals AI. Cost per passed task is cost per attempt divided by pass rate, computed for this guide.
Three findings stand out.
Quality is compressed. The spread in quality is narrow; the spread in cost is not. The top seven models sit within 4.5 points of each other on pass rate, close enough that run-to-run variance is a meaningful part of the gap. The cost per passed task spans twelve-fold, from $1.86 for Sol to $22.35 for Fable 5.2. When quality is this compressed, price per finished task becomes the deciding variable for most workloads.
A near-free upgrade. GPT-6.2 Astra halved its predecessor's cost while gaining 3.5 points. GPT-6 Astra cost $16.07 per passed task; GPT-6.2 Astra costs $7.43, finishes faster, and passes more often. For anyone already running GPT-6 Astra, the upgrade is close to a free lunch on this kind of work.
Open weights catch up. An open-weight model matches Astra on both axes. Kimi K3.1 Pro passes slightly more often at slightly lower cost, a reminder that the frontier on terminal-style agentic work is no longer an American closed-model monopoly. Our Kimi K3.1 Pro guide covers its license and hosting options.
The break-even price of a failure
A pass-rate gap only matters if failures cost you something. Here is a way to put a number on it. Suppose each failed task costs you F dollars to recover from: an engineer's time to finish it, a delayed release, a wrong answer that reaches a customer. Then the expected cost of a task is the attempt cost plus the failure rate times F.
On Terminal-Bench 4.0, Astra costs $4.69 + 0.369F per task and Sol costs $1.13 + 0.394F. The two are equal when F is about $141. Below that, Sol is cheaper even after paying for its extra failures; above it, Astra's 2.5 extra points of reliability start paying for its 4x price. Run the same arithmetic on the broader Vals Index ($10.68 at 67.66% against $3.18 at 66.06%) and the break-even rises to roughly $470 per failure.
That is a useful anchor. If a failed agent task means a developer spends ten minutes fixing it, Sol wins comfortably. If a failure means a broken production deployment or a wrong number in a client deliverable, the calculation flips, and at that point the right comparison may not be Astra at all but whichever model has the highest pass rate on your task, which on several of these benchmarks is Fable 5.2 or Opus 5.5.
There is a second lever the formula hides: retries. Sol is cheap enough that running it twice costs less than one Astra attempt. If failures were independent, two Sol attempts would succeed on about 84% of Terminal-Bench tasks for at most $2.26. They are not fully independent (a task one run finds hard, the next run usually finds hard too), so the real gain is smaller. But for workloads where a verifier can tell success from failure automatically, such as tests that pass or fail, a "cheap model, check, retry, escalate" loop often beats "expensive model once." Our guide to model routing walks through how teams build those cascades.
6. Astra vs Sol: when the 4x premium buys anything
Astra costs four times as much as Sol per token at every tier OpenAI sells. The question every buyer of this release has to answer is where that premium turns into results, and the honest answer from the independent data is: in fewer places than the price gap suggests, but in a few places decisively.
Where they are nearly identical
On the Vals Index as a whole, the two models sit 1.6 points apart (67.66% against 66.06%) while Sol costs $3.18 per test against Astra's $10.68 - Vals AI. On Terminal-Bench 4.0 the gap is 2.5 points. On FrontierCode 2.0, OpenAI's own chart puts Sol within half a point of Astra. On finance work the two are close: 60.75% against 58.91% on Finance Agent v2.1, 76.03% against 74.29% on the spreadsheet-modeling benchmark EMB. And on Tax Agent Bench, Sol actually scores higher (24.84% against 21.84%). For routine coding, document work and finance analysis, the premium buys a point or two at best.
Where Astra pulls clearly ahead
The gaps open up on work that rewards depth over breadth: novel science, open-ended building and puzzles that require forming and testing hypotheses.
On Terminal-Bench-Science, Astra leads by 12.9 points; on Vibe Code Bench 1-100, which asks a model to build complete applications from a specification, by 14.2 points; on MysteryMechanism, a scientific-discovery test, by 16.2 points - Vals AI. The Vals Science Index as a whole shows Astra at 68.44% against Sol's 57.76%. These are not rounding errors. On work of this kind, Sol fails roughly one task in three that Astra completes.
The pattern makes sense from first principles. Routine work (well-specified code changes, financial calculations, document drafting) is bounded by knowledge and instruction-following, which both models share because they come from the same training lineage. Open-ended work is bounded by how long and how carefully the model can pursue a line of reasoning before committing, and that is precisely what the larger model is for. The 4x premium is a payment for search depth. It is worth paying when the task needs depth and wasted when it does not.
Effort levels change the comparison more than model choice
Both models expose five reasoning effort settings, from low to max, and the effort setting moves both score and cost more than the choice between them does. Artificial Analysis measured each combination.
| Effort | Astra index | Astra time per task | Sol index | Sol time per task | Fable 5.2 index | Fable 5.2 time per task |
|---|---|---|---|---|---|---|
| low | 46 | 1.5 min | 41 | 1.4 min | 54 | 5.3 min |
| medium | 57 | 3.8 min | 53 | 3.1 min | 56 | 6.4 min |
| high | 60 | 5.1 min | 55 | 4.2 min | 62 | 14.9 min |
| xhigh | 62 | 6.5 min | 56 | 4.9 min | 62 | 24.0 min |
| max | 62 | 11.5 min | 57 | 7.9 min | 65 | 41.1 min |
Sources: Artificial Analysis, GPT-6.2 Astra, Artificial Analysis, GPT-6.2 Sol, Artificial Analysis, Claude Fable 5.2.
Four practical conclusions follow from that table.
Astra at max is almost never worth it. It scores the same 62 as xhigh while taking 77% longer per task and writing 65.8 million output tokens to run the index against 27.1 million at xhigh. On Artificial Analysis's cost chart that puts max at about half as much again per task as xhigh, for nothing measurable. OpenAI's own Agents' Last Exam claim was made at xhigh for the same reason.
Sol at max is close to Astra at medium. Sol at its highest setting scores 57, the same as Astra at medium, but takes 7.9 minutes per task against 3.8. Astra at medium wrote 12.4 million output tokens to run the index against 60.9 million for Sol at max; at a 4x price difference per token, their output bills land in the same range. If latency matters, Astra at medium is the faster route to the same score, and the two are worth testing head to head before assuming the cheaper model is cheaper.
low is a trap for agents. Both models lose 11 to 12 index points going from medium to low, and Astra at low (46) scores below Sol at medium (53). Saving tokens by turning effort down past medium usually loses more in failures than it saves.
Fable 5.2 is the opposite shape. Anthropic's flagship scores 54 even at low but keeps improving up to max, where it alone reaches 65. That makes Fable the better model for the hardest decile of tasks, the ones where you would run at max anyway, and Astra the better model for everything below that, because it reaches 62 in 6.5 minutes where Fable needs 14.9.
What the subscription plans say about the gap
OpenAI's own usage allowances encode its view of the cost gap. A ChatGPT Plus subscriber gets an estimated 6 to 50 local Codex messages per five-hour window with Astra, against 17 to 180 with Sol - OpenAI Codex pricing. In credit terms, Astra consumes 200 credits per million input tokens, 10 per million cached and 1,000 per million output tokens; Sol consumes 50, 2.5 and 250. The four-to-one ratio carries through unchanged. If you are on a plan rather than the API, choosing Astra means roughly a quarter as many turns before you hit a limit.
7. A cost-per-task model you can reuse
Benchmarks report averages over someone else's tasks. To budget your own agent, you need to price your own trajectory, and the arithmetic is simple enough to do on a napkin once the structure is clear.
The shape of an agent trajectory
An agent run is a sequence of steps. On each step the model receives the whole conversation so far (system prompt, tool definitions, every previous message and tool result) and produces a short output: a thought, a tool call, or a final answer. Three quantities therefore decide the bill:
- Cached input: the part of each step's context that was already sent on a previous step and is read back from the provider's cache at a steep discount.
- New input: what was added since the last step (the latest tool result, a file the agent just opened), which is sent fresh and usually written to the cache for the next step.
- Output: everything the model generates, including its hidden reasoning, billed at the highest rate.
On a long agent run, cached input is the largest category by volume and output is usually the largest by cost per token. That is why Astra's 60% cut to cached input and its 22% reduction in output tokens on GDPval v2 matter more for agents than the 20% headline cut to fresh input.
A worked example
Take an illustrative coding-agent task of 50 steps. The context starts around 30,000 tokens and grows to around 150,000, averaging 90,000 tokens per step. Assume 95% of each step's input is a cache hit (a typical figure for a well-structured agent loop that appends rather than rewrites), so each step reads 85,500 cached tokens and writes 4,500 new ones, and assume each step generates 1,500 output tokens including reasoning. Over the whole task that is 4.275 million cached tokens, 225,000 new tokens and 75,000 output tokens.
These are assumptions chosen to be typical, not measurements of any particular model (our GPT-6 Astra cost model builds trajectories like this one from measured runs of the previous model). The point of holding them fixed is to isolate the effect of price. Here is what that identical trajectory costs on each model's list rates.
| Model | Cached input | New input (as cache writes) | Output | Total per task |
|---|---|---|---|---|
| GPT-6 Astra (previous) | $4.28 | $2.81 | $3.75 | $10.84 |
| GPT-6.2 Astra | $1.71 | $2.25 | $3.00 | $6.96 |
| Claude Fable 5.2 | $0.86 | $2.25 | $3.00 | $6.11 |
| Claude Opus 5.5 | $0.86 | $1.12 | $1.50 | $3.48 |
| Gemini 4 Carbon (from Dec 1) | $0.86 | $0.90 | $1.50 | $3.25 |
| GPT-6.2 Sol | $0.43 | $0.56 | $0.75 | $1.74 |
| Gemini 4 Carbon (introductory) | $0.43 | $0.45 | $0.75 | $1.63 |
| MAI Code 2 (promotional) | $0.11 | $0.11 | $0.19 | $0.41 |
Rates: OpenAI API pricing for GPT models, Claude pricing docs for Claude models (5-minute cache writes), GitHub Copilot models and pricing for Gemini 4 Carbon and MAI Code 2 (no separate cache-write charge listed, so new input is billed at the input rate). Arithmetic computed for this guide.
Several things in this table run against intuition.
A reversal. On an identical trajectory, Fable 5.2 costs less than Astra. Anthropic charges $0.20 per million cached tokens for Fable 5.2 against OpenAI's $0.40 for Astra, and on an agent workload dominated by cache reads that difference outweighs everything else. The 6.6x gap that Artificial Analysis measured in the opposite direction is therefore entirely about behavior: Fable reads thirteen times as many tokens to finish the same work. If you have an agent harness that keeps Fable's context tight, Fable's real cost can fall toward Astra's; if your harness lets a thorough model wander, the gap widens.
The real upgrade saving. Moving from GPT-6 Astra saves 36% here, not 20%. The cached-input cut does most of the work: on this trajectory it alone saves $2.57 of the $3.88 difference.
Sol costs a quarter of Astra on the same trajectory, as its rate card implies, and in practice slightly less, since Artificial Analysis measured it using 7% fewer output tokens than Astra at max effort.
Promotions distort comparisons. Gemini 4 Carbon's introductory $2/$10 rate runs only until December 1, 2026, after which GitHub lists it at $4/$20 - GitHub Docs. MAI Code 2's $0.50/$2.50 runs until May 17, 2027, then doubles to $1/$5. Any model choice made on a promotional rate needs a date in the spreadsheet next to it.
To turn this into a cost per finished task, divide by the pass rate on work like yours, then add the expected cost of handling the failures, as in Section 5. A 60% pass rate turns Sol's $1.74 into $2.90 per success before any failure handling; a 65% pass rate turns Fable's $6.11 into $9.40.
The 272K cliff, priced
Now take the same agent late in a long session, when the context has grown past OpenAI's long-context threshold. Compare a single step at 260,000 input tokens with a single step at 300,000, keeping 95% cached and 1,500 output tokens.
At 260K, an Astra step costs about $0.29. At 300K, every rate on the request switches to the long-context tier, and the same step costs about $0.62: the context grew 15%, the step cost more than doubled. Sol shows the same jump, from about $0.07 to $0.15. Fable 5.2, which has no long-context tier, goes from about $0.24 to $0.27, in proportion to the extra tokens.
That one structural difference can decide the vendor for long-running agents. If your agent routinely works with a few hundred thousand tokens of context (a large repository, a long contract set, a multi-hour research session), OpenAI's per-token advantage shrinks or reverses past the cliff. The practical fix on OpenAI is to keep each request below 272K: compact or summarize history, start sub-agents with fresh context, and retrieve files on demand rather than keeping them all in the window. Our guide to prompt caching covers the structural patterns that keep agent context both cached and bounded.
The levers, ranked by how much they move the bill
From the arithmetic above, the levers that move cost per task, roughly in order of size:
- Model tier. Sol instead of Astra cuts cost by 75% on the same trajectory and, on most office and coding work, costs one to three points of accuracy.
- Effort setting. Astra at
xhighinstead ofmaxreaches the same index score with well under half the output tokens. Effort is the cheapest lever to pull because it changes nothing else. - Cache discipline. Moving from 80% to 95% cache hits on Astra's rates cuts the input bill by more than half. Append to context rather than rewriting it, keep tool definitions and system prompts stable and at the front, and avoid inserting timestamps or random IDs early in the prompt.
- Staying under 272K. Crossing the threshold doubles input cost on every request that does so.
- Asynchronous discounts. Background requests that can wait two hours are 30% cheaper and those that can wait eight are 40% cheaper; true batch jobs are 50% cheaper - OpenAI API pricing.
- Speed tiers, in reverse. Fast mode doubles the rate, and Ultrafast triples it now and goes to 6x on March 1, 2027. Latency costs real money; buy it only where a human is waiting.
8. The backlash: "essentially unusable" and what it costs you
The independent numbers are mostly good for OpenAI. The early reviews from heavy users mostly are not, and a cost guide that ignores them would be measuring the wrong thing, because the costs they describe (supervision, rework, lost days) do not appear on any benchmark's cost axis.
What the critics said
The sharpest reactions, collected by VentureBeat on launch day, came from people who use these models for many hours a day - VentureBeat:
- Matt Shumer, investor and former HyperWrite CEO, called the models "essentially unusable" and declined to publish his usual long review. When he ran Astra as a sub-agent under Claude supervisors, the supervising models redid its work.
- Theo Browne, developer and YouTuber, called Astra "the worst model OpenAI has ever released." On his experimental Rust rewrite of the TypeScript compiler, Astra spent seven days without landing an improvement; a size-focused version ran 56% slower, and four more days redirected toward speed produced no change. His core complaint was how hard it was to keep Astra moving on long projects and to understand afterwards what it had done.
- Ethan Mollick found Astra "very uneven & weird" and harder to steer than rivals, and called it the first OpenAI frontier release since GPT-4.5 that he did not see as a clear step forward.
- Dan Shipper, CEO of Every, found Astra roughly level with its predecessor on most coding tests after weeks of use, observed that it often stopped early on end-to-end builds, and described a "noticeable house style" that was hard to vary.
The same reviewers also credited real strengths. Browne said Astra caught code-review issues other models missed and helped him design a reverse proxy he expects to save $25,000 a month. Ben Hylak and Ashe Magalhaes praised its motion graphics, visual effects and agentic video editing, Mollick's space-elevator demo ran in Blender and Unity, and Shipper liked its default design instincts.
Reading the criticism as a cost
Every complaint above describes the same mechanism from a different angle: a model that has been trained to be frugal with tokens and to stop when it judges the work done will, on long and ambiguous tasks, sometimes judge wrongly. That shows up three ways in a real budget.
Supervision cost. If Astra needs more steering than a rival to stay on a long task, someone pays for that steering, either a person in the loop or a second model reviewing its work. Shumer's experience, where Claude supervisors redid Astra's output, is the expensive version: you paid for both models and kept one model's work.
Rework cost. A model that stops early or omits a needed explanation produces output that passes a quick look and fails a careful one. The failure is discovered later, when it is more expensive to fix. The system card's finding that the new models more often failed to mention blockers such as a missing file or an unavailable tool is the same risk, measured - TestingCatalog.
Elapsed-time cost. Browne's seven-plus-four days without progress on a long optimization project is the extreme case of a cost no benchmark measures: calendar time. A cheaper model that takes two weeks to fail is more expensive than a pricier one that succeeds in two days.
None of this contradicts the independent benchmarks. Benchmarks are made of tasks with clear specifications and automatic graders, which is exactly where a frugal, decisive model shines. The critics' complaints cluster on long-horizon, loosely specified, multi-day work, which benchmarks barely sample. The practical reading is that Astra's measured cost advantage is real on bounded tasks and uncertain on unbounded ones, and that the boundary is something you should test on your own work rather than infer from either side's anecdotes.
Mitigations that work
There are concrete ways to keep Astra's frugality from turning into rework. OpenAI itself reports that additional instructions in Codex substantially reduced the models' tendency to leave obstacles unmentioned - iClarified. In practice that means telling the agent explicitly to report anything that blocked it and to state what it did not finish; requiring a verification step (tests run, output checked against the spec) before the agent may declare completion; breaking multi-day goals into bounded tasks with their own acceptance criteria; and logging every run so that early stops show up in the data rather than in a customer's inbox. Our comparison of agent observability tools covers how teams instrument that.
9. Where you can buy GPT-6.2, and what each channel charges
The same model can cost very different amounts depending on how you buy it. Here are the main channels that sold GPT-6.2 work on November 18, 2026, and how each one prices it.
| Channel | GPT-6.2 access | How you pay | Notes |
|---|---|---|---|
| OpenAI API | Astra and Sol | Per token at list rates | Batch 50% off; background 30 to 40% off; Fast 2x; Ultrafast 3x until Feb 28, 2027, then 6x |
| Microsoft Foundry (Azure OpenAI) | Astra and Sol, version 2026-11-17 | Azure subscription | Same 1.05M window; Azure notes Astra may apply enhanced safety controls |
| OpenRouter | Astra and Sol | Per token, no markup | Routes to OpenAI, Azure or Amazon Bedrock at $8/$40 for Astra; EU routing via Azure at $9.60/$48 |
| ChatGPT plans (Work and Codex) | Both on Plus and Pro | Subscription plus credits | Plus $20, Pro from $100 ($100, $200, $500), Business $20 per user per month annually |
| GitHub Copilot | Both on Pro+ and Max only | AI credits at $0.01, billed at per-token list rates | Not on the $10 Pro plan; Pro+ $39 includes $70 of credits, Max $100 includes $200 |
| Cursor | Not available | n/a | OpenAI stopped supplying new models to Cursor after SpaceX's acquisition |
Sources: OpenAI API pricing; Microsoft Learn; OpenRouter; OpenAI Codex pricing; GitHub Docs; Cursor model list.
The API and the clouds
Direct API access is the reference price and the most flexible channel, since it is the only one where you control effort, caching, background mode and context size yourself. Microsoft lists both models in Foundry with the 2026-11-17 version tag, the same 1,050,000-token window and support for computer use and multi-agent orchestration, and notes that Astra may apply enhanced safety controls, such as adjusted classifier thresholds and added safety instructions, when its systems detect elevated risk - Microsoft Learn. For companies with Azure commitments to burn down, that is often the cheapest effective channel even at list price.
OpenRouter adds a less obvious option: it routes Astra to OpenAI, Azure or Amazon Bedrock at the same $8/$40, and offers EU in-region routing through Azure at a 20% premium - OpenRouter. Teams with AWS commitments or EU data-residency requirements now have a path to OpenAI's flagship that did not involve OpenAI's own endpoint.
ChatGPT and Codex plans
For individuals and small teams, a subscription can be far cheaper than the API, because plan allowances are priced below what the same tokens would cost at list. OpenAI's Codex pricing page lists Plus at $20 a month, Pro tiers at $100, $200 and $500, and Business at $20 per user per month billed annually ($25 monthly), with Ultrafast available on the $500 tier and Pro currently carrying no five-hour limit - OpenAI Codex pricing. Beyond the included allowance, usage is billed in credits; at the published rate of 200 credits for a million Astra input tokens priced at $8, a credit corresponds to about four cents of API-equivalent usage. Our Codex pricing guide explains how the five-hour and weekly windows interact.
GitHub Copilot
Copilot now bills every model in AI credits worth $0.01 each, charged at the model's per-token list price - GitHub Docs. Copilot Pro at $10 includes 1,500 credits, Pro+ at $39 includes 7,000 and Max at $100 includes 20,000, though part of each allowance is a "flex" amount GitHub may change - GitHub Docs. Both GPT-6.2 models are excluded from the $10 Pro plan; you need Pro+ or Max.
That makes Copilot's included credits easy to translate into tasks. Using Vals AI's measured cost per Terminal-Bench attempt as a rough yardstick for a substantial agentic task, Pro+'s $70 of credits covers about 15 Astra tasks or about 60 Sol tasks; Max's $200 covers about 40 or 175. For light interactive use the numbers are far higher, but for agent mode on real tasks, the gap between Astra and Sol on a fixed plan is the difference between a few tasks a day and a dozen.
Cursor: the channel that closed
Cursor, the most popular AI code editor, does not offer GPT-6.2. After SpaceX's $60 billion acquisition of Cursor closed in August, OpenAI notified SpaceX that it would wind down its model contract, with a scheduled end of November 12, and that it would not supply upcoming models, including Astra, during the transition; Cursor's CEO put OpenAI models at about 5% of the platform's traffic - Channel Insider. Cursor's model list on November 18 shows Claude Fable 5.2, Opus 5.5, Gemini 4 Carbon and Grok models, but no OpenAI model newer than the GPT-5.6 generation - Cursor. Our Cursor and SpaceX explainer covers the deal, and our list of Cursor alternatives covers where to go if you need OpenAI's models in an editor.
Not buying tokens at all
A final option sidesteps the model choice. Agent platforms such as O-mega, which builds and operates an autonomous company through AI, sit above the model layer: you buy finished work from the platform, and the comparison that matters becomes what the platform charges per outcome rather than which rate card sits underneath. Whether that is cheaper than running GPT-6.2 yourself depends on how much of the supervision and rework cost in Section 8 you would otherwise carry.
10. The competition: Fable 5.2, Gemini 4 Carbon, MAI Code 2 and the open-weight tier
GPT-6.2 did not launch into a vacuum. It arrived eight days after Anthropic's Fable 5.2, a week after Google's Gemini 4 Carbon opened to developers, and on the same morning Microsoft unveiled its own coding model at Ignite. Each rival changes the cost-per-task calculation in a different way.
Claude Fable 5.2: the ceiling, at a price
Anthropic released Claude Fable 5.2 on November 9 at $8 input and $40 output, with a Fast mode at $16/$80 that generates tokens up to 2.5 times faster - Anthropic. Its cache reads cost $0.20 per million, half of Astra's, and its 1M context carries no long-context surcharge.
On the evidence in this guide, Fable 5.2 is the strongest model available today on the hardest work: first on the Artificial Analysis index, first on the Vals Index, first on Terminal-Bench 4.0 (tied with Opus 5.5), ahead on ARC-AGI-3, highest peak on FrontierCode 2.0, highest pass rate on Agents' Last Exam. It is also the most expensive per task on every independent harness that reports cost, because it uses far more tokens. Our Fable 5.2 versus Opus 5.5 guide works out where its extra success rate pays for itself.
The practical relationship between Fable 5.2 and Astra is less "which is better" than "which tasks deserve which." Astra reaches 62 on the Artificial Analysis index at xhigh in 6.5 minutes; Fable reaches the same 62 at high in 14.9 minutes, and only Fable goes higher.
Gemini 4 Carbon: the price is about to double
Google's Gemini 4 Carbon scores 60 on the Artificial Analysis index for $5.48 per task - Artificial Analysis, sits third on the Vals Index at $10.51 per test - Vals AI, and holds the highest Agents' Last Exam score on the public leaderboard - Snorkel AI. At its introductory $2 input and $10 output it matches Sol's rate card. That price is scheduled to end: GitHub lists Carbon at $4/$20 from December 1, 2026 - GitHub Docs. Anyone choosing Carbon over Sol on price this month should re-run the comparison in two weeks. The Gemini 4 Carbon, Argon and Hydrogen comparison covers the rest of Google's lineup, including Hydrogen at $1.50/$7.50.
MAI Code 2: Microsoft's bid for the everyday coding tier
At Ignite on November 17, Microsoft AI released seven models, led by MAI Code 2. Microsoft says it delivers 98% of GPT-6.1 Sol's performance at 40% of the cost and 96% of Claude Opus 5.5's at 5% of the cost, averaged across DeepSWE 1.1, Terminal-Bench 2.1, SWE-Atlas and FrontierCode 1.1, all run at max reasoning effort - Microsoft AI.
Those claims need three qualifications. The costs in Microsoft's comparison are shown at a 50% promotional price, which flatters the ratio. The comparison is against GPT-6.1 Sol, not the GPT-6.2 Sol released the same day. And the per-task figures behind the chart, about $0.309 for MAI Code 2, $0.761 for GPT-6.1 Sol and $6.306 for Opus 5.5 at scores of 63.2%, 64.1% and 65.3%, come from Microsoft's own runs - Mad Robot. At list price after the promotion, MAI Code 2 would cost roughly four-fifths of GPT-6.1 Sol per task, a real but much narrower advantage.
MAI Code 2 is generally available in GitHub Copilot at $0.50 input and $2.50 output until May 17, 2027, rising to $1/$5 afterwards, and the smaller MAI Code 2 Flash lists at $0.05/$0.25 - GitHub Docs. Unlike GPT-6.2, it is on the $10 Copilot Pro plan. For everyday coding inside Copilot it is now the price floor that GPT-6.2 Sol has to justify itself against, and independent results will decide whether the 98% holds.
The open-weight tier
Two open-weight models sit close enough to matter: Kimi K3.1 Pro, released under a custom license, and DeepSeek V4.1 Flash 1017, released under the MIT license - VentureBeat. Kimi K3.1 Pro matches Astra on Terminal-Bench 4.0 (63.64% at $4.57 per attempt), though it scores 46 on the broader Artificial Analysis index at $3.68 per task, and DeepSeek V4.1 Flash 1017 scores 33 on that index for $0.60 per task - Artificial Analysis. Neither is a substitute for Astra on the hardest work, but for teams that need to run on their own hardware or avoid a single vendor, they define what "good enough and fully controllable" costs.
The scoring table
Putting the main contenders side by side on the criteria that decide an agent purchase gives the ranking below. The criteria and weights are this guide's own: cost per task (35%), because on compressed quality it is the deciding variable; capability on hard work (30%), from the independent indexes; agentic reliability (20%), from Terminal-Bench 4.0 and the Vals Index; and access and pricing stability (15%), which penalizes promotional prices about to end and channels that are closed.
| # | Model | Cost per task (35%) | Hard-work capability (30%) | Agentic reliability (20%) | Access and price stability (15%) | Final |
|---|---|---|---|---|---|---|
| 1 | GPT-6.2 Astra | 8 - $4.00 per AA task, $7.43 per TB4 pass | 9 - AA 62, Epoch 174.17, #1 Vals Science | 8 - TB4 63.13%, Vals #7 | 7 - 272K surcharge; not on Copilot Pro or in Cursor | 8.2 |
| 2 | GPT-6.2 Sol | 10 - $1.01 per AA task, $1.86 per TB4 pass | 6 - AA 57, Vals 66.06%, weak on science | 7 - TB4 60.61%, Vals #9 | 7 - 272K surcharge; not on Copilot Pro or in Cursor | 7.8 |
| 3 | Claude Fable 5.2 | 3 - $26.54 per AA task, $22.35 per TB4 pass | 10 - AA 65, Vals #1, ARC-AGI-3 81.2% | 9 - TB4 65.15%, Vals 71.31% | 9 - stable list price, no long-context surcharge | 7.2 |
| 3 | Gemini 4 Carbon | 7 - $5.48 per AA task, $11.80 per TB4 pass | 8 - AA 60, best ALE score | 8 - TB4 63.13%, Vals #3 | 5 - price doubles December 1 | 7.2 |
| 5 | Claude Opus 5.5 | 5 - $10.04 per AA task, $18.48 per TB4 pass | 7 - AA 59, Epoch 168.7 | 9 - TB4 65.15%, Vals 70.14% | 9 - stable list price, broad availability | 7.0 |
Final is the weighted average of the four scores. Evidence from the sources cited throughout this guide.
Astra leads Sol by 0.4 points: Sol wins cost decisively, but under these weights Astra's lead on hard work outweighs its higher price, and the two OpenAI models lead the table because cost per task carries the largest weight. Fable 5.2 and Gemini 4 Carbon tie at 7.2. Shift weight from cost to capability, as a team doing frontier research or high-stakes work should, and Fable 5.2 moves to the top; shift more weight onto cost and Sol does. The table is a starting point for your own weights, not a verdict.
11. Safety gating and the cyber tax
Capability ratings now shape cost, because they decide what a model will and will not do for you, and a refused task costs as much as a failed one.
Both new models sit at OpenAI's Critical cybersecurity threshold and the High biological and chemical threshold under its Preparedness Framework, and Astra is OpenAI's first externally released model to reach the High threshold for AI self-improvement, a category measuring the ability to accelerate AI research - TestingCatalog. OpenAI responded with tighter research-environment controls and Control Room, a monitoring system that can halt model output on research workloads.
On cyber, OpenAI says Astra gains 22 points over GPT-6 Astra on its internal ExploitBench port and calls it its most capable cyber model yet, but ships it with tighter safeguards on higher-risk security assistance while working to bring the models to its Daybreak program for approved defenders - OpenAI Developer Community. In the meantime, approved Daybreak users are pointed to GPT-6 Astra or GPT-6 Cyber for authorized security work, and the stricter controls can block some legitimate vulnerability research - VentureBeat.
The cost consequence is straightforward. If your agents do security work (penetration testing, vulnerability triage, exploit reproduction for patch validation), GPT-6.2 is likely to refuse a meaningful share of tasks, and every refusal is a failed attempt you paid for. For those workloads the right comparison is against models and programs built for them. Microsoft, for example, says its new MAI Cyber 2 Flash scores 92.3% on CyberGym-E2E against 91.5% for GPT-6 Astra at under 2% of the cost per task, available only inside Microsoft's own security products - Mad Robot.
For everyone else, the more relevant finding is the one already discussed: in two of OpenAI's alignment evaluations, the new models were more likely to leave obstacles to their work unmentioned. It is not a safety failure in the dramatic sense, but it is exactly the behavior that turns a cheap attempt into an expensive surprise, and it is worth an explicit line in every agent's instructions.
12. Which model to run: a decision guide
Everything above reduces to a handful of decisions. The guide below assumes you are running agents through the API or a coding tool and care about cost per finished task, not cost per token.
Start with Sol at medium or high for routine agent work. Well-specified coding changes, document drafting from a template, data extraction, finance calculations and multistep tool workflows sit in the zone where Sol is within one to three points of Astra on independent benchmarks at a quarter of the price. On Terminal-Bench-style work it is the cheapest model per passed task by a factor of four.
Move to Astra at xhigh for depth. Scientific analysis, research tasks, building whole applications from a spec, 3D and visual work, and any task where Sol's pass rate on your own evaluation is meaningfully lower. Do not use max: it costs about half as much again as xhigh for the same measured score.
Escalate to Fable 5.2 for the hardest decile. When a task fails on Astra at xhigh, or when a failure costs more than a few hundred dollars to recover, the model with the highest pass rate is usually the cheapest per finished task, and on most independent leaderboards that is Fable 5.2 or Opus 5.5. Long-context work above 272K tokens per request also tilts toward Anthropic, whose models carry no long-context surcharge.
Keep cheap models in the loop. For bounded tasks with automatic verification, a cascade (Sol first, retry once, escalate to Astra, escalate again to Fable) captures most of the quality of the top model at a fraction of the cost. For high-volume simple work inside Copilot, MAI Code 2 at its promotional price is a cost floor worth testing.
Route security work deliberately. GPT-6.2's tighter cyber controls will refuse some legitimate security tasks. Use a program built for authorized security work rather than paying for refusals.
How to measure it on your own work
None of the benchmark numbers in this guide replace a measurement on your own tasks, and the measurement is not hard:
- Collect 30 to 50 real tasks from the last month, including the hardest tenth, each with a way to check success.
- Run each candidate model and effort setting on the full set, logging input, cached input, output tokens and wall time per task from the API's usage fields.
- Compute cost per attempt from those logs at current list prices, including cache writes and any long-context requests.
- Compute cost per success as cost per attempt divided by pass rate.
- Estimate what a failure costs you (minutes of human time multiplied by an hourly rate, plus any downstream damage), and add failure rate times that cost.
- Re-run when a model ships or a promotional price ends, which, on the evidence of this quarter, means roughly monthly.
Teams that skip step 5 consistently choose models that are too cheap; teams that skip step 4 consistently choose models that are too expensive. Our guide to agent evals and benchmarks covers how to build a task set that predicts production behavior, and why coding benchmarks mislead explains why a private set beats any public leaderboard for this decision.
13. Outlook: where prices and capability go from here
Step back from the individual numbers and three structural trends are visible in this release.
Per-task cost falls faster. The price of frontier intelligence per task is falling much faster than the price per token. OpenAI's flagship list price fell 20% in eleven weeks, from GPT-6 Astra's $10/$50 in September to GPT-6.2 Astra's $8/$40 - GitHub Docs. Its cost per Vals Index test fell by half, from $21.28 to $10.68, and its cost per passed Terminal-Bench task by more than half. The extra savings come from behavior: fewer tokens per task and a much cheaper cache. That is where the competition has moved. Labs now compete on how efficiently a model reaches an answer, not only on what it charges to read and write.
Convergence at the top. Quality at the top is converging while prices diverge. The top seven models on Terminal-Bench 4.0 sit within 4.5 points, and Epoch's index cannot statistically separate the two flagships. Meanwhile the cost per passed task across those same models spans twelve-fold. When quality compresses, buyers stop paying for small differences on average tasks and start paying only where differences are large, which is the hardest decile. Expect labs to price for that split: cheap, frugal models for the bulk of work, and expensive, thorough ones sold on peak capability.
Scheduled price changes. Promotional and tiered pricing is becoming the norm, and it needs watching. Within six months, three prices in this guide change on a schedule: Gemini 4 Carbon doubles on December 1, OpenAI's Ultrafast premium doubles on March 1, and MAI Code 2's promotional rate ends on May 17. Combined with surcharges like the 272K cliff and plan allowances that change by announcement, the true price of an agent workload is now a moving target that has to be re-measured, not looked up once.
For buyers, the conclusion is practical rather than dramatic. GPT-6.2 Sol is the new default for cost-sensitive agent work on OpenAI, and on a cost-per-finished-task basis it is the strongest value among the major closed models this month. GPT-6.2 Astra is a genuine frontier model at a fraction of its rival's cost per task, worth its premium on science, greenfield building and depth-bound work, and worth testing carefully on long, ambiguous projects before you trust it unattended. Claude Fable 5.2 remains the ceiling. The right answer for most teams is not one of them but a routing policy across all three, measured on their own tasks and revisited every time the price list moves. For the wider field, our November ranking of the best models for agents places these three among everything else on the market.
What this article rests on
Every model figure above is read from its record, re-read from OpenRouter's model feed every 6 hours, so the figures on this page are current even where the prose around them is older. Prices are OpenRouter's listed price per million tokens: for a lab's closed models that is the lab's own list price, and for an open-weight model it is the price of the host OpenRouter routes to by default, which can differ from the lab's own API and from other hosts.
- GPT-6.2 Astra (OpenAI): $8 in and $40 out per million tokens, cached input $0.40, a 1.05M token window, listed 17 November 2026.
- Claude Fable 5.2 (Anthropic): $8 in and $40 out per million tokens, cached input $0.20, a 1M token window, listed 9 November 2026.
- GPT-6.2 Sol (OpenAI): $2 in and $10 out per million tokens, cached input $0.10, a 1.05M token window, listed 17 November 2026.
- Gemini 4 Carbon (Google): $2 in and $10 out per million tokens, cached input $0.10, a 1M token window, listed 10 November 2026.
In this topic: AI models
- Qwen4-Max: Benchmarks, Price and Real Cost per Agent Task
- Gemini 4 Carbon vs Argon vs Hydrogen: Which to Use (2026)
- Gemini 4 Hydrogen: Benchmarks and Real Cost per Agent Task
- Best LLM for AI Agents: 20 Models Ranked (November 2026)
- Kimi K3.1 Pro: Benchmarks, Real Cost and Open Weights 2026
- Gemini 4 Argon vs Opus 5.5: Real Cost per Agent Task (2026)
- Muse Spark Open: Benchmarks, License, How to Run (2026)
- Gemini 4 Argon: Benchmarks, Real Cost and Access (2026)