
GPT-6.2 Astra is OpenAI's new flagship, released 17 November 2026, and it is cheaper and smarter than GPT-6 Astra: $8/$40 per million tokens instead of $10/$50, with cached input down to $0.40. Independent testing from Artificial Analysis puts it second overall, behind Claude Fable 5.2, at about a sixth of Fable's cost per task.
The catch is that it guesses more when it doesn't know a fact (59% against 50% for GPT-6 Astra). If you already run GPT-6 Astra, switch. For support tickets, GPT-6.2 Sol matched it in my test at a quarter of the cost, and a grounded AI helpdesk teammate like eesel matters more than the model underneath.
What is GPT-6.2 Astra?
GPT-6.2 Astra is the successor to GPT-6 Astra, which launched in September. OpenAI shipped it on 17 November 2026 together with GPT-6.2 Sol, and the launch post calls Astra "our new frontier model for your hardest projects" and Sol "our efficient, versatile model for everyday work."

I build the integrations and API plumbing at eesel, so my first move with any new model is to call it from code and see what it does on real work. I did that within hours of launch: the gpt-6.2-astra model ID worked on my API key, and I ran it against the same kind of support tickets I used for the GPT-6.1 Sol review. The results are further down.
On availability, OpenAI says both models are live for Plus, Pro, Enterprise, and Edu users in ChatGPT Work and Codex, and on the API. Enterprise and Edu users get access once a workspace admin enables it. Pro 500 subscribers can run either model in Ultrafast mode, and OpenAI says Ultrafast is also coming to Pro 200, starting with Sol. The ChatGPT pricing guide covers what each plan costs.
What changed from GPT-6 Astra?
Three things changed in a way you'd notice on a bill or a benchmark: the price, the efficiency, and the writing style. The context window did not change.

Here are the specs from the model page, next to the old model:
| GPT-6 Astra | GPT-6.2 Astra | |
|---|---|---|
| Launch | 3 September 2026 | 17 November 2026 |
| Input / output (per 1M) | $10 / $50 | $8 / $40 |
| Cached input (per 1M) | $1.00 | $0.40 |
| Context window | 1,050,000 tokens | 1,050,000 tokens |
| Max input / max output | n/a | 922,000 / 128,000 |
| Knowledge cutoff | n/a | 18 May 2026 |
| Lowest reasoning effort | n/a | low (none is rejected) |
| AA Intelligence Index (max) | 57 | 62 |
| AA cost per task (max) | $6.24 | $4.00 |
The price cut is the easy part to read. OpenAI says GPT-6.2 Astra is 20% cheaper on input and output and 60% cheaper on cached input, and that it also uses fewer output tokens. On OpenAI's internal GDPval v2 benchmark, it scored 6.2 points higher than GPT-6 Astra while using 22% fewer output tokens.
The writing style is the part people are arguing about. OpenAI's migration guide says the model "tends to be more concise and direct by default" and suggests revisiting any "be concise" lines in your system prompt. That matters if your prompts were tuned to rein in the older model.

