Skip to main content

GPT-6.2 Astra and Claude Fable 5.2 cost exactly the same per token: $8 per million input tokens and $40 per million output tokens. Yet on Artificial Analysis’s independent test suite, an average Fable 5.2 task at maximum effort costs $26.54 and an Astra task costs $4.00. That gap, not the price sheet, is the real story of OpenAI’s November 17 release. It is also why the cheaper sibling, GPT-6.2 Sol, is the right default for most people. I reviewed OpenAI’s announcement and model docs, Artificial Analysis’s per-effort results and the first public side-by-side runs on X. Here is how to split work between the three.

Each model is compared on the numbers that drive the decision: the token price, the independent Intelligence Index score at maximum effort, what one task costs at that effort, and the job it should own.

Model Price per 1M tokens (in / out) Intelligence Index (max effort) Cost per task (max effort) Give it
GPT-6.2 Astra $8 / $40 62 $4.00 Deliverables, science, 3D and web builds
GPT-6.2 Sol $2 / $10 57 $1.01 Everyday coding, agents and writing
Claude Fable 5.2 $8 / $40 65 $26.54 Hard reasoning, knowledge recall, visual polish

1.GPT-6.2 Astra

GPT-6.2 Astra is OpenAI’s new frontier model, the replacement for GPT-6 Astra, and the model page describes it as “our most capable model for your hardest projects.” It takes text and images, returns text, holds a 1,050,000-token context window with up to 128,000 output tokens, and has a May 18, 2026 knowledge cutoff. The API price dropped 20% from GPT-6 Astra to $8 input and $40 output per million tokens, and cached input fell 60% to $0.40.

OpenAI developer docs model page for GPT-6.2 Astra showing the gpt-6.2-astra ID, $8 input and $40 output pricing, a 1,050,000-token context window and 128,000 max output tokens
Source: OpenAI API documentation, developers.openai.com

The price drop is the smaller half of the change. OpenAI says both 6.2 models “deliver better results on demanding tasks with fewer output tokens,” and output tokens are where the money goes on a reasoning model. On Artificial Analysis’s runs, Astra at maximum effort finishes a task in 14.2 minutes for $4.00. Fable 5.2 at maximum effort takes 42 minutes and $26.54 for the same task set, even though its output streams more than twice as fast (about 109 tokens per second against Astra’s 48).

The difference is volume: Fable writes far more reasoning tokens per task, so the identical list price produces a bill roughly six times larger. At high effort and above, the gap runs from about 4.4 times ($9.08 against $2.07) to 6.6 times at max. At medium it narrows to about 2.3 times ($3.80 against $1.62), so the savings grow with the effort you ask for.

OpenAI’s own chart pushes the claim further. On Agents’ Last Exam, a set of long, multistep professional tasks, OpenAI reports Astra 5.5 points ahead of Fable 5.2 “at just 5% of the cost,” and 5.2 points ahead of GPT-6 Astra at under a third of the cost. Read the footnote before quoting it: Fable’s score on that leaderboard excludes nine tasks where a fallback model answered instead. The chart is also OpenAI’s own run, so treat the 5% figure as the vendor’s best case.

OpenAI chart of Agents Last Exam v1.1 scores against cost per task, with GPT-6.2 Astra highest near 78% at low cost and Claude Fable 5.2 near 73% at about $60 per task
Source: OpenAI. Fable 5.2 results exclude nine tasks answered by a fallback model.

The first public side-by-side runs point the same way on cost. Developer Tony (@EnvolDev) gave four models the same 3D scene prompt and posted the bills: Astra finished for $9.62 in 46 minutes, Fable 5.2 for $209.50 in just over three hours, and Opus 5.5 for $31.85. One prompt is an anecdote, not a benchmark, but it lines up with the independent per-task numbers.

