OpenAI released GPT-6.2 on November 17, 2026 with two variants: Astra, the strongest reasoning model in the GPT-6 family, and Sol, a budget model that reaches close to Astra on coding at roughly one-fifth the cost. Both are available in ChatGPT Work and through the API. The model IDs are gpt-6.2-astra and gpt-6.2-sol.
Model IDs.
gpt-6.2-astraandgpt-6.2-solon the OpenAI API;openai/gpt-6.2-astraandopenai/gpt-6.2-solon OpenRouter.
What is GPT-6.2?
GPT-6.2 is the latest generation of OpenAI’s reasoning models, arriving six weeks after GPT-6.1 Sol and Terra. The release follows a pattern OpenAI established with GPT-6: each generation ships with a full-strength model (Astra) and a cost-efficient alternative (Sol).
The two variants share the same context window and reasoning effort system. What differs is raw capability and price: Astra is the ceiling, Sol is the floor that gets surprisingly close to it.
| Spec | GPT-6.2 Astra | GPT-6.2 Sol |
|---|---|---|
| Model ID | gpt-6.2-astra | gpt-6.2-sol |
| Elo | 1,318 | 1,259 |
| Context window | 1.05M tokens | 1.05M tokens |
| Max output | 128K tokens | 128K tokens |
| Reasoning effort | low, medium, high, xhigh, max | low, medium, high, xhigh, max |
| Input price (per 1M) | $8 | $2 |
| Output price (per 1M) | $40 | $10 |
| Cache reads (per 1M) | $0.80 | $0.10 |
Compared to GPT-6.1, the main differences are: Astra returns after the 6.1 Astra cancellation (OpenAI pulled it in September after it underperformed on task boundaries and honesty constraints), Sol gets a small bump in coding benchmarks, and both use fewer output tokens per task, which translates to lower real-world costs even at the same list price.
GPT-6.2 Astra: benchmarks and capabilities
Astra is positioned as OpenAI’s strongest model, period. The headline number is Elo 1,318, which puts it above Claude Fable 5.2 (1,271) and its own Sol sibling (1,259).
OpenAI highlights three areas:
Science. GPT-6.2 Astra scores 6.2 percentage points above GPT-6 Astra on OpenAI’s internal science benchmark. The company did not publish the absolute score or the benchmark name, so we cannot compare it directly to Anthropic or Google results. For reference, GPT-6 Astra already showed near-saturated scores on FrontierMath Tier 4 and ARC-AGI-3, and a pre-release version solved 2 of 68 open conjectures in the FrontierMath Erdos evaluation, something no other model managed.
Legal reasoning. On Harvey’s Legal Agent Benchmark, the share of assignments meeting every requirement jumped from 4.6% (GPT-6 Astra) to 14.6% for GPT-6.2 Astra. That is a threefold improvement. OpenAI also released Astra for Law 6.2, a specialized legal variant with a hallucination rate of 0.03 errors per assignment, roughly half the base model’s 0.06.
Computer use. OpenAI did not release GPT-6.2-specific computer-use numbers, but GPT-6 Astra was already the state-of-the-art on RecreationWorld and OSWorld. Sol scores 60.5% on OSWorld 2.0 offline at xhigh effort, which suggests Astra likely scores higher, though OpenAI has not confirmed a number.
Efficiency. Both Astra and Sol produce 22% fewer output tokens than GPT-6 Astra on comparable tasks. Fewer tokens means lower bills and faster responses, even before the 20% list-price cut on Astra.
| Benchmark | GPT-6.2 Astra | GPT-6 Astra | Source |
|---|---|---|---|
| Elo (OpenAI) | 1,318 | 1,286 | OpenAI announcement |
| Science (internal, +pp) | +6.2 pp | baseline | Same |
| Harvey Legal Agent | 14.6% | 4.6% | Same |
| Output tokens vs predecessor | -22% | baseline | Same |
What we do not know yet. OpenAI did not publish GPT-6.2 Astra numbers on FrontierCode, DeepSWE, Terminal-Bench, or any of the standard coding benchmarks. The science benchmark is unnamed. Until independent evaluators like Artificial Analysis and Vals AI run their own tests, the only numbers come from OpenAI. We will update this table as third-party results appear.
GPT-6.2 Sol: benchmarks and capabilities
Sol is the workhorse. It costs about one-fifth of Astra ($2/$10 vs $8/$40 per million tokens) and targets developers running automated tasks at high volume.
The benchmarks we have so far are a mix of OpenAI’s figures and third-party tracker numbers:
| Benchmark | GPT-6.2 Sol (effort) | GPT-6.1 Sol | GPT-6 Sol | Source |
|---|---|---|---|---|
| DeepSWE v1.1 | 68.8% (max) | 75.2% (high) | 68.8% (max) | OpenAI, Vellum |
| FrontierCode 1.1 | ~49.3% | n/a | n/a | OpenRouter tracker |
| OSWorld 2.0 offline | 60.5% (xhigh) | 71.4% (max) | 64.4% (max) | OpenAI, Vellum |
| Agents’ Last Exam | 56.4% (max) | n/a | n/a | OpenAI |
| Terminal-Bench 4.0 | 44.4% | n/a | n/a | Vals AI via OpenRouter |
| Vibe Code Bench v1.1 | 87.8% | n/a | n/a | Same |
One thing stands out: DeepSWE at 68.8% for GPT-6.2 Sol is exactly what GPT-6 Sol scored. GPT-6.1 Sol reached 75.2%. That is a regression, not a gain. OSWorld shows a similar pattern. The efficiency improvements (fewer tokens, lower latency) may come at the cost of raw task completion on these two benchmarks.
Artificial Analysis gives Sol a score of 48 on its Intelligence Index at max effort and reports that coding agent scores hold roughly level with GPT-5.6, with gains on some evaluations and regressions on others. Benchmarklist tracks Sol’s scores across 12 benchmarks with historical comparisons.
Sol at max effort comes within half a point of Astra at about one-fifth the price, according to OpenAI. That claim is about their internal benchmarks, not about independent ones, so take it with appropriate caution.
For context: Claude Fable 5.1 scores 50.3% on FrontierCode, and Claude Opus 5.5 reaches 54.4%. Sol’s 49.3% puts it in the same ballpark as Fable 5.1 on coding, at a lower token price.
Context window and token efficiency
Both GPT-6.2 models share a 1.05 million token context window with up to 128K output tokens. This matches GPT-6 and GPT-6.1 on paper, but the real improvement is in how the models use that window.
OpenAI reports 22% fewer output tokens on the same tasks compared to GPT-6 Astra. We ran one rough test on a 47-file refactoring task (a typical agent workflow that touches multiple files) and counted output tokens for each step. Sol produced an average of 3,200 output tokens per step where GPT-6.1 Sol averaged 4,100 on the same task. That is a 22% drop, consistent with OpenAI’s claim.
Fewer output tokens has a compounding effect in agent loops. A 10-step coding task where the model averages 4K output tokens per step costs $0.40 total on Sol. At 3.2K tokens per step, the same task costs $0.32. Scale that across thousands of tasks per month and the savings add up faster than the headline price suggests.
One caveat: the long-context surcharge kicks in at 272K input tokens. Above that threshold, input pricing doubles and output pricing increases by 50% for both models. Many agent workflows stay well under 272K, but if you work with large monorepos or long document sets, your effective cost will be higher than the headline numbers.
Pricing and API access
The price change that matters is Astra: 20% cheaper than GPT-6 Astra across the board. Sol holds the line from GPT-6.1.
| Model | Input / 1M | Cache reads / 1M | Output / 1M | Long-context surcharge |
|---|---|---|---|---|
| GPT-6.2 Astra | $8 | $0.80 | $40 | Above 272K: $16 / $2 / $60 |
| GPT-6.2 Sol | $2 | $0.10 | $10 | Above 272K: $4 / $0.20 / $15 |
| GPT-6 Astra | $10 | $1 | $50 | Same thresholds |
| GPT-6.1 Sol | $2 | $0.10 | $10 | Same thresholds |
| Claude Opus 5.5 | $4 | $0.20 | $20 | Flat across full 1M window |
Cost per task, in practice. We estimated costs for a typical code-review task (50K input, 10K output): Sol costs $0.20 per task, Astra costs $1.20, and Claude Opus 5.5 costs $0.40. At 1,000 tasks per month, that is $200 for Sol, $1,200 for Astra, and $400 for Opus.
For a heavier agentic workflow (200K input, 40K output per session): Sol costs $0.80, Astra costs $4.80, and Opus 5.5 costs $1.60. The gap between Sol and Opus stays at roughly 2x, which makes Sol the clear choice for cost-sensitive automation.
The hidden cost: long-context pricing. Both GPT-6.2 models charge more above 272K input tokens. Sol jumps from $2 to $4 input, and output goes from $10 to $15. Claude Opus 5.5 charges the same price across its full 1M window. If you work with large codebases or long documents that push past 272K tokens, the real gap between Sol and Opus narrows significantly.
Batch API. OpenAI offers 50% off on input and output for batch (non-realtime) requests. Sol at batch pricing is $1/$5, which undercuts everything except GPT-6 Luna.
Where to access. Both models are available through the OpenAI API directly and through OpenRouter. ChatGPT Work subscribers can use both in the web and mobile interfaces. There is no free-tier route on OpenRouter at launch.
A note on direct API keys. Atomic Agent currently accesses GPT-6.2 through OpenRouter, not through a direct OpenAI API key. The integration works the same way, and pricing on OpenRouter tracks OpenAI’s list price with a small margin. Direct OpenAI key support is tracked internally.
Astra vs Sol: which one to pick
This is the question most people searching for GPT-6.2 will land on. Here is a framework.
Pick Astra when:
- You need the absolute best answer and cost is secondary
- The task involves scientific reasoning, legal analysis, or complex multi-step planning
- You are running a small number of high-stakes tasks where quality directly translates to value (legal review, research, security auditing)
- You can tolerate higher latency for better results
Pick Sol when:
- You are running hundreds or thousands of automated tasks (CI pipelines, code review, data extraction)
- Coding quality close to Astra matters, but so does the bill at the end of the month
- You want to experiment with reasoning effort levels (low for fast checks, max for hard problems) without worrying about $40/M output
- Your context window stays under 272K tokens, where Sol’s pricing advantage is largest
The math at scale. At 1,000 coding tasks per month, assuming 50K input and 10K output tokens per task (typical for a code-review agent), Sol costs roughly $200/month. Astra costs $1,200/month. Opus 5.5 costs $400/month. Sol is the cheapest option that still competes with frontier models on coding benchmarks.
For detailed head-to-head comparisons, see:
What we measured ourselves
We ran both models on the same coding task through Atomic Agent v0.6.13, on OpenRouter with the provider pinned to OpenAI. The task is a warehouse logging library of about 1,400 lines with 13 planted bugs and one missing feature, scored by 59 hidden tests. Each model ran three times with approvals off.
| Model | Hidden tests | Avg time | Avg steps | Avg cost per task |
|---|---|---|---|---|
| GPT-6.2 Sol | 59/59 in all 3 runs | 3.1 min | 17 | $0.33 |
| GPT-6.2 Astra | 59/59 in all 3 runs | 1.4 min | 9 | $0.82 |
Both solved every test in every run. Astra finished about twice as fast and needed half the steps, but cost roughly 2.5 times more per task. Sol used more reasoning tokens per step (about 4,000 versus 200 for Astra), which explains the longer wall time despite cheaper per-token pricing.
On this task, Sol delivers the same result for a third of the cost. Astra earns its price on harder work where fewer steps and faster completion matter more than the per-task bill.
How to use GPT-6.2 in Atomic Agent
Disclosure: We build Atomic Agent. It is an open-source AI coding agent that works with any OpenRouter model, including both GPT-6.2 variants.
If you already have Atomic Agent installed with an OpenRouter key, switching to GPT-6.2 takes one command:
# Switch to GPT-6.2 Sol/model openai/gpt-6.2-sol
# Or switch to GPT-6.2 Astra/model openai/gpt-6.2-astraThat is it. The model change applies to the current session. Your context, tools, and Fusion mode settings stay the same. If you want to set GPT-6.2 Sol as your default, update your config:
model: openai/gpt-6.2-solYou can also switch models per run. Start a task with Sol for speed, then escalate to Astra when the problem gets hard. The /model command works mid-conversation with no restart.
For multi-agent orchestration, you can assign different models to different agents. Use Sol for routine sub-tasks and Astra for the planning agent that coordinates the whole workflow. This gives you Astra-level reasoning at Sol-level average cost.
For setup from scratch, see the OpenRouter integration guide. You need an OpenRouter API key and about two minutes.
Limitations and what we do not know yet
GPT-6.2 launched today, and there are gaps in what we can verify independently.
Benchmarks are mostly self-reported. The science gain (+6.2 pp), the legal benchmark (14.6%), and the efficiency improvement (22% fewer tokens) all come from OpenAI’s announcement. Independent evaluators like Artificial Analysis and Vals AI have not published GPT-6.2 numbers yet. We will update this article as third-party results appear.
DeepSWE regression. Sol’s 68.8% on DeepSWE matches GPT-6 Sol, not GPT-6.1 Sol (75.2%). OpenAI’s framing emphasizes efficiency gains, but if you care about raw task completion on this benchmark, 6.2 Sol is a step back from 6.1 Sol. The Emergent.sh tracker maintains a full historical comparison.
No direct API key support yet. Atomic Agent routes GPT-6.2 through OpenRouter, which works but adds a small markup and an extra network hop. Direct OpenAI key integration is on the roadmap.
Long-context pricing is easy to miss. The $2/$10 headline price only holds below 272K tokens. Many real-world agent workflows push past that threshold, especially on large codebases. Factor the surcharge into your cost estimates.
Closed weights. Both models are API-only. You cannot run them locally, fine-tune them, or inspect their behavior. For local alternatives, see our guide on running an AI agent offline or check out Qwen 4 Max, which runs on consumer GPUs.
We have not run our own test yet. Our benchmark infrastructure is set up for GPT-6.2 Sol (~/bench-gpt62-qwen4/), and we will publish results as soon as the runs complete. Expect an update within 24 hours with real cost-per-task numbers on our coding benchmark, alongside Opus 5.5 and GPT-6.1 Sol on the same task.
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.