How much does GPT-6.2 Astra cost?
GPT-6.2 Astra costs $8 per million input tokens, $0.40 cached, and $40 per million output tokens at the Standard tier. Here is the full grid from OpenAI's pricing page, with GPT-6 Astra for comparison:
| Tier | GPT-6.2 Astra input | Cached input | Output | GPT-6 Astra input / output |
|---|---|---|---|---|
| Standard | $8.00 | $0.40 | $40.00 | $10 / $50 |
| Batch | $4.00 | $0.20 | $20.00 | $5 / $25 |
| Fast | $16.00 | $0.80 | $80.00 | $20 / $100 |
| Ultrafast (to 28 Feb 2027) | $24.00 | $1.20 | $120.00 | $60 / $300 |
| Ultrafast (from 1 Mar 2027) | $48.00 | $2.40 | $240.00 | n/a |
A few lines on that page change the real bill:
- Cache writes cost more than plain input. A 30-minute cache write is $10 per million tokens and a 12-hour write is $20. Reads are where you save.
- Long prompts cost more. Past 272,000 input tokens, input and cache rates double and output costs 1.5 times as much, for the whole request.
- Ultrafast doubles on 1 March 2027. It's 3 times the Standard rate until 28 February 2027, then 6 times. If you build on Ultrafast now, budget for that date.
- Background requests are cheaper. Eligible requests run 30% below Standard on a 2-hour window and 40% below on an 8-hour window.
- Flex isn't listed for GPT-6.2 Astra on the pricing page, unlike GPT-6 Astra.
The deeper breakdown of how these tiers stack up across the family lives in the GPT-6 Astra pricing post and the wider OpenAI API pricing guide.
Do the benchmarks hold up?
Mostly, yes, with two exceptions OpenAI didn't put in its charts.
OpenAI leads with Agents' Last Exam, a test of long, multi-step professional work, where it says GPT-6.2 Astra "sets a new high, scoring 5.2 points higher than GPT-6 Astra at less than a third of the cost." On Harvey's legal benchmark, it says Astra more than doubled Claude Fable 5.2's pass rate at about a sixth of the cost.
Artificial Analysis, which runs its own tests, mostly agrees. Its numbers at max effort:
| Model | AA Intelligence Index | Cost per task | Hallucination rate |
|---|---|---|---|
| Claude Fable 5.2 | 65 | $26.54 | 59% |
| GPT-6.2 Astra | 62 | $4.00 | 59% |
| Gemini 4 Carbon (high) | 60 | n/a | 11% |
| Claude Opus 5.5 | 59 | n/a | 50% |
| GPT-6 Astra | 57 | $6.24 | 50% |
| GPT-6.2 Sol | 57 | $1.01 | 55% |
The figures come from the AA model pages for GPT-6.2 Astra and GPT-6 Astra. The jump from 57 to 62 is real, and so is the cost drop. GPT-6.2 Sol now matches the old Astra's score at about a sixth of its cost per task, which says a lot about where the value sits in this family.
Two results are missing from OpenAI's charts:
- Coding didn't move. Artificial Analysis found GPT-6.2 Astra "flat with GPT-6 Astra" on its Coding Agent Index. OpenAI reports gains on its own coding tests, so treat coding claims as unproven until your own repo says otherwise.
- It guesses more. On AA-Omniscience, which checks whether a model answers or admits it doesn't know, GPT-6.2 Astra's hallucination rate rose from 50% to 59% at max effort, and from 45% to 54% at medium. Gemini 4 Carbon sits at 11% on the same test.
That second point is the one I'd weigh if you put this model in front of customers. A model that guesses on facts it doesn't know needs to be grounded in your own docs and told when to stop, which is the whole job of hallucination prevention in support.
The flashiest number came from the ARC Prize team, who said on X that GPT-6.2 Astra "is the first model to achieve a 100% score on ARC-AGI-3." Read the fine print: that was with a provider adapter, and the standard run scored 70.3%.
"GPT-6.2 Astra is the first model to achieve a 100% score on ARC-AGI-3."
What are early testers saying?
The reaction split hard. OpenAI's launch page carries quotes from early customers, mostly about token savings. Jay Hack at ClickUp said GPT-6.2 Astra edged out their production model in blind testing with "about 40% fewer tokens and 30% fewer review rounds."
Several well-known testers who had early access said the opposite, loudly:
"I will not be writing a full review of GPT-6.2 Astra / Sol. I had a terrible experience testing them. They were essentially unusable."
Dan Shipper's team at Every was more specific. They found the writing "a step back from Astra 6," saying it was trained to be so concise "that its writing is hard to understand," and that in real coding tasks it "seemed to stop too early frequently."
"We've been testing them for the last few weeks @every and, unfortunately, these models aren't great. Overall a disappointing release compared to Fable 5.2."
On Hacker News, where the launch thread passed 800 points and 500 comments, the mood was more practical. Price got the warmest reception:
"Seeing them keep prices low is awesome. Was worried for a while that it would be like the GPT5.x series where progressively the models just got more and more expensive."
And a question I think most teams should ask before paying for the top model:
"I have yet to find an application for Astra vs Sol where the former is noticeable better."
The "concise to a fault" complaint lines up with OpenAI's own migration notes, so I'd treat it as a real trait of the model. For support replies, short and direct is often what you want. For long documents, you'll want to tell it how much detail you expect.
How did GPT-6.2 Astra do on real support tickets?
All four setups I tested scored 15 out of 15, and the new Astra was about 17% cheaper per ticket than the old one. The differences showed up in small behaviors, not in pass rates.
I rebuilt the eval from my GPT-6.1 Sol review on 18 November 2026, using the Responses API:
- A policy doc for a fictional SaaS company: refund windows, a 5-business-day rule for duplicate charges, no address changes after shipping, no discount codes from agents, and "escalate anything not covered."
- One tool,
lookup_order, wired up with function calling. It returns canned order data, "not found" for unknown IDs, and a deliberate 503 timeout for one order. - 15 tickets covering refund math, an angry duplicate charge, a prompt injection, Spanish and German tickets, a vague "I want a refund," a broken tool, and an order ID with a typo (the letter O instead of a zero).
- Four setups: GPT-6.2 Astra at low and medium effort, GPT-6 Astra at medium, and GPT-6.2 Sol at medium. That's 60 runs, each graded by hand against the policy.
This is a small hand-built test, not a benchmark. It tells you how these models behave on clean support work, which is most support work, and it's the kind of check I'd run before trusting any model with a queue. OpenAI's agent evals tooling does the same thing at a larger scale.

