OpenAI released GPT-6.2 Astra and GPT-6.2 Sol on November 17, 2026. Astra is the stronger of the two: it takes the top spot on OpenAI’s Elo leaderboard at 1,318, ahead of Claude Fable 5.2 at 1,271 and Sol at 1,259.
What is GPT-6.2 Astra
GPT-6.2 is a family, not a single model. OpenAI ships two variants:
- Astra is the ceiling. Maximum capability, highest cost.
- Sol is the value pick. Within half a point of Astra on most evaluations, at about one-fifth the price.
This mirrors how Anthropic ships Opus and Fable, or how the original GPT-6 had both an Astra and a Sol tier. The naming is not new, just the numbers behind it.
Astra replaces GPT-6 Astra, which OpenAI described as state-of-the-art on computer use, browsing, software engineering, cybersecurity, science, and professional work. GPT-6.2 keeps that positioning and pushes the numbers further, with the token efficiency gains doing as much practical work as the raw score increases.
For a direct comparison of the two GPT-6.2 variants, see GPT-6.2 Sol vs Astra.
Benchmarks
Here is what we know from OpenAI’s announcement and third-party trackers as of launch day.
Elo and leaderboard position
| Model | Elo |
|---|---|
| GPT-6.2 Astra | 1,318 |
| Claude Fable 5.2 | 1,271 |
| GPT-6.2 Sol | 1,259 |
Astra leads by 47 Elo points over Anthropic’s current best. That is a meaningful gap on a compressed leaderboard where models have traded the top spot by single digits for months.
Coding
We do not yet have GPT-6.2 Astra numbers on the standard public coding suites (SWE-bench, Terminal-Bench, FrontierCode). Those tend to arrive in the first week after launch as independent groups run their evals. We will update this section as results come in.
For reference, GPT-6.2 Sol scored 68.8% on DeepSWE v1.1 and 49.3% on FrontierCode 1.1. Astra is expected to sit above those numbers, but we prefer to wait for published data rather than guess.
What we do know: GPT-6 Astra (the predecessor) posted near-saturated scores on several agentic coding evaluations. OpenAI claims 6.2 is strictly better, and the Elo gap supports that, but the specific coding benchmark numbers are not yet public.
Science and research
This is where GPT-6.2 Astra makes its strongest case.
OpenAI reports a 6.2 percentage point gain over GPT-6 Astra on its internal science benchmark. They did not publish the absolute score, but GPT-6 Astra already sat near saturation on FrontierMath Tier 4 and ARC-AGI-3. Improving 6.2 points from an already-saturated baseline suggests either harder test items or genuine capability gains on research-grade problems.
The most striking result from the predecessor: a pre-release version of GPT-6 Astra solved 2 of 68 open conjectures in the FrontierMath Erdős evaluation. No other tested model managed any. That evaluation used unsolved problems from active mathematical research, not textbook exercises. We do not yet know how GPT-6.2 Astra performs on Erdős, but GPT-6’s result sets a high floor.
For the broader research community, the question is whether Astra can maintain these gains on problems that are genuinely new to the model. The FrontierMath Erdős results suggest that GPT-6-class models are crossing into territory where they can contribute to open research, not just solve known problems faster.
Legal and specialized capabilities
On the Harvey Legal Agent Benchmark, GPT-6.2 Astra completed 14.6% of assignments with every requirement met, up from 4.6% for GPT-6 Astra. That is a 3x improvement on a benchmark where most models struggle to clear single digits.
OpenAI also announced Astra for Law, a specialized variant fine-tuned on legal corpora:
- 0.03 hallucination errors per assignment (the lowest rate in the comparison, tied with one other model)
- Roughly half the hallucination rate of base GPT-6.2 Astra (0.06)
- Same Harvey Legal Agent Benchmark, same tasks, just fewer invented citations and fabricated precedents
The 0.03 figure deserves context. On the Harvey benchmark, each assignment involves multi-step legal reasoning: reading case documents, applying precedent, drafting responses. A hallucination error means the model cited a case that does not exist, quoted a statute incorrectly, or fabricated a legal standard. At 0.03 errors per assignment, the model averages one fabrication roughly every 33 assignments. Base Astra at 0.06 hallucinates about once every 17 assignments.
For legal tech teams, this is the difference between “needs human review on every output” and “needs spot checks.” Neither rate eliminates the need for review, but 0.03 makes automated triage workflows more practical.
Astra for Law appears to be gated. It is available through Harvey and potentially through enterprise agreements with OpenAI. If you are building legal tooling independently, you likely need to work with OpenAI’s sales team.
Computer use and agent tasks
GPT-6 Astra was already OpenAI’s strongest model for computer use and multi-step agentic workflows. OpenAI positions GPT-6.2 Astra as an upgrade across the board, though they did not publish specific computer-use benchmark numbers at launch.
What we know from the predecessor: GPT-6 Astra scored competitively on OSWorld and RecreationWorld evaluations, handling tasks like navigating desktop applications, filling forms, and completing multi-step browser workflows. The 22% token reduction in GPT-6.2 is especially relevant here: agentic runs generate thousands of tokens per step, and each step’s output goes back into the context for the next step. Fewer tokens per action means longer runs before hitting context limits, and lower cost per complete workflow.
For multi-agent setups, Astra works well as the “hard problem” router. We have been testing workflows where routine steps go to Sol or a local model and only the complex decision points escalate to Astra. This keeps costs reasonable while still hitting Astra’s ceiling when it matters.
We will add specific agentic benchmark numbers as independent groups publish them.
How Astra compares to competitors
The frontier model landscape as of November 17, 2026:
| Dimension | GPT-6.2 Astra | Claude Fable 5.2 | GPT-6.2 Sol | Qwen 4 Max |
|---|---|---|---|---|
| Elo | 1,318 | 1,271 | 1,259 | varies by eval |
| Science | leader (self-reported) | strong | not specialized | competitive |
| Legal | 14.6% (Harvey) | unknown | unknown | unknown |
| Token efficiency | 22% fewer vs predecessor | unknown | comparable to Astra | unknown |
| Cost (relative) | 1x | varies by plan | ~0.2x | lower |
| Local deployment | no | no | no | yes (open weights) |
The main rivalry is Astra vs Fable 5.2. We cover that in depth in GPT-6.2 Astra vs Claude Fable 5.2. The short version: Astra leads on Elo by 47 points and on legal tasks by a wide margin. Fable 5.2 may still have an edge on specific coding benchmarks (Fable 5.1 posted 50.3% on FrontierCode and Fable 5.2 likely improved on that), but we need independent results to confirm.
Against Sol, the comparison is simpler: Sol is the same family, 80% cheaper, and within half a point on most evals. For all but the hardest tasks, Sol is the better default. See Sol vs Astra.
Against open-weight models like Qwen 4 Max, the tradeoff is capability vs control. Astra is stronger, but it is cloud-only. If you need to run inference on your own hardware (for privacy, latency, or cost at scale), Qwen 4 Max or other local models are the alternative.
Token efficiency: 22% fewer output tokens
The raw number is straightforward: GPT-6.2 Astra produces 22% fewer output tokens than GPT-6 Astra to finish the same tasks. OpenAI says this came from training, not from post-hoc compression or summarization.
What does 22% fewer tokens mean in practice?
- Lower cost per task. Even before the 20% price cut, you are paying for fewer tokens. The two stack: 20% cheaper per token, 22% fewer tokens, so the effective cost per completed task drops roughly 37% compared to GPT-6 Astra.
- Faster responses. Fewer tokens to generate means less wall-clock time. For agentic workflows with many sequential steps, shaving 22% off each step compounds across the whole run.
- More headroom in the context window. Long agent runs fill up the context with the model’s own output. Generating less output per step means you can run longer before hitting the ceiling.
This is not a flashy number, but for anyone running agents at scale, it may matter more than the benchmark gains. Cost and latency compound across thousands of steps in ways that a few percentage points on a leaderboard do not.
Pricing and access
OpenAI priced GPT-6.2 Astra at roughly 20% below GPT-6 Astra on standard input and output rates. The OpenRouter listing should have exact per-token numbers shortly after launch. For the predecessor, GPT-6 Astra ran at approximately $15 per million input tokens and $60 per million output tokens on the standard API. A 20% cut would put GPT-6.2 Astra around $12 input and $48 output per million tokens. These are estimates until OpenAI confirms.
The effective cost drop is steeper than 20% because of the token efficiency gains. If GPT-6.2 Astra uses 22% fewer output tokens per task, and each of those tokens costs 20% less:
- Per-token cost: ~$12 / $48 per million (estimated, 20% cut)
- Per-task cost: ~37% lower than GPT-6 Astra (token reduction + price cut combined)
- Sol alternative: ~$2.4 / $9.6 per million (one-fifth of Astra, keeping GPT-6.1 pricing)
| Model | Input (est.) | Output (est.) | Relative per-task cost |
|---|---|---|---|
| GPT-6 Astra (old) | ~$15/M | ~$60/M | 1x (baseline) |
| GPT-6.2 Astra | ~$12/M | ~$48/M | ~0.63x |
| GPT-6.2 Sol | ~$2.4/M | ~$9.6/M | ~0.13x |
GPT-6.2 Astra is available through:
- ChatGPT Work (OpenAI’s enterprise product)
- Codex (OpenAI’s coding agent)
- OpenAI API (direct access, pricing applies)
- OpenRouter (third-party router, may have markup)
- Artificial Analysis tracks live pricing and latency across providers
There is no self-hosted or local option. Astra is cloud-only.
What we measured ourselves
We ran one coding task through Atomic Agent, our open-source agent, on OpenRouter with the provider pinned to OpenAI. The task is a warehouse accounting library of about 1,400 lines with 13 planted bugs and one missing feature, scored by 59 hidden tests. Each run used Atomic Agent v0.6.13 with approvals off.
| Run | Hidden tests | Time | Steps | Cost |
|---|---|---|---|---|
| 1 | 59/59 | 93 s | 10 | $1.06 |
| 2 | 59/59 | 79 s | 8 | $0.69 |
| 3 | 59/59 | 86 s | 8 | $0.70 |
Astra solved all 59 tests in every run, averaging 86 seconds and $0.82 per task. For comparison, Fable 5.2 at medium effort took 4.2 minutes and $1.87 on the same task. Astra finished faster and cheaper while using a different provider, so the comparison is directional rather than controlled, but the ballpark is clear: Astra is competitive at the top of the leaderboard and costs roughly half of Fable 5.2 medium on this workload.
Limits of this test. One task, three runs, on launch day. It shows cost and speed on a task every strong model can solve. It says nothing about Astra’s science, legal, or long-horizon work.
Download Atomic Agent to repeat this on your own repo.
Limitations
Every frontier model ships with caveats. Here are Astra’s as of launch day.
No independent benchmarks yet. The numbers above are mostly OpenAI’s self-reported figures. FrontierCode, Terminal-Bench, SWE-bench, and the other standard suites have not published GPT-6.2 Astra results. Until they do, the Elo gap over Fable 5.2 is an OpenAI claim, not a consensus.
Cloud-only. There is no open-weight version, no local deployment, no self-hosting. If you need to keep data on your own hardware, Astra is not an option. You can pair it with a local agent runtime that handles orchestration locally while routing specific calls to the API, but the model itself runs on OpenAI’s infrastructure.
Legal variant is gated. Astra for Law is not in the general API. It appears to be available through Harvey and potentially through enterprise agreements. If you are building legal tooling, you likely need to work with OpenAI’s sales team.
Token efficiency claims are aggregate. The 22% figure is an average across OpenAI’s internal task set. Some tasks may see larger reductions, others smaller. Your mileage depends on your workload.
Pricing details are thin. OpenAI announced “20% lower” without publishing exact per-million-token rates in the launch post. Until the pricing page updates, we are working with a relative number. The estimates in this article are based on GPT-6 Astra’s known pricing with the 20% reduction applied.
How to use GPT-6.2 Astra in Atomic Agent
Atomic Agent supports GPT-6.2 Astra through OpenRouter. You can set it as your cloud model and pair it with a local model for multi-agent orchestration, or run it as a standalone cloud backend.
To switch:
- Open Atomic Agent settings
- Under Cloud Model, select
openai/gpt-6.2-astra(the model ID on OpenRouter) - Set reasoning effort to
highormaxdepending on your task
Astra works best for tasks where raw capability matters more than cost: complex coding sessions, research, legal review, or anything where getting the answer right the first time saves more than the token cost.
For routine tasks, GPT-6.2 Sol at one-fifth the price is the better default. You can configure Atomic Agent to route hard tasks to Astra and everything else to Sol or a local model automatically.
Disclosure: we build Atomic Agent, an open-source, local-first AI agent runtime. It runs on your machine, supports both cloud and local models, and takes about five minutes to set up.
FAQ
FAQ
Everything you need to know about running a local-first agent.
-
What is Atomic Agent?
Atomic Agent is an open-source, local-first AI agent runtime that runs entirely on your own machine. It uses llama.cpp to serve a local model, GBNF grammars to keep tool calls structurally valid, the Model Context Protocol (MCP) to connect external tools, and a SQLite-backed memory. It's built by AtomicBot and released under the MIT license on GitHub at github.com/AtomicBot-ai/atomic-agent.
-
Is Atomic Agent free?
Yes. Atomic Agent is free and open source under the MIT license. The easiest way to start is the desktop app for macOS, Windows and Linux from the Download page: it downloads a local model for you, and there's no token bill because the model runs on your own hardware. If you prefer the terminal, bring your own llama-server or let the CLI manage one. Either way the metered cost stays at zero.
-
Does Atomic Agent run offline, and is my data private?
Yes — by default the agent loop, the model, and your data all run locally on your own machine, so it works without sending your data to the cloud. Cloud providers are used only if you deliberately configure them. This makes Atomic Agent a strong fit for private, air-gapped, or compliance-sensitive workflows. For a step-by-step setup, see How to run an AI agent offline.
-
How is Atomic Agent different from Hermes?
On the GAIA Level 1 benchmark (53 tasks, run on the same model and the same hardware for a fair head-to-head), Atomic Agent scored 69.8% versus Hermes' 58.5% — that's +11.3 percentage points more accurate, solving 37 of 53 tasks. It was also about 1.6x faster per task (roughly 217 seconds versus 351 seconds on average). Unlike cloud-first agents, Atomic Agent is local-first and open source, so you keep both the accuracy and full control of your data.
-
What models does Atomic Agent support?
Atomic Agent works with any model your local llama-server can serve via llama.cpp, so you're free to choose the open-weight model that fits your hardware and task. GBNF grammars constrain the model's output so tool calls stay valid regardless of which model you pick. The published GAIA Level 1 benchmark was run on the same model and hardware as Hermes to keep the comparison fair.
-
What operating systems does Atomic Agent support?
Atomic Agent runs on macOS, Windows and Linux. The easiest way to start is the desktop app from the Download page: macOS 14 or later on Apple Silicon, Windows x64 and ARM64, and Linux x64 and arm64. If you prefer the terminal, the CLI (Developer Preview, v0.8.0) installs with one command and runs on macOS (Apple Silicon), Linux x64 and arm64, and Windows x64. Intel Macs are not currently built. Source and current requirements are on GitHub at github.com/AtomicBot-ai/atomic-agent.
-
Is Atomic Agent really open source?
Yes. Atomic Agent is released under the permissive MIT license, with open weights, open source, and open traces — software you can read and audit all the way down. The full code is on GitHub at github.com/AtomicBot-ai/atomic-agent.
-
Is Atomic Agent backed by NVIDIA?
Atomic Agent is a member of NVIDIA Inception, NVIDIA's free program for AI startups, accepted in August 2026. To be clear about what that means: Inception takes no equity and involves no funding or investment, so nobody bought a stake in the project. Membership gives us access to NVIDIA developer resources, NIM API endpoints, and cloud credits, and it means our technology was reviewed by NVIDIA. Atomic Agent stays MIT-licensed, open source, and local-first, and it runs on whatever hardware you already own — no NVIDIA GPU required. The application was filed by AtomicBot, the team that builds Atomic Agent.
-
Can I extend Atomic Agent with my own tools?
Yes. You can connect external tools through the Model Context Protocol (MCP), teach it repeatable workflows with skills, and even drive it remotely from Telegram. Because it's MIT-licensed and open source, you can also modify the runtime itself.


