GPT-6.2 Astra: what's new, what it costs, and who should switch

Rama Adi
Written by

Rama Adi

Katelin Teen
Reviewed by

Katelin Teen

Last edited November 17, 2026

Expert Verified
Hand-drawn illustration of one person holding a glowing star-shaped AI model while another hands over a small price tag, for a guide to OpenAI's GPT-6.2 Astra
TL;DR

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."

The OpenAI launch page for GPT-6.2, showing the words Astra and Sol on either side of GPT-6.2 against a dark starfield, as taken from the announcement by OpenAI
The OpenAI launch page for GPT-6.2, showing the words Astra and Sol on either side of GPT-6.2 against a dark starfield, as taken from the announcement by OpenAI

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.

The GPT-6.2 Astra model page on the OpenAI developer docs, showing $8 input and $40 output pricing, a 1,050,000-token context window, 128,000 max output tokens and a May 18, 2026 knowledge cutoff, captured from OpenAI Developers
The GPT-6.2 Astra model page on the OpenAI developer docs, showing $8 input and $40 output pricing, a 1,050,000-token context window, 128,000 max output tokens and a May 18, 2026 knowledge cutoff, captured from OpenAI Developers

Here are the specs from the model page, next to the old model:

GPT-6 AstraGPT-6.2 Astra
Launch3 September 202617 November 2026
Input / output (per 1M)$10 / $50$8 / $40
Cached input (per 1M)$1.00$0.40
Context window1,050,000 tokens1,050,000 tokens
Max input / max outputn/a922,000 / 128,000
Knowledge cutoffn/a18 May 2026
Lowest reasoning effortn/alow (none is rejected)
AA Intelligence Index (max)5762
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.

Hand-drawn before and after comparison of GPT-6 Astra and GPT-6.2 Astra: price $10/$50 to $8/$40, cached input $1.00 to $0.40, Artificial Analysis Intelligence Index 57 to 62, cost per task $6.24 to $4.00, and guessing when unsure 50% to 59%, with the last value circled
Hand-drawn before and after comparison of GPT-6 Astra and GPT-6.2 Astra: price $10/$50 to $8/$40, cached input $1.00 to $0.40, Artificial Analysis Intelligence Index 57 to 62, cost per task $6.24 to $4.00, and guessing when unsure 50% to 59%, with the last value circled

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:

TierGPT-6.2 Astra inputCached inputOutputGPT-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.00n/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:

ModelAA Intelligence IndexCost per taskHallucination rate
Claude Fable 5.265$26.5459%
GPT-6.2 Astra62$4.0059%
Gemini 4 Carbon (high)60n/a11%
Claude Opus 5.559n/a50%
GPT-6 Astra57$6.2450%
GPT-6.2 Sol57$1.0155%

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:

  1. 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.
  2. 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:

Hacker News

"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:

Hacker News

"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.

Hand-drawn bar chart of cost per 1,000 test tickets: GPT-6.2 Sol medium $1.42, GPT-6.2 Astra low $5.74, GPT-6.2 Astra medium $5.79, and GPT-6 Astra medium $6.98, with a note that all four scored 15/15
Hand-drawn bar chart of cost per 1,000 test tickets: GPT-6.2 Sol medium $1.42, GPT-6.2 Astra low $5.74, GPT-6.2 Astra medium $5.79, and GPT-6 Astra medium $6.98, with a note that all four scored 15/15
SetupScoreCost per 1,000 ticketsAvg. response time
GPT-6.2 Sol, medium15/15$1.423.2s
GPT-6.2 Astra, low15/15$5.743.7s
GPT-6.2 Astra, medium15/15$5.795.0s
GPT-6 Astra, medium15/15$6.984.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.

Hand-drawn two-panel comparison for GPT-6.2 Astra with the same 12,500-token prompt: with the help center in instructions, three calls each show 0 cached at $0.10 per call; with the help center in a developer message, the first call writes and the next two read 12,501 cached tokens at $0.005 per cached call
Hand-drawn two-panel comparison for GPT-6.2 Astra with the same 12,500-token prompt: with the help center in instructions, three calls each show 0 cached at $0.10 per call; with the help center in a developer message, the first call writes and the next two read 12,501 cached tokens at $0.005 per cached call

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.
  • none effort is rejected. If you used none or minimal, move to low. OpenAI suggests starting new integrations at medium.
  • 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, and top_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 useMy take
GPT-6 AstraSwitch. 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 SolStay on Sol for support and everyday work. It matched Astra on my tickets at about a quarter of the cost.
Claude Fable 5.2Try Astra on your hardest workloads. It scores 3 points lower on AA at about a sixth of the cost per task.
Claude Opus 5.5Astra scores higher on AA. Run your own tests, since testers report big differences in feel.
Any model, for customer-facing answersWeigh 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.

The eesel activity view filtered to a Zendesk instance, listing resolved and pending conversations with their ticket numbers
The eesel activity view filtered to a Zendesk instance, listing resolved and pending conversations with their ticket numbers

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 is OpenAI's flagship model, released on 17 November 2026 alongside GPT-6.2 Sol. It replaces GPT-6 Astra as OpenAI's most capable model, with a 1,050,000-token context window, lower token prices, and better results on professional work like documents, spreadsheets, and slides. The API model ID is gpt-6.2-astra.
How much does GPT-6.2 Astra cost?
On the API, GPT-6.2 Astra costs $8 per million input tokens, $0.40 per million cached input tokens, and $40 per million output tokens at the Standard tier, per OpenAI's pricing page. Batch halves that and Fast mode doubles it. In my support-ticket test it worked out to about $5.79 per 1,000 short tickets. The OpenAI API pricing guide covers the rest of the catalog.
GPT-6.2 Astra vs GPT-6 Astra: what changed?
GPT-6.2 Astra is 20% cheaper per token, 60% cheaper on cached input, and scores 62 against 57 on the Artificial Analysis Intelligence Index at roughly two thirds of the cost per task. The catch is factual guessing: its hallucination rate on AA-Omniscience rose from 50% to 59% at max effort. The GPT-6 Astra review covers the older model in depth.
Is GPT-6.2 Astra better than Claude Fable 5.2?
Not on overall intelligence. Artificial Analysis puts Claude Fable 5.2 at 65 and GPT-6.2 Astra at 62, but Astra costs about $4 per benchmark task against Fable's $26.54. OpenAI reports Astra ahead on Agents' Last Exam and legal work. If price per task matters, Astra wins; if you need the top score, Fable still leads.
Should I use GPT-6.2 Astra or GPT-6.2 Sol?
For most support, routing, and everyday agent work, GPT-6.2 Sol. In my test both models scored 15 out of 15 tickets, and Sol cost about a quarter as much at $1.42 per 1,000 tickets. Pick Astra for long, hard projects like financial models, legal research, or science work. The GPT-6.1 Sol review covers the Sol line's earlier tests.
Is GPT-6.2 Astra good for customer support?
It handles support tickets well: it followed refund rules, refused a prompt injection, and admitted when a tool failed. Its higher guessing rate on unknown facts means it needs a grounding layer, tests on your own past tickets, and clear escalation rules. An AI helpdesk agent like eesel handles that layer on top of the model.
How do I get access to GPT-6.2 Astra?
GPT-6.2 Astra is available to Plus, Pro, Enterprise, and Edu users in ChatGPT Work and Codex, and on the API as gpt-6.2-astra. Enterprise and Edu users get it once a workspace admin turns it on. It is not on the free tier.

Share this article