| Setup | Score | Cost per 1,000 tickets | Avg. response time |
|---|---|---|---|
| GPT-6.2 Sol, medium | 15/15 | $1.42 | 3.2s |
| GPT-6.2 Astra, low | 15/15 | $5.74 | 3.7s |
| GPT-6.2 Astra, medium | 15/15 | $5.79 | 5.0s |
| GPT-6 Astra, medium | 15/15 | $6.98 | 4.4s |
Three things stood out once I read the replies side by side.
It finally asked about the typo. In my last test, not one of five setups noticed a customer typing A1O43 instead of A1043. This time, both GPT-6.2 Astra setups asked the customer to double-check the order ID, while still escalating. GPT-6 Astra and GPT-6.2 Sol escalated without asking. That's a small thing, but it's the difference between a one-message fix and a ticket sitting in a human queue.
It built links the tool never gave it. On the two order-status tickets, both GPT-6.2 models turned the tracking number into a ups.com/track link. GPT-6 Astra printed the number on its own. The link format was correct, but nothing in my tool data contained a URL. In a real helpdesk, I'd want a rule about which links an agent may create, because the next made-up link might not be a harmless one.
The savings on short tickets come from the price cut, not efficiency. The new Astra averaged 62 output tokens per ticket against 57 for the old one, and used almost no reasoning tokens on tickets this short. OpenAI's token-efficiency gains show up on long, multi-step tasks. On a support queue, expect roughly the 20% list-price cut and not much more.
The rest, from the prorated refund math ($990, correct in every setup) to refusing a fake "admin mode" discount request, was the same across all four. For support, the score doesn't separate these setups; the cost does.
What caught me out with prompt caching?
The 60% cached-input discount is the best part of this release for anyone running a support bot, and I almost missed it entirely.
I sent a 12,500-token help center prompt to GPT-6.2 Astra three times with the help center in the top-level instructions field, the way plenty of integrations are built. All three calls came back with 0 cached tokens and 0 cache writes, so each one paid full price. The same request on GPT-6 Astra cached normally from the second call.
When I moved the identical help center text into a developer message, GPT-6.2 Astra wrote it to cache on the first call and read 12,501 cached tokens on each call after that. OpenAI's prompt caching guide notes that top-level instructions can't hold an explicit cache breakpoint and suggests a developer message for reusable instructions. I didn't see the zero-cache behavior documented, so treat it as what I observed on launch day, and check your own cached_tokens before you assume the discount.

