In late September 2026, OpenAI shipped GPT-6 Sol at the mid-to-high end and GPT-6 Luna as the lightweight tier. On the official account, Sol is priced at $2 input / $10 output per million tokens, a 50% cut from GPT-5.6 Sol; Luna lands at $0.10 / $0.50, also 50% cheaper, at a fixed price with no peak-and-valley swings. Add the cache trio - improved default hit rate, a 90% discount on cached input reads, and mid-conversation effort changes that do not break the cache - and this is a migration with quantified upside for cost-sensitive agent pipelines. This piece covers operations only: whether to migrate, a pre-migration checklist, five steps, the price math, pitfalls, and a pre-launch checklist. For capabilities see the GPT-6 Astra agentic workflow SOP; for the broader price war, see the AI LLM price war roundup; for cross-model migration discipline in general, the Claude Fable 5.1 API migration SOP.
Who should migrate: three fits, two waits
Three teams that fit
Teams already on GPT-5.6 Sol in production with unit-price sensitivity. The official account gives a 50% price cut while benchmarks show capability holding or improving: 33.2% on AutomationBench at the xhigh tier, above the best reported Claude Opus 5 figure, and roughly half the factual errors of GPT-5.6 Sol in internal evaluation. Price and quality moving in your favor at once makes this the most certain payoff.
Cache-heavy teams. Long system prompts, multi-turn sessions, and large tool sets benefit most: the improved default hit rate stacks with the 90% discount on cached reads. Official numbers like "about 9% of the competitor's per-task cost" rest on stable cached prefixes. The higher your hit rate, the more you capture; if your prefix changes every call, the 50% cut is your entire upside and the trio is irrelevant. For the systematic arithmetic, see the agentic cost comparison under a cache-first architecture.
High-throughput light-task teams moving to Luna. Classification, extraction, routing, and structured output at $0.10 / $0.50 fixed push the "cheap model" boundary down a notch. Per the official account, Luna inherits Astra's multimodal capabilities, so light multimodal work is covered.
Two teams that should wait
Teams without an evaluation baseline. The price cut is the official account, but only your own eval set can answer what quality does on your distribution. Migrating blind lets the savings be quietly eaten by rework. Build a baseline first - fixed eval set, fixed scoring - then follow this SOP.
Teams whose core metric lives on a specific benchmark - check comparisons first. On DeepSWE v1.1 (coding), Grok 4.7 posts 71.0% on its official account, above Sol's 68.8% (each vendor's own figure, different harnesses, no cross-comparison conclusions); DeepSeek V4.1 Flash scores 74.2% on the same benchmark, above Luna's 66.6%. The cheapest model also posts the highest score there, so "cheapest" and "best-scoring" do not always live in the same house. For extreme cost-sensitive coding, evaluate DeepSeek V4.1 Flash alongside; see the DeepSeek V4.1 Flash integration SOP.
Pre-migration checklist
Five items, all done before touching code:
- Map call sites. Where model names live: hardcoded strings, config centers, framework defaults; whether you call through a homegrown SDK, the official SDK, or an OpenAI-compatible gateway. Separately confirm gateways have listed
gpt-6-solandgpt-6-luna- the easiest item to miss. - Build two baselines. Cost: per-task token usage, cache hit rate, billed cost on sampled recent tasks. Quality: a fixed eval set with fixed scoring, archived for step four.
- Inventory effort usage. Does the pipeline send a reasoning-effort setting, and which tiers? The new series spans low through xhigh/max; exact parameter naming defers to the official OpenAI documentation - this article invents no request fields.
- Confirm availability. Per the official account, Free and Go users can only use Luna for now; Sol targets Plus/Pro/Business/Enterprise/Edu. How tiers map to API entitlements is a matter for official documentation; do not discover a permission gap during canary.
- Prepare rollback. Model ID in a config center, so rollback is a config change, not a release.
The five-step migration
Step 1: change the model name
The minimal change is swapping the identifier to gpt-6-sol or gpt-6-luna. Access stays OpenAI-compatible with unchanged endpoints and auth; request field shapes defer to the official documentation. One discipline: the model name lives only in config, because canary, ramp-up, and rollback all hang off that switch.
Step 2: minimal verification
Pick one non-critical pipeline and smoke-test six things: the request goes through, output shapes are correct, structured output works, tool calling works, streaming works, multimodal input works. Then fire one request per effort tier and confirm each is accepted with sensible response differences. Problems caught here are the cheapest they will ever be.
Step 3: cache restructuring
The core engineering effort - the trio plus one key property:
- Re-measure the default hit rate. The official account says it improved, but your hit rate depends on your prompt structure. Measure after migration; do not carry over old conclusions.
- Capture the 90% discount. Move stable content to the front: system prompt, tool definitions, few-shot examples in the prefix; dynamic content (session history, retrieval injections) after. The discount applies to the matched prefix, so the more stable the prefix, the more it pays.
- Place explicit breakpoints correctly. OpenAI supports explicit breakpoints controlling the cache prefix boundary. The rule: only fully invariant content inside a breakpoint; session-specific variation only after it. A breakpoint enclosing a segment with timestamps or per-user state punches through the cache by hand.
- Exploit mid-conversation retiering. This is the key difference from past behavior: adjusting effort mid-conversation keeps the cached prefix valid. Tier by task difficulty - low tiers for simple turns like routing and extraction, high tiers for hard reasoning - and step up mid-session when a turn needs deeper thinking, instead of locking one tier to protect the cache. The old reflex of never touching effort for fear of cache invalidation is exactly what this pricing rewards you for unlearning.
Step 4: regression comparison
Run the fixed eval set on old and new models side by side and compare four things:
- Output quality: official internal evaluation shows about half the factual errors of GPT-5.6 Sol, but that is the official account on internal evals - your distribution needs your own measurement.
- Tool-call sequences: a new model may prefer different paths; more turns per task quietly eats the price cut - the most commonly missed regression.
- Token usage and billed cost: read the bill, not just token counts.
- p95 latency: measured the same way as before.
Step 5: canary and observation
Start at 1% of traffic by request and ramp in steps. Watch four metrics: error rate, cache hit rate, per-task cost, p95 latency. Pre-commit rollback thresholds - for instance, auto-switch back when cost growth or error rate crosses a set value. Keep session histories isolated between old and new pipelines; never mix them. Ramp on dashboard data, not on "a batch of demos ran fine".
Price comparison
| Model | Input ($/M tokens) | Output ($/M tokens) | Basis |
|---|---|---|---|
GPT-6 Sol (gpt-6-sol) | 2 | 10 | OpenAI official; 50% below GPT-5.6 Sol |
| GPT-5.6 Sol | 4 | 20 | Back-derived from the official "50% cut" claim; not directly published; cite with the derivation note |
GPT-6 Luna (gpt-6-luna) | 0.10 | 0.50 | OpenAI official; fixed price, no peak/valley |
| GPT-5.6 Luna | 0.20 | 1.00 | Back-derived from the official "50% cheaper" claim; cite with the derivation note |
| Claude Opus 5.5 | 4 | 20 | Anthropic official |
| Grok 4.7 | 2 | 6 | x.ai official account (via Machine Heart) |
Three ways to read it:
- Carry the basis with derived rows. The GPT-5.6 rows are back-derived from the official 50% claim; any citation must note the derivation.
- Do the cache arithmetic separately. Cached input reads carry a 90% discount per the official account; derived from Sol's $2 input, a hit costs roughly one tenth (derived). Each step of hit-rate improvement can shrink effective input price more than the model's own 50% cut - raise the hit rate first, then haggle over unit price.
- Report the Luna-DeepSeek comparison honestly. On DeepSeek's official account, V4.1 Flash costs 1 yuan input off-peak / 2 yuan peak, 4 yuan / 8 yuan output; Luna works out to roughly 0.7 and 3.5 yuan - cheaper, with no peak-and-valley swings. Yet on DeepSWE v1.1, DeepSeek's 74.2% exceeds Luna's 66.6%. Cheaper does not mean higher-scoring; choose per workload.
Pitfalls
| Pitfall | Symptom | Fix |
|---|---|---|
| Free/Go accounts cannot use Sol | Per the official account, Free/Go users can only use Luna for now; selecting Sol fails on permissions or availability | Upgrade the account tier, or route that pipeline to Luna for now; API-side entitlements defer to official documentation |
| Never adjusting effort mid-task | Simple turns also run at high effort, inflating cost | Mid-conversation retiering without cache breakage is the official cost-saving key: low tiers for simple turns, high tiers for hard tasks, cache still hits |
| Explicit breakpoints in the wrong place punch through the cache | Hit rate drops after migration; cached reads are a tiny share of the bill | Enclose only fully invariant content; anything with timestamps, user state, or random injections stays outside |
| Treating cross-vendor scores as selection proof | "Sol beat X" used as a procurement argument | Scores come from different harnesses and admit no cross-comparison conclusions; on Terminal-Bench 4.0, Sol/Luna are officially unpublished - write "unpublished" for missing cells |
| Citing derived prices as official numbers | Quoting GPT-5.6 Sol at $4/$20 without the note | Always attach the "back-derived from the 50% cut" basis |
| Third-party gateways lag behind | Gateway reports model not found, or silently falls back to the old model | Confirm gateways list the new IDs and pass effort through before launch; for self-built routing, include route-table updates in the release |
| Skipping the hit-rate re-measurement | Old conclusions carried over; the 90% discount never captured | List cache hit rate separately on the canary dashboard as a ramp-up gate |
Pre-launch checklist
- Model IDs are config-driven; rollback requires no release
- Minimal verification passed: structured output, tool calling, streaming, multimodal, all effort tiers
- Cache restructuring done: stable prefix plus explicit breakpoints, measured hit rate on target
- Effort tiering live: tiers routed by task difficulty, mid-session step-ups allowed
- Regression comparison done: quality, tool-call sequences, cost, latency, all with old-vs-new data
- Canary dashboard ready: error rate, cache hit rate, per-task cost, p95 latency
- Rollback thresholds committed and rehearsed once for real
- Third-party gateways and downstream dependencies confirmed on the new model IDs
References
- OpenAI official release (GPT-6 Sol and Luna, September 2026, as relayed by media and AI tooling aggregators): pricing and the 50% cut claims, the cache trio, effort tiers and mid-conversation retiering without cache breakage, availability tiers (Free/Go limited to Luna for now), and official benchmarks (AutomationBench, Agents' Last Exam, DeepSWE v1.1, OSWorld 2.0, FrontierCode, factual-error comparison).
- Anthropic official account (Claude Opus 5.5): the $4/$20 pricing.
- x.ai official account (Grok 4.7): pricing and DeepSWE score, relayed by Machine Heart.
- DeepSeek official account (V4.1 Flash): peak/valley pricing and DeepSWE score (relayed).
- Exact effort parameter naming, request field shapes, and per-tier API entitlements: defer to the official OpenAI documentation; this article provides none.
- Beyond the above, the back-derived GPT-5.6 prices and the derived cache-discount unit cost are labeled in the body; remaining implementation suggestions are engineering judgment, not official sources.
FAQ
Q1: Can I just swap the model name from GPT-5.6 to gpt-6-sol and ship?
A1: It will most likely run - OpenAI-compatible access means the change is the identifier itself. But do not: request-field and effort-value compatibility must be verified against the official documentation, and without restructuring the cache and effort tiering you capture none of the 90% discount or the mid-conversation retiering. Half the migration's value depends on those changes.
Q2: Is the 90% cached-read discount automatic, or does it require code changes?
A2: Per the official account, the improved default hit rate and the 90% discount on cached reads apply by default - billing needs no switch. But your hit rate depends entirely on prompt structure. To capture the discount fully, move stable content to the front and place explicit breakpoints around the invariant prefix; that part is real prompt-engineering and code work.
Q3: Does raising effort from a low to a high tier mid-conversation really not break the cache?
A3: The official account states explicitly that tiers can be changed mid-conversation without breaking the cache. This is the most valuable property of the migration: assign tiers by per-turn difficulty - low for simple steps, high for critical ones - while the prefix cache keeps hitting. For how the tier is passed in requests, defer to the official documentation.
Q4: Our account is on the Free/Go tier. Can we use Sol?
A4: Per the official account, Free and Go users can only use Luna for now; Sol targets Plus/Pro/Business/Enterprise/Edu, and API-side entitlements are a matter for official documentation. For light, high-throughput workloads, Luna's $0.10/$0.50 fixed pricing is usually enough. If you truly need Sol, resolve the account tier before planning the migration.
Q5: Luna is so cheap - can it replace every GPT-5.6 call outright?
A5: By workload. For light tasks like classification, extraction, and routing, official benchmarks show Luna at or above GPT-5.6 Sol's medium tier on several measures, so switching is justified. For hard coding and reasoning, be careful: on DeepSWE v1.1, Luna scores 66.6%, below DeepSeek V4.1 Flash's 74.2% and below Sol's 68.8%. Cheaper does not mean higher-scoring - use the step-four regression comparison to draw the Luna/Sol boundary per task instead of cutting over by price alone.