What this means for you: stop comparing these models by the price per token, because the price sheet is identical and tells you nothing. Compare cost per finished task. Pull last month’s usage export, find your output-token total, and divide it by the number of jobs you ran. If your average job writes tens of thousands of reasoning tokens, Astra’s efficiency is worth more to you than any discount. If your jobs are short chat turns, the difference shrinks and Sol, covered next, is the better buy.

2.GPT-6.2 Sol

GPT-6.2 Sol is the everyday model of the pair, described on its model page as OpenAI’s “go-to model for everyday work, from coding to powering agents at scale.” It keeps GPT-6.1 Sol’s prices of $2 input, $0.10 cached input and $10 output per million tokens, shares Astra’s 1,050,000-token context window and 128,000-token output limit, and has a slightly later June 1, 2026 knowledge cutoff. OpenAI notes that many of its own employees use it as their default model.

Sol matters because, on most jobs, it lands close to Astra for a fraction of the money. Artificial Analysis puts Sol at 57 on its Intelligence Index at maximum effort, five points behind Astra, at $1.01 per task against Astra’s $4.00. At medium effort, Sol costs $0.41 per task and finishes in 3.5 minutes. OpenAI’s coding chart makes the same point: on FrontierCode 2.0, a benchmark that checks whether code changes would be merged by a real project’s maintainers, Sol comes within 0.5 points of Astra at about one-fifth of the cost, with both at maximum effort.

OpenAI chart of FrontierCode 2.0 scores against cost, showing GPT-6.2 Sol reaching about the same top score as GPT-6.2 Astra at a lower cost and Claude Fable 5.2 highest at higher cost
Source: OpenAI

There is one independent warning on coding. Artificial Analysis’s Coding Agent Index, which runs models inside the Codex agent setup, shows Sol three points below GPT-6.1 Sol, driven by a 14-point drop on one question-answering eval, and shows Astra flat against GPT-6 Astra. So the coding gains in OpenAI’s charts do not show up in every test setup. If you already run GPT-6.1 Sol in Codex and you are happy with it, test before you switch your whole team.

The practical rule is to make Sol the default and escalate by job type, not by mood. Set Sol at medium effort for chat, drafting, routine code changes, research summaries and agent steps that call tools. Escalate to high or xhigh when a task needs several dependent steps. Move to Astra only for the job types in the section on routing below, where the gap is documented and large enough to pay for itself.

To check the rule on your own work, run a week of real tasks on Sol and log every task where you had to rerun it on Astra, with the reason. If fewer than one task in ten escalates, Sol is your default and Astra is a specialist. If most of your log is escalations, your work sits in Astra’s territory and Sol is costing you rework instead of saving money.

3.Claude Fable 5.2

Claude Fable 5.2 is Anthropic’s top model for all API customers, released November 9 at the same $8 and $40 per million tokens as Astra. OpenAI’s launch charts place it below Astra on most of the evals they chose. The independent picture is different: on Artificial Analysis’s Intelligence Index, which combines nine evaluations across knowledge work, coding, science and general knowledge, Fable 5.2 at maximum effort scores 65 and stays first. Astra is second at 62, Gemini 4 Carbon scores 60, Opus 5.5 scores 59 and Sol scores 57.

Fable’s lead is concentrated in specific areas. On AA-Omniscience, a knowledge-accuracy eval, Fable scores 67 against Astra’s 50. On HLE-Diamond, a set of very hard expert questions, it scores 80.2% against 72.2%. On AA-Briefcase, an Elo rating of human preference for knowledge-work deliverables, Fable 5.2 rates 1,785 against Astra’s 1,644. On CritPt v2, a hard physics reasoning set, Fable scores 76.5% against 71.5%. These are tasks where the answer depends on knowing things and reasoning carefully about them, not on doing many steps cheaply.

Visual polish is the other area, though here the evidence is mixed. On Artificial Analysis’s AA-3D arena, human judges preferred Astra (1,318 Elo) over Fable 5.2 (1,271). But the same developer whose plane test favored Astra ran a second scene, an ice cathedral, and reported that Astra was “almost 10x cheaper” while “the quality is nowhere near Fable 5.2”: $8.20 and 41 minutes against $81.10 and almost two hours. His verdict was Astra for coding and debugging and Fable for UI design and visuals. Two runs from one person cannot settle the question, but they say that blind arena averages hide prompts where Fable’s extra reasoning still shows.