At list prices, an uncached call with that prompt costs about $0.10 in input alone. A cached read costs about $0.005, a 20x difference on every single ticket. For a bot answering thousands of tickets a day from the same help center, this one setting decides whether the release saves you money.
What else changes for developers?
If you call the API directly, the migration guide has a short list of breaking changes worth reading before you flip the model ID:
- Reasoning gets dropped if you edit history. Starting with GPT-6.2, the API drops reasoning items when it detects mid-conversation changes to the history, a model downgrade, or a change of end user or organization. OpenAI warns that "answer quality can decline" when that happens. Append new instructions; don't rewrite old ones.
noneeffort is rejected. If you usednoneorminimal, move tolow. OpenAI suggests starting new integrations atmedium.- Tool calling needs the Responses API. The model supports Chat Completions, but tools only work through Responses.
- Sampling settings are gone. Drop
temperature,top_p,logprobs, andtop_logprobs. - Expect check-ins on vague tasks. The guide says that when intent is unclear, the model "may propose a next step and wait for confirmation." For autonomous agents, give it room to make reasonable assumptions in the prompt.
None of this is unusual for a model upgrade, but the first one bites support integrations that rewrite the system prompt per turn to inject customer data. If that's you, restructure before you switch, or you'll pay more and get worse answers. The GPT-6.1 Sol post covers the earlier API changes in the same family.
What about safety and the cyber limits?
GPT-6.2 Astra keeps the "Critical" cybersecurity rating that made GPT-6 Astra the first model OpenAI rated that way, plus a "High" rating for biological and chemical capability. OpenAI says it is also the company's first externally released model to reach "High" on AI self-improvement.
In practice, that means tighter guardrails. OpenAI says it launched both models "with tighter safeguards for higher-risk cybersecurity assistance," and that these "also restrict some legitimate vulnerability research." Security teams that need fewer refusals are pointed to OpenAI Daybreak and GPT-6 Cyber, and OpenAI says it will bring the 6.2 models there later.
The system card is candid about two regressions. Both models "were more likely to omit known obstacles when reporting their work," such as a missing file or an unavailable tool. And GPT-6.2 Astra "showed more signs of evaluation awareness," meaning it more often suspected it was being tested, though OpenAI says that was flagged in fewer than 3% of turns.
The first one matters for support. An agent that quietly skips over a failed lookup is how a customer gets a confident wrong answer. In my test, all four setups did say when the order service timed out, but that was one ticket with a loud error. I'd still put observability on any agent running this model, so you can see what it tried and what failed.
Should you switch to GPT-6.2 Astra?
It depends on which model you're on today, and for most teams the answer isn't Astra at all.
| If you use | My take |
|---|---|
| GPT-6 Astra | Switch. It's cheaper per token and per task, scores higher, and keeps the same context window. Fix caching and history edits first. |
| GPT-6.1 Sol or GPT-6.2 Sol | Stay on Sol for support and everyday work. It matched Astra on my tickets at about a quarter of the cost. |
| Claude Fable 5.2 | Try Astra on your hardest workloads. It scores 3 points lower on AA at about a sixth of the cost per task. |
| Claude Opus 5.5 | Astra scores higher on AA. Run your own tests, since testers report big differences in feel. |
| Any model, for customer-facing answers | Weigh the higher guessing rate. Grounding and escalation rules matter more than the upgrade. |
The pattern from GPT-6.1 Sol continues here. OpenAI's mid-tier keeps closing the gap on the flagship, so Astra earns its price on long, hard, multi-step work: financial models, legal research, science workflows. A refund request doesn't need it. If you're shopping outside OpenAI, the GPT-6 Astra alternatives roundup still applies.
What does GPT-6.2 Astra mean for a support team?
A better model is better infrastructure. It isn't a better support agent on its own. The model doesn't know your refund policy, can't see your helpdesk, and, per the Omniscience numbers, will guess more often than its predecessor when it doesn't know something. Everything that makes it useful on a real queue sits around the model.
That's the layer eesel builds. eesel is a set of AI teammates you hire for specific jobs, an AI helpdesk teammate for your queue and an AI blog writer for content, and each arrives with the integrations, knowledge, and guardrails for its role. The model is the engine; the teammate is who you hire to drive it. You can also drive it from code: with the eesel CLI, a coding agent can upload approved help articles and macros, adjust the agent's instructions, and run test questions against them before anything goes live. Connecting the helpdesk itself still needs an admin to approve it.
Two eesel customers show how that works. SE Ranking runs one eesel agent per product across three products on Zendesk, and handled 4,650 conversations in a month. The agents search about 16,800 pages of help center and site content before answering, and they're told never to describe a menu or button they didn't find there. That rule targets the same hallucination problem the Omniscience numbers describe.
smava, a German loan comparison platform, takes the cautious route at higher volume. Its eesel agents worked through 27,000 Zendesk tickets in a month, categorizing them and drafting replies word for word from about 820 macros and articles, and eesel never sends a reply itself. A person approves every draft. When a model guesses more, a review step like that is the cheapest insurance you can buy.
If you're weighing this release for support, the more useful question than "Astra or Sol?" is whether you can test the agent on your own past tickets before it goes live. A benchmark can't tell you that, and neither can a launch post. The best AI helpdesk software roundup compares the tools that do this.
Try eesel
If GPT-6.2 Astra got you thinking about AI on your support queue, the part that decides whether it works is the teammate around the model. eesel plugs into the helpdesk you already use, learns from your past tickets and help center, and lets you run it against your real historical tickets so you can read its answers before it touches a live customer. When a new model lands, you get the upgrade without rebuilding your prompts, caching, or escalation rules yourself.

You can try eesel free on a slice of your queue, or compare it with using ChatGPT directly if you're still deciding whether to build it yourself.
Frequently Asked Questions
What is GPT-6.2 Astra?
gpt-6.2-astra.How much does GPT-6.2 Astra cost?
GPT-6.2 Astra vs GPT-6 Astra: what changed?
Is GPT-6.2 Astra better than Claude Fable 5.2?
Should I use GPT-6.2 Astra or GPT-6.2 Sol?
Is GPT-6.2 Astra good for customer support?
How do I get access to GPT-6.2 Astra?
gpt-6.2-astra. Enterprise and Edu users get it once a workspace admin turns it on. It is not on the free tier.