Disclosure: this article contains one referral link, labeled where it appears. If you sign up through it, the author may receive a referral reward.
On November 3, OpenAI published a post about using its models for physical-product engineering. Tucked inside was a chart: an unnamed “internal model” scoring 0.875 on a benchmark called BenchCAD 2.0, while GPT-6 Astra, its flagship at the time, topped out at 0.594.
OpenAI gave the model no name and no launch date. The internet supplied guesses for both.
By mid-November the pile-up included screenshots of Codex usage pages with a line for a model nobody had announced, quota entries from a cloud console, a viral claim that a hidden row in OpenAI’s biology benchmark showed 89%, and a Minecraft-style demo of unknown origin. On November 17, OpenAI shipped GPT-6.2 Astra and GPT-6.2 Sol.
That gives us something rare: a rumor cycle with a verdict. Below, the leaks get graded. Then comes the part that touches your bill.
The short version: the leaks got the name right, the price half right and the loudest number unverified. OpenAI’s and Anthropic’s flagships now list at the same $8 / $40 per million tokens, which moves the comparison that matters from cost per token to cost per resolved task. And the durable answer to model churn isn’t better forecasting. It’s a thin layer you control and a small test set of your own.
The pre-launch timeline builds on AI Economy’s piece in Inside AI, “GPT-6.2 Astra Is Coming Soon — Major Rumors.” Launch details come from The Decoder’s coverage of OpenAI’s announcement, Anthropic’s pricing documentation and BenchCAD’s public leaderboard. Vendor-reported numbers are labeled as such.
Fourteen days from OpenAI’s first hint to launch
Codex users had been posting usage-page screenshots with a separate gpt-6.2-astra line since around November 1. OpenAI’s own first hint came two days later, and the dates that followed look like this:
November 3. The BenchCAD 2.0 chart: an unnamed internal model at 0.875, GPT-6 Astra at 0.594.
November 6. OpenAI and the biotech company Ligo publish BioBasicsBench, 100 wet-lab data-interpretation tasks. At the xhigh reasoning setting, GPT-6 Astra earns 66.7% of the available credit. The same day, a viral post claims a hidden “gpt-6.2-astra” row scores 89%.
November 9. Anthropic releases Claude Fable 5.2 and cuts list prices by 20%, from $10 / $50 to $8 / $40 per million input / output tokens.
November 16. A report on enjoy.dev gathers unauthenticated screenshots of Codex usage pages labeled “GPT-6.2 Astra,” plus purported cloud quota entries for Astra and Sol at 6.2.
November 17. OpenAI releases GPT-6.2 Astra at $8 / $40 and GPT-6.2 Sol at $2 / $10, in ChatGPT Work, Codex and the API.
The scorecard
Six claims were in circulation before launch. Here is how each one held up.
Held up
**OpenAI has a model newer than GPT-6 Astra. **The chart came from OpenAI itself, and GPT-6.2 Astra arrived two weeks later.
**It’s called GPT-6.2 Astra, and there’s a Sol to go with it. **The usage-page labels said gpt-6.2-astra, and the purported quota entries listed both Astra and Sol at 6.2. The API names that shipped on November 17 are gpt-6.2-astra and gpt-6.2-sol. Each screenshot was unauthenticated and easy to doubt on its own. Together they pointed the right way.
Half right
The price will land near $6 in and $30 out, with a cache discount of 95% or better. This was a wish from a pre-launch Medium piece, not a leak, but it makes a fair yardstick. The list price landed at $8 / $40, a 20% cut from the previous $10 / $50. The cache discount reached the floor of the wish: $0.40 per million cached tokens against an $8 input rate is 95% off. (The old rate, $1 against $10, was 90%.)
It should at least beat Opus 5.5, and ideally Fable 5.2. On the Artificial Analysis Intelligence Index, Astra scores 62, ahead of Claude Opus 5.5 (59) and behind Fable 5.2 (65). Epoch AI’s index ties Astra and Fable 5.2 at 174, though Epoch found Astra weaker on real-world research tasks. On BenchCAD’s board for custom harnesses, Astra’s 0.825 beats Opus 5.5 (0.653) and sits just under Fable 5.2 (0.835), with each model run inside its own vendor’s harness. A near tie at the top, not a takeover.
Unverified
The unnamed BenchCAD model at 0.875 is GPT-6.2 Astra. We found no OpenAI statement linking the two. BenchCAD’s leaderboard, citing OpenAI’s launch post, lists GPT-6.2 Astra at 0.825 on BenchCAD 2.1, a newer version of the benchmark, and notes that scores from the two versions aren’t comparable. “Something newer existed” is proven. “That was the model in the chart” is not.
A hidden GPT-6.2 Astra row scores 89% on BioBasicsBench. The claim traveled well because half of it was checkable: the 67% it quoted for GPT-6 Astra is OpenAI’s real 66.7%. The new row was the only part nobody could check. OpenAI’s published table covers seven models, none of them GPT-6.2, and we found no OpenAI source for the 89%.
Independent testing did show something nearby: Vals AI ranks Astra first on its Science Index, which measures how well models interpret biological data and run experiments. That makes a strong biology result plausible. It doesn’t make the 89% real.
What the pattern says
One cycle proves no rule, but the ordering is worth keeping as a prior. The signals closest to OpenAI’s own publications and systems held up: the chart and the model names. The viral, spreadsheet-shaped number is still unconfirmed, and the demo clip can’t be tested at all. Next time, weigh the first kind of signal most, treat a lone number as entertainment, and test whatever you can actually call.
Price parity on paper, not on the invoice
List prices per million tokens as of November 19, input / cached input / output:
GPT-6.2 Astra: $8 / $0.40 / $40
Claude Fable 5.2: $8 / $0.20 / $40
GPT-6 Astra, previous: $10 / $1 / $50
Claude Opus 5.5: $4 / $0.20 / $20
GPT-6.2 Sol and Claude Sonnet 5.5: $2 / $0.10 / $10 each
OpenAI’s cut is 20% on input, 20% on output and 60% on cached input. At the top of each lineup the two vendors now match on the numbers every pricing page leads with. Three things below that line decide the invoice.
**1. Cache mechanics. **Both vendors price cache reads far below fresh input, and Fable 5.2’s are half of Astra’s. Cache writes are a separate line item: Anthropic lists $10 per million tokens for a five-minute entry and $16 for an hour, against an $8 base input rate. An agent that re-sends the same long prefix on every turn lives or dies by these lines, so read each vendor’s current cache rules against your own traffic.
**2. Context thresholds. **Anthropic’s documentation says a 900K-token request on Fable 5.2 is billed at the same per-token rate as a 9K-token one. OpenAI’s earlier Astra page carried a 272K-token threshold with higher long-context rates above it. Third-party breakdowns say GPT-6.2 Astra keeps that threshold and bills the whole request at the higher rate, not just the excess. Confirm the current rule before you point an agent at an entire repository.
**3. Tokens per task. **Tokens per job vary by multiples between models, which makes the per-token price only half the story. OpenAI’s own BioBasicsBench table shows how wide the spread gets: at the same reasoning setting, GPT-5.2 spent 27,620 output tokens per task and earned 31.2% of the credit, while GPT-6 Astra spent 4,704 and earned 66.7%. Almost six times fewer tokens for more than double the credit.
The launch coverage points the same way. Vals AI puts GPT-6.2 Astra at $10.68 per task in its index against $21.28 for GPT-6 Astra, a drop bigger than the 20% price cut alone would explain, and reports that Astra averaged 91,000 output tokens per task, the fewest in its top ten.
OpenAI claims more: on Agents’ Last Exam, Astra beats Fable 5.2 by 5.5 points at about 5% of the cost, and on the legal benchmark Harvey LAB-AA it more than doubles Fable 5.2’s pass rate at about one-sixth of the cost. Those two are vendor-reported, single-benchmark results, so treat them as claims to test. The mechanism behind them is real, though. When per-token prices match, the model that finishes in fewer tokens and fewer retries wins on the invoice.
Try the arithmetic on a hypothetical support agent that resolves a ticket in ten model calls. Each call sends a 40,000-token prompt, 90% of it a cached prefix, and writes back 1,500 tokens. Per ticket that is 360,000 cached input tokens, 40,000 fresh input tokens and 15,000 output tokens. At list prices:
GPT-6.2 Astra: $0.14 cached + $0.32 fresh + $0.60 output = $1.06
GPT-6 Astra at its old prices: $0.36 + $0.40 + $0.75 = $1.51
Claude Fable 5.2: $0.07 cache hits + $0.32 fresh + $0.60 output = $0.99
Fable’s figure assumes the fresh tokens are billed as ordinary input. Writing them to a five-minute cache at $10 per million would add $0.08, and cache rules on the OpenAI side deserve the same check. Across those variations the two flagships land within about 7% of each other at identical token counts, and the new Astra is about 30% cheaper than the old one.
The real bill gets settled afterward. Suppose one model resolves 85 of 100 tickets and another resolves 65, both at $1.06 per attempt. That is $1.25 versus $1.64 per resolved ticket, 31% more. Or suppose a model writes 60% more output, 24,000 tokens instead of 15,000. The attempt rises from $1.06 to $1.42, 34% more, before a single retry.
Cost per resolved task = average cost per attempt ÷ success rate.
That formula is why a per-token price table can’t tell you which model is cheaper for you. Your own tasks can.
Why “wait for the next model” is the wrong plan
Look at how much moved in two weeks.
Before November 9, GPT-6 Astra and Claude Fable 5.1 both listed at $10 / $50. On November 9, Anthropic cut Fable by 20% and OpenAI’s flagship became the expensive option. On November 17, OpenAI cut Astra by the same 20%, cut cached input by 60% and left Sol at $2 / $10. The price relationship between the two flagships changed twice in eight days.
Quality leadership is just as unsettled. Fable 5.2 leads the Artificial Analysis index (65 to 62) and tops Vals’ overall ranking. Astra leads Artificial Analysis’ 3D-design and robotics scores and Vals’ science index. Epoch has the two tied. On Artificial Analysis’ coding-agent index, Astra is flat against the model it replaced. Which one is “best” depends on your workload, and the answer changes on a schedule you don’t control.
Anyone who paused a decision to wait for the rumored model spent two weeks learning nothing about their own workload. Anyone who could swap models in an afternoon lost nothing and could run the same test on launch day. You can’t forecast the leaderboard, but you can make changing your mind cheap. Three habits do most of the work:
1.Keep the model name, base URL and API key in configuration, not in code. Many vendors and gateways accept the OpenAI chat-completions format, so one client can address several models. Treat the config switch as step one. Prompts, tool-calling behavior and output length still differ from model to model, so fence those differences into one place you can find after a switch.
**2.Keep a test set made of your own work. **Twenty to fifty real cases, each with an automatic pass/fail check: tickets from your support queue, contracts your users uploaded, failing tests your coding agent was handed. A leaderboard answers a question about the model. Your test set answers a question about your product.
3.Count cost per resolved task, not cost per token. Log tokens and outcomes on every run, and use the formula above.
A model-agnostic layer in an afternoon
Here is the whole idea in under fifty lines of Python. It runs the same tasks against several models through one OpenAI-compatible endpoint and reports pass rate and cost per passing task. Fill TASKS with your own cases and PRICES with your own rates.
pip install openai python-dotenv
import os
from dotenv import load_dotenv
from openai import OpenAI
load_dotenv() # reads RELAYROUTER_API_KEY and RELAYROUTER_BASE_URL from .env
client = OpenAI(
api_key=os.environ["RELAYROUTER_API_KEY"],
base_url=os.getenv("RELAYROUTER_BASE_URL", "https://api.relayrouter.app/v1"),
)
USD per million tokens (input, output). Use the rates on your own invoice or console.
Cached-input discounts and surcharges are ignored to keep this short.
PRICES = {
"gpt-6.2-astra": (8.00, 40.00),
"claude-fable-5-2": (8.00, 40.00), # use the exact name your endpoint lists
}
Each task: a prompt plus a check that returns True when the answer is acceptable.
TASKS = [
("Reply with the invoice total as a number only: 'Total due: $1,284.50 (net 30)'",
lambda out: "1284.5" in out.replace(",", "")),
("Is this review positive or negative? Reply with one word: 'The update broke my export.'",
lambda out: "negative" in out.lower()),
# ...add 20 to 50 real tasks from your own product
]
RUNS = 3 # repeat each task, because model output varies
for model, (price_in, price_out) in PRICES.items():
cost, passed, attempts = 0.0, 0, 0
for prompt, check in TASKS:
for _ in range(RUNS):
reply = client.chat.completions.create(
model=model,
messages=[{"role": "user", "content": prompt}],
)
usage = reply.usage
cost += (usage.prompt_tokens * price_in
+ usage.completion_tokens * price_out) / 1e6
passed += bool(check(reply.choices[0].message.content or ""))
attempts += 1
per_pass = cost / passed if passed else float("inf")
print(f"{model}: pass rate {passed / attempts:.0%}, "
f"cost per attempt ${cost / attempts:.4f}, cost per pass ${per_pass:.4f}")
Two details matter. The model names must match what your endpoint lists, and the prices must come from your own console or invoice, because a gateway or reseller sets its own rates. Keep the key in .env and out of Git.
The script assumes every model you want to compare speaks the same API format. If you would rather not wire up a separate SDK per vendor, a gateway is one way to get there. RelayRouter is a third-party gateway that exposes one OpenAI-compatible API for models from several providers (its site names GPT, Claude, Gemini, DeepSeek and Qwen), bills by usage and keeps keys, usage and costs in one console. Its public quickstart repository on GitHub has runnable Python, JavaScript and PowerShell examples built on three settings: an API key, a base URL and a model name. The script above reads the same key and base-URL variable names, so one .env file serves both.
At the time of writing, the repository’s announcement feed lists gpt-6.2-astra and gpt-6.2-sol as launched on November 18. Your console’s model list is the source of truth for what your account can call and at what price. To get a key, you can register here (referral link), then fill in .env, add twenty of your own tasks and run the comparison.
A gateway doesn’t remove the rest of the work:
**Prompts and tools still need adapting. **The same request can behave differently across models.
**It adds a third party to your data path. **Read the terms and data-handling policy before sending anything sensitive, and use a separate key for each project.
**Prices and catalogs can differ from vendor lists. **Compare the invoice, not the vendor’s pricing page.
Test the endpoint you will ship. Run the evaluation against the exact base URL production will call, so the results reflect that route’s real behavior.
Caveats before you switch anything
**Most headline numbers are OpenAI’s own. **Independent measurements are more mixed. Artificial Analysis shows no gain for Astra on its coding-agent index, Epoch found it behind Fable 5.2 on real-world research tasks, and Vals ranks it seventh overall, with 11th and 30th place on its two legal benchmarks.
Hallucination is still a live issue. On an Artificial Analysis test of very hard factual questions, Astra guessed instead of saying it didn’t know 59% of the time at maximum effort, and Sol 55%. Those questions are unusually hard, so this isn’t an everyday rate, but it is a reason to keep checks in the loop.
**Safeguards changed. **OpenAI says both models reach “Critical” for cybersecurity in its Preparedness Framework, and the stricter safeguards that come with that can also block legitimate security testing.
Read the conditions behind a number. OpenAI’s cybersecurity figures were produced with safeguards and classifiers turned off, and BenchCAD notes that scores from different harnesses or versions aren’t comparable.
The durable lesson
The rumor mill got the name right, the existence right, the price half right and its loudest number unverified. That is a decent record for a process with no editors.
But the lesson isn’t really about Astra. In a market where the price relationship between two flagships changes twice in eight days, and the quality ranking depends on which benchmark you open, “which model?” stops being a decision you make once. It becomes a question your system should answer on demand, with a config change and an evaluation run in place of a roadmap meeting.
Build the thin layer. Keep your own tasks. Count cost per resolved task. The next leak is already on its way, and with those three habits it costs you an afternoon of testing instead of a quarter of planning.
Sources
The Decoder: OpenAI launches GPT-6.2 Astra and Sol with lower API prices and some benchmark gains: launch pricing, plus benchmark figures from
OpenAI, Artificial Analysis, Epoch AI and Vals AI.
OpenAI: Introducing GPT-6.2 Astra and Sol
OpenAI: Accelerating engineering for the physical world: the November 3
BenchCAD 2.0 chart.
BenchCAD leaderboard and BenchCAD news: benchmark versions, harnesses and comparability notes.
Anthropic: Claude pricing documentation: Fable 5.2, Fable 5.1, Opus 5.5 and Sonnet 5.5 prices, cache rules and long-context billing.
R&D World: OpenAI’s BioBasicsBench tests AI on everyday wet-lab data
AI Economy, “GPT-6.2 Astra Is Coming Soon — Major Rumors,” Inside AI on Medium: the pre-launch rumor timeline, the price wish and the BioBasicsBench table.
RelayRouter API quickstart on GitHub
Prices and benchmark figures are as of November 19, 2026. Check each vendor’s pricing page before you decide.





Top comments (0)