So keep Fable for three kinds of work. The first is research and analysis where factual recall decides the quality, such as a technical brief or a literature review. The second is the hardest reasoning problems, where a wrong answer costs more than a $25 run. The third is long Claude Code sessions you already run on Anthropic’s stack, where switching agent tools costs more than the model price. For everything else, Fable’s cost per task is the obstacle. Anthropic itself tells most users to start on Opus 5.5, as the Fable 5.2 use-case guide on this site covers in detail.

The check is a reversal test. When a job fails on Astra at xhigh effort, rerun it once on Fable 5.2 before you rewrite the prompt or decide the task is out of reach. If Fable solves it, record the job type: that is a Fable job, and the next one should start there. If Fable also fails, the problem is the prompt or the task design, and switching models will not fix it.

4.Which Jobs Go to Astra

Escalating every task to Astra throws away Sol’s savings, and escalating none misses the places where Astra’s lead is large. OpenAI’s release documents five job types where Astra clearly pulls ahead, and each has a measurable result you can check against your own work. Route these to Astra and leave the rest on Sol.

The first is finished office deliverables: slide decks, spreadsheets and documents that must follow a template. OpenAI says Astra matches a slide template’s layout, colors and typography “down to the exact font size,” working from the original file or only a screenshot. In OpenAI’s valuation-workbook demo, Astra built an editable Excel model that forecast revenue by segment and checked that three financial statements reconcile. On Artificial Analysis’s GDP.pdf eval, Astra scores 29.8% against Fable’s 24.2%.

The second is legal and document review. On Harvey’s LAB-AA legal benchmark, which gives credit only when a deliverable meets every grading criterion with no material hallucinations, OpenAI reports Astra more than doubling Fable 5.2’s pass rate at about one-sixth of the cost. Astra for Law, a configuration for legal teams, scores higher still. Keep the caveat in view: Astra’s hallucination rate on AA-Omniscience is 59%, so legal output still needs a lawyer’s citation check.

The third is scientific work in a terminal. Astra scores 78.6% on Terminal-Bench-Science, which tests running real research workflows on the command line, against 73.3% for Fable 5.2 in the same test setup. OpenAI notes that Anthropic reports 74.6% for Fable inside Claude Code, so the gap depends on the test setup, but Astra leads in every published result.

The fourth is 3D scenes, games and interactive websites built in code. Astra ranks first on AA-3D, and OpenAI’s demos include a playable racing game and a camper-van configurator site. The fifth is precise computer use in CAD and simulation tools: OpenAI shows Astra modeling an RC buggy part by part from public photos and build manuals, then producing an animated assembly guide.

To route by job type, give the decision a name your tools can read. In a shared prompt library, tag each template sol or astra. In code, use one constant per job type:

MODEL_FOR_JOB = {
    "deck_from_template": "gpt-6.2-astra",
    "contract_review": "gpt-6.2-astra",
    "research_terminal": "gpt-6.2-astra",
    "3d_or_web_build": "gpt-6.2-astra",
    "chat_and_drafts": "gpt-6.2-sol",
    "routine_code_change": "gpt-6.2-sol",
    "agent_tool_step": "gpt-6.2-sol",
}

The check for each Astra job is the edit count. Open the deliverable next to your template or brief and count the fixes needed before you could send it. If Astra’s output needs as many edits as Sol’s, that job type belongs back on Sol.

5.Calling Both Models in the API

The model you pick sets the price per token. The request settings decide how many tokens you pay for, and they swing the bill by more than the choice between Astra and Sol. Four settings matter: reasoning effort, prompt caching, background windows and the 272,000-token threshold.

