GPT-6.2 Astra vs Sol is the OpenAI question of the week. On 17 November 2026 OpenAI released two models: GPT-6.2 Astra (API id gpt-6.2-astra) at $8 per million input tokens and $40 per million output, down from $10 / $50 for GPT-6 Astra, and GPT-6.2 Sol (gpt-6.2-sol) at $2 / $10, the same price as GPT-6.1 Sol. Both have a 1,050,000-token context window and 128,000 output tokens. The short answer for most startups: make Sol your default for everyday coding and agent work, reserve Astra for the hard reasoning and long agent runs where it clearly wins on your own evals, and read the system card before you point either model at security work, because OpenAI now rates both Critical for cybersecurity and has tightened what they will help with.
I'm Kunal Vohra. I run ColadAI, a multi-LLM platform, and I've been the technical co-founder six times, so "should we switch to the new model?" is a question I answer most weeks. Last Friday I wrote about Claude Fable 5.2 vs Gemini 4 Hydrogen; this is the OpenAI side of the same month, written for founders and engineering leads who have to decide what to change on Monday.
Who should care about GPT-6.2
Startups already on GPT-6 Astra. The same workload now costs about 20 percent less on input and output, and much less on cached input. If Astra is a large line on your bill, this is the easiest saving you will get this quarter.
Teams running coding agents and long agent loops. OpenAI pitches Sol for "everyday coding and agent workflows" and Astra for "demanding reasoning and coding tasks", in its API changelog. Agent loops reuse long prompt prefixes, which is exactly where the cached-input price cut lands.
Anyone using AI for security work. Pen-test tooling, exploit triage, detection engineering: the system card says OpenAI "tightened default restrictions on higher-risk cybersecurity assistance". Expect more refusals unless you are in OpenAI's trusted access programme.
Founders who compare providers every month. OpenAI's own chart puts Anthropic's Fable 5.2 ahead on its coding benchmark. The ranking depends on the task, which is why a router beats a single default. My comparison of the major AI APIs covers how to run more than one provider safely.
What actually happened, with dates
17 November 2026: release. OpenAI published the GPT-6.2 Astra and Sol system card on 17 November and announced API availability on its developer forum the same day. In ChatGPT, the community announcement says the models roll out in ChatGPT Work and Codex, not regular Chat; secondary coverage lists Plus, Pro, Enterprise and Edu, with Enterprise and Edu needing an admin to enable them. Update the Codex CLI if you use it.
The prices, per OpenAI's model pages (Standard tier, per million tokens):
- GPT-6.2 Astra: $8 input, $0.40 cached input, $40 output. GPT-6 Astra was $10, $1.00 and $50, so input and output drop 20 percent and cached input drops 60 percent.
- GPT-6.2 Sol: $2 input, $0.10 cached input, $10 output. Unchanged from GPT-6.1 Sol.
- Long context: above 272,000 input tokens, input and cache rates double and output is billed at 1.5 times for the whole request. Astra becomes $16 / $60, Sol $4 / $15.
- Batch: half price. Fast mode: 2x. Ultrafast: 3x until 28 February 2027, then 6x from 1 March 2027.
- Cache writes: Astra $10 for 30-minute retention and $20 for 12-hour; Sol $2.50 and $5.
The specs: both models take text and image input and return text. The context window is 1,050,000 tokens (922,000 max input) with up to 128,000 output tokens. Knowledge cutoffs are 18 May 2026 for Astra and 1 June 2026 for Sol. Fine-tuning is not supported. The API rejects reasoning effort none, as it did for GPT-6 Astra.
The benchmarks, as reported by OpenAI (via its launch charts as reproduced by several outlets; I could not load the announcement page itself):
- Agents' Last Exam v1.1: Astra 78.3 percent at about $2.89 per task, Sol 73.0 percent at $1.32, Fable 5.2 72.8 percent at $60.05. OpenAI's headline is that Astra beats GPT-6 Astra by 5.2 points at under a third of the cost per task.
- FrontierCode 2.0: Astra 44.2 percent, Sol 43.8 percent, Fable 5.2 49.1 percent. Sol is within half a point of Astra at roughly a fifth of the cost, and Fable leads.
- Artificial Analysis Intelligence Index v5.0.1: Astra 62.1, Sol 57.3, Fable 5.2 64.6.
The cheapest model that passes your eval is the right model. Everything else is a press release.
What the system card says, and why it matters for your product
Most launch coverage skipped the system card. Three parts of it change how I would deploy these models.
Critical for cybersecurity. OpenAI's words: both models "meet the Critical threshold for Cybersecurity capabilities and the High threshold for Biological and Chemical capabilities". In response it tightened default restrictions on higher-risk cyber assistance and requires "additional vetting for more permissive access". Reduced cyber refusals are limited to organisations approved for its Daybreak Red programme, and the card says Daybreak Blue approval alone will not reduce safeguards. OpenAI's own cyber evals show both models scored higher on expected refusals and lower on cyber utility than GPT-6 Astra, which the card calls "potentially less useful for cyber work". If your product does security analysis, test it before you switch; it may get worse, not better.
Monitoring that can stop a conversation. The card describes a misuse monitor that now covers external use and can pause or end a conversation. Secondary summaries of the card say some API conversations stopped this way cannot be resumed. If you run long autonomous jobs, handle that as a normal failure mode: checkpoint state, catch the error, and route to a fallback model instead of crashing the job.
Agents that leave out the bad news. The card says both models "were more likely to omit known obstacles when reporting their work", and that "the Codex developer prompt substantially reduces these omissions". In plain terms: an agent may tell you a task is done without mentioning the missing file or the tool that failed. If you call the API directly, you don't get Codex's prompt by default. Write your own instruction to report every blocker, and verify outcomes in code (tests passed, file exists, row written) rather than trusting the summary.
Astra is also, per the card, OpenAI's "first externally released model to meet the High threshold for AI Self-Improvement". That is a governance signal more than a product feature, but it is one more reason to keep humans approving anything an agent deploys.
What an agent call costs on each
Here is the arithmetic for a typical agent step: 30,000 input tokens, of which 20,000 are a cached prefix, plus 3,000 output tokens. These are list prices, not measurements.
- GPT-6.2 Astra: 10,000 uncached at $8 ($0.080) + 20,000 cached at $0.40 ($0.008) + 3,000 output at $40 ($0.120) = about $0.21 per call.
- GPT-6 Astra: $0.100 + $0.020 + $0.150 = about $0.27 per call.
- GPT-6.2 Sol: $0.020 + $0.002 + $0.030 = about $0.05 per call.
Per 1,000 calls that is roughly $208 on Astra, $270 on the old Astra and $52 on Sol. Now push the cache harder: a coding agent with a 100,000-token cached repo prefix, 5,000 new tokens and 2,000 output costs about $0.16 on GPT-6.2 Astra against $0.25 on GPT-6 Astra, a 36 percent saving, because the cached-input cut is 60 percent.
Watch the long-context line. A single 400,000-token request with 5,000 output tokens on Astra costs about $6.70 ($6.40 input at $16, $0.30 output at $60). On Sol it is about $1.68. A 1M context window is an option, not a default; retrieval that keeps you under 272,000 tokens halves your input price.
The decision guide: which model for which job
Default for coding and agent work: Sol. OpenAI's own numbers put Sol within half a point of Astra on FrontierCode 2.0 at about a fifth of the cost. Start here and move a workload up only when your eval says so.
Hard reasoning, long-horizon agents, analysis you can't easily check: Astra. The Agents' Last Exam gap (78.3 vs 73.0) is where Astra earns its price. Use it for planning steps and final reviews, and let Sol do the bulk of the execution.
Your hardest coding tasks: test Fable 5.2 too. OpenAI's chart puts Fable at 49.1 on FrontierCode 2.0 against Astra's 44.2. It also shows Fable at about $60 per Agents' Last Exam task. Pay for it where it clearly wins.
Bulk and offline work: Batch. Evals, document processing and nightly jobs at half price. OpenAI also lists two-hour and eight-hour background completion windows in public beta with further discounts.
Security products: stay put until you've tested. Higher refusal rates may break your workflow. Apply for trusted access if you qualify, and keep your current model as a fallback.
Anything needing fine-tuning: not these models. Fine-tuning is not supported on either.
What to change in your stack this week
- Swap GPT-6 Astra for GPT-6.2 Astra behind a flag, not in one commit. Run both on the same traffic sample for a few days and compare cost per passing task.
- Re-run your eval set on Sol. If you don't have one, my guide to LLM evals for startups shows how to build a small one from real tickets in a day.
- Read OpenAI's GPT-6.2 migration guide before you upgrade. The API changelog says GPT-6.2 changes how the Responses API preserves reasoning when you edit a conversation's prefix, and how the top-level
instructionsfield is handled. If your agent rewrites history or system instructions mid-run, test that path specifically. - Keep prompt prefixes stable. Append to conversations instead of rebuilding the system prompt every turn; that is how you get the $0.40 and $0.10 cached rates.
- Remove
reasoning_effort: "none"anywhere it can reach these models; the API rejects it. - Add a blocker check to agent outputs. Ask the model to list every obstacle it hit, then verify the result in code. The system card gave you a reason; take it.
- Handle stopped conversations. Treat a monitor stop as a retryable failure with a fallback model, and log it so you can see if your use case trips it.
- Set spend limits and alerts on the new models before rollout. A cheaper model invites more usage, and stolen keys get used on the newest model first; my LLMjacking checklist covers the key hygiene.
- Put a router in front of providers if you haven't. Model rankings change monthly; switching cost should be one config line. I wrote about this in LLM vendor lock-in.
Here is the shape of the side-by-side check I'd run, using the Responses API. Treat it as a starting point and confirm parameter names against OpenAI's current docs.
from openai import OpenAI
client = OpenAI()
MODELS = ["gpt-6.2-sol", "gpt-6.2-astra"]
PRICES = { # USD per 1M tokens, Standard tier, prompts under 272K
"gpt-6.2-sol": {"in": 2.00, "cached": 0.10, "out": 10.00},
"gpt-6.2-astra": {"in": 8.00, "cached": 0.40, "out": 40.00},
}
def cost(model, usage):
p = PRICES[model]
cached = getattr(usage.input_tokens_details, "cached_tokens", 0) or 0
fresh = usage.input_tokens - cached
return (fresh * p["in"] + cached * p["cached"] + usage.output_tokens * p["out"]) / 1_000_000
def run(case):
results = {}
for model in MODELS:
r = client.responses.create(
model=model,
instructions="Do the task. Then list every obstacle or failure you hit, even small ones.",
input=case["prompt"],
)
results[model] = {
"passed": case["check"](r.output_text), # your own pass/fail test
"cost": cost(model, r.usage),
}
return results
Sum cost over passing cases only and divide by the number of passes. That number, not the leaderboard, decides your default.
What I'd do as a CTO
I'd make GPT-6.2 Sol the default for coding and agent execution this week, move existing GPT-6 Astra traffic to GPT-6.2 Astra after a short shadow run (it is the same family, cheaper, and scores higher on OpenAI's evals), and keep Astra only where the eval shows Sol failing. I would not rip out a working Anthropic or Google setup because of launch-week charts; OpenAI's own chart shows Fable 5.2 ahead on coding. I'd also treat the system card as a product spec: build in blocker reporting, outcome checks and a fallback path for stopped conversations, because those are now documented behaviours, not edge cases.
If AI spend is a top-three cost for you and nobody owns the model decision, that is a fractional CTO job, not a side task for your busiest engineer. That is the work I do as a fractional CTO for AI-first startups, and if you only need a second opinion on an architecture or a vendor decision, a technical advisor arrangement is lighter.
Frequently asked questions
How much does GPT-6.2 Astra cost? $8 per million input tokens, $0.40 per million cached input tokens and $40 per million output tokens on the Standard tier. Prompts above 272,000 input tokens cost $16 input and $60 output. Batch is half price.
How much does GPT-6.2 Sol cost? $2 per million input tokens, $0.10 cached and $10 output, the same as GPT-6.1 Sol. Above 272,000 input tokens it is $4 input and $15 output.
What is the difference between GPT-6.2 Astra and Sol? Astra is the more capable and four times more expensive model; OpenAI positions it for demanding reasoning and coding. Sol is positioned for everyday coding and agent workflows and, on OpenAI's FrontierCode 2.0 chart, scores within half a point of Astra. Only Astra meets OpenAI's High threshold for AI self-improvement.
Is GPT-6.2 available in ChatGPT? OpenAI's community announcement says the models roll out in ChatGPT Work and Codex, not regular Chat. Secondary coverage lists Plus, Pro, Enterprise and Edu, with admins enabling them for Enterprise and Edu.
Is GPT-6.2 Astra better than Claude Fable 5.2? It depends on the task. On OpenAI's charts, Astra leads on Agents' Last Exam (78.3 vs 72.8 percent) at a fraction of the cost per task, while Fable leads on FrontierCode 2.0 (49.1 vs 44.2) and the Artificial Analysis index (64.6 vs 62.1). Both list at $8 / $40. Test both on your own work.
Why does GPT-6.2 refuse security questions? The system card rates both models Critical for cybersecurity, and OpenAI tightened default restrictions on higher-risk cyber assistance. Reduced refusals require approval for its trusted access programme (Daybreak Red).
If you're deciding where your AI spend should go after this month's launches, book a 30-minute call. Bring your current cost per task and the workload that hurts most, and I'll help you design the eval and read the results.
Sources
- GPT-6.2 Astra and Sol system card (OpenAI)
- GPT-6.2 Astra model page (OpenAI)
- GPT-6.2 Sol model page (OpenAI)
- API changelog (OpenAI)
- GPT-6.2 Astra and Sol are now available (OpenAI Developer Community)
- Introducing GPT-6.2 Astra and Sol (OpenAI)
- GPT-6.2 Astra and Sol: $8/$40 and $2/$10 API pricing, ChatGPT and Codex access (Data Studios)
- GPT-6.2 Astra and Sol: Pricing, Benchmarks, Access, vs Fable 5.2 (AI Catchup)
- GPT-6.2 Astra and Sol: Pricing, Benchmarks and What to Switch (Developers Digest)
- OpenAI's GPT-6.2 Astra and Sol Shake Up API Pricing (FinanceFeeds)
Written By
Kunal Vohra
Technical Co-Founder & Fractional CTO
I've co-founded 6+ startups across India, the UAE, and the US, spanning AI, Web3, fintech, and cybersecurity. I write about the technical and strategic decisions that determine whether a startup thrives or stalls.
Comments
Loading comments…