GPT-6.2 Astra and Sol: Pricing, Benchmarks, and Migration Guide

GPT-6.2 adds Astra and Sol; Astra is 20% cheaper, requiring tiered routing and canary migration.
The article covers pricing and use cases for Astra and Sol in OpenAI's GPT-6.2 series. Astra is $8/M input and $40/M output, 20% lower than GPT-6 Astra; Sol stays at $2/$10 for low-cost, high-concurrency work. Vendor benchmarks are reference ceilings only; cache rates cut repeated input costs but lack specific figures, so validate hit rates with small traffic first. Codex needs updated model IDs, API params, and retry/timeout verification. Teams with complex reasoning and cost sensitivity should move to Astra; simple cost-priority tasks can stay on Sol; dual-model teams should route by difficulty and use canary migration with rollback.
OpenAI's GPT-6.2 series introduces two new members: Astra and Sol. Astra is priced at $8 per million input tokens and $40 per million output tokens, 20% lower than GPT-6 Astra; Sol remains unchanged at $2 input and $10 output per million tokens. This article covers pricing, vendor-reported benchmarks, cache rates, Codex configuration, and discusses which teams should switch.
Pricing Structure: Astra Drops, Sol Holds Steady
GPT-6.2 Astra is priced at $8 per million input tokens and $40 per million output tokens. Compared to GPT-6 Astra, both input and output prices are reduced by 20% overall. For teams making high-frequency API calls, this means a direct reduction in per-unit inference cost. Sol's pricing is unchanged at $2 input and $10 output, continuing to serve as the workhorse for low-cost scenarios.
Looking at the pricing tiers, Astra is positioned to balance performance and cost, while Sol handles volume. The coexistence of both models means users need to route by task complexity rather than betting entirely on a single model.
Input/output token billing is the dominant pricing model for large model APIs today: prompts submitted by users (including system prompts, conversation history, and retrieved context) are billed as input tokens, and model-generated responses are billed as output tokens, with output typically priced 3–5x higher than input. Per-million-token quotes make for easy horizontal comparison, but the actual bill also depends on the input-to-output ratio—long-context, short-answer tasks have a higher input cost share, while open-ended generation tasks carry heavier output costs. So when comparing Astra and Sol, don't just look at unit prices; combine them with your own task's token structure for a weighted estimate.
Vendor-Reported Benchmarks and Cache Rates
The benchmark data mentioned in the original source is vendor-reported, with no third-party reproduction results provided. When evaluating, treat such figures as reference ceilings—actual performance depends on prompt structure, context length, and task type.
Cache rates are another variable mentioned. Cache hits can reduce billing costs for repeated input, with a noticeable impact on scenarios involving long system prompts and fixed knowledge base injection. The original source does not provide specific cache discount figures, so when estimating costs, it's advisable to first validate cache hit rates with small traffic volumes before extrapolating scaled-up spending.
Prompt caching is a mechanism that caches and reuses repeated prefix content (such as long system prompts, fixed knowledge bases, and few-shot examples) on the server side. Cached portions are billed at a significantly lower rate than standard input, reducing both cost and time-to-first-token in long-context scenarios. Caching typically requires an exact prefix match and a minimum length threshold, and hit rates depend heavily on prompt structure: putting stable content first and variable content later can significantly improve hit rates. This is also a variable worth measuring separately when evaluating Astra.
Key Codex Configuration Points
The original source mentions Codex setup but does not elaborate on specific steps. Based on common practice, when switching models you need to update the model identifier and API parameters on the Codex side, and confirm that cache strategy, timeout settings, and retry logic match the new model's response characteristics. For teams already running automated tasks on Codex, it's recommended to run a full workflow in a non-production environment first before migrating production traffic.
Codex is OpenAI's model/tool series for code generation and software engineering tasks, callable via API or IDE plugins, commonly used for automated fixes, code review, and repository-level tasks. When switching the underlying model, beyond updating the model identifier, note differences in context window, function calling format, streaming output, and rate limit support across models; code tasks tend to have long contexts and frequent retries, so timeout and backoff parameters need retuning to match the new model's response characteristics.
Who Should Switch
The following situations are suitable for considering a switch to Astra:
- Currently using GPT-6 Astra and sensitive to the 20% cost reduction;
- Tasks are primarily medium-to-high complexity reasoning that require more capability than Sol;
- An existing caching strategy is in place to further compress costs using cache rates.
The following situations can stay on Sol:
- Tasks are primarily high-concurrency, low-complexity calls where cost is the priority;
- The existing Sol pipeline is stable, and migration benefits don't justify the switching cost;
- Output quality requirements fall within the range Sol can already satisfy.
For teams using both models, routing by task difficulty is the more pragmatic approach: simple classification, extraction, and short Q&A go to Sol, while complex reasoning and long-context tasks go to Astra.
Pre-Switch Checklist
- Compare Astra's output quality against existing models using real traffic samples;
- Estimate the impact of cache hit rates on actual billing;
- Update model configuration in Codex and verify retry and timeout behavior;
- Keep a rollback path and migrate gradually by traffic percentage.
A price cut doesn't necessarily mean total costs will drop—output token consumption, retry counts, and cache efficiency all affect the final bill. Treat vendor-reported benchmarks as a starting point rather than a conclusion, and make decisions based on your own data—that's the right approach to switching.
Canary rollout means first routing a small percentage of traffic to the new model, observing quality, latency, and cost metrics, and then gradually scaling up once stability is confirmed. For large model switches, canary deployment can surface issues that offline evaluation struggles to catch, such as format drift under specific prompts, changes in refusal rates, or abnormal token consumption. Combined with a rollback path that retains the old model, you can quickly recover from regressions and keep switching risk within an acceptable range.
One-line Summary
GPT-6.2 adds Astra and Sol; Astra is 20% cheaper, requiring tiered routing by task and canary migration.
Paragraph Summary
The article introduces the pricing and use cases of Astra and Sol, two new members of OpenAI's GPT-6.2 series. Astra costs $8 per million input tokens and $40 output tokens, 20% lower than GPT-6 Astra; Sol remains at $2 input and $10 output, continuing to serve low-cost, high-concurrency scenarios. The article notes that vendor-reported benchmarks are only reference ceilings, and that cache rates can reduce repeated input costs though specific discounts weren't provided, recommending small-traffic validation of hit rates first. On the Codex side, model identifiers and API parameters need updating, with timeout and retry behavior verified. Finally, it offers switching guidance: teams with medium-to-high complexity reasoning and cost sensitivity should migrate to Astra, low-complexity cost-priority tasks can stay on Sol, and dual-model teams should route by task difficulty, controlling risk through canary migration and rollback paths.
Related articles

RePlan-VLA: Progress-Aware Replanning Breakthrough for Long-Horizon Robotic Manipulation
The RePlan-VLA framework converts VLA models' short-horizon capabilities into reliable long-horizon execution through progress-aware adaptive replanning, improving success rates by 21.9% and 10.4% on RoboCasa365 and CALVIN, and validating real-world deployment on a Franka Research 3 robot.

Geometric Bridge Flow Matching: A New Breakthrough in Blind Rigid Motion Correction
Geometric bridge flow matching enables blind rigid motion correction in head CBCT, achieving 37.1 dB PSNR and 0.27 mm RPE on simulated data in ~9.1 minutes, outperforming existing methods.

Google Releases Gemini 4 Hydrogen: 2.5x Faster Without Sacrificing Intelligence
Google releases the lightweight Gemini 4 Hydrogen: 2.5x faster task completion, AA Intelligence Index of 54 beating its flagship sibling, 7.3s single-step on Agent Arena faster than Claude and GPT rivals, four thinking levels with pay-as-you-need pricing, now available across AI Studio and more.