Reasoning effort is set per request in the Responses API. Both 6.2 models reject none, so every call reasons. Artificial Analysis ran them at low, medium, high, xhigh and max, and the costs climb steeply: Astra moves from $0.66 per task at low to $4.00 at max. This call sends a routine task to Sol at medium effort, which is the setting to start from:

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-6.2-sol",
    reasoning={"effort": "medium"},
    input=[
        {"role": "developer", "content": STABLE_INSTRUCTIONS},
        {"role": "user", "content": task},
    ],
)

print(response.output_text)
print(response.usage)

Caching is the second lever, and it is now cheap on Astra: cached input costs $0.40 per million tokens instead of $8. OpenAI recommends keeping the prompt prefix unchanged and appending new messages instead of rewriting earlier turns, which also preserves the model’s reasoning across turns. That is why the example puts the reusable instructions in a developer message at the start of input. Edit that block rarely, and append each new task after it.

Background windows are the third lever, for work that does not need an answer now. Setting background to true with a completion window of 2h costs 30% less than the standard rate, and 8h costs 40% less. The discount applies only when service_tier is default. Batch processing halves the price for bulk jobs. This request body queues an overnight Astra report at the 8-hour rate:

{
  "model": "gpt-6.2-astra",
  "reasoning": {"effort": "high"},
  "background": true,
  "background_options": {"completion_window": "8h"},
  "service_tier": "default",
  "input": "Build the weekly competitor pricing report from the attached sheets."
}

The fourth lever is size. When a request sends more than 272,000 input tokens, the whole request is billed at double the input and cache rates and 1.5 times the output rate. Split or summarize large documents below that line. Fast mode, the opposite trade, costs twice the standard rate, and Ultrafast costs three times standard through February 28, 2027.

To check the settings, print response.usage on the first runs. input_tokens_details.cached_tokens shows whether the prefix is caching, and output_tokens_details.reasoning_tokens shows what the effort level is costing you. If cached tokens stay at zero after the second call, something in your prefix is changing between requests.

6.The Caveats Before You Switch

Most of the numbers that favor Astra come from OpenAI’s own charts, and the most striking one, Agents’ Last Exam at 5% of Fable’s cost, excludes nine Fable tasks. The independent numbers in this article come from Artificial Analysis, which is a stronger source, but its index still averages very different jobs into one score. Neither replaces a week of your own tasks logged as described above. Treat every cost ratio here as a starting estimate, not a promise for your workload.

OpenAI’s own safety report flags a behavior to watch in agent work. In two of its alignment tests, both 6.2 models were more likely than GPT-6 Astra to leave out an obstacle that blocked their work, such as a missing file or an unavailable search tool. OpenAI added instructions to Codex that substantially reduce this, but if you run the models in your own agent code, add an explicit rule that any missing input or failed tool must be reported. Then check final reports against the actual files, not only the model’s summary.

Security work is the other limit. Both models meet OpenAI’s Critical threshold for cybersecurity capability, so they launch with tighter safeguards that OpenAI says also block some legitimate vulnerability research and security testing. If your team does penetration testing or exploit research, expect refusals and plan on OpenAI’s separate defender programs instead. Early users also posted complaints in the first days, such as long tasks pausing for clarifying questions, outputs that would not parse and agents looping. An OpenAI lead replied that early testers had used an earlier build and that the models are “by no means perfect.” Keep the previous model one setting away for the first weeks.

The decision itself is short. Default to Sol at medium. Send template-bound deliverables, legal review, terminal science and 3D or web builds to Astra. Keep Fable 5.2 for knowledge-heavy research, the hardest reasoning and visual work where its quality still shows. Measure cost per finished task, not price per token, and revisit the split once your own log has a month of data. If you are weighing the even cheaper tier for computer-use agents, the GPT-6.1 Terra guide covers that option.

Leave a Reply

Close Menu

About aiartimind

Hands-on guides to the AI tools creators actually use: Claude Code and coding agents, AI video and motion graphics, and AI agents that automate your work. Every workflow is tested before we publish it.