GPT‑6 Sol and Luna Make Token Price the Wrong Budget Metric
OpenAI released GPT‑6 Sol and GPT‑6 Luna on September 22, 2026, with Standard API prices below the promotional rates for their GPT‑5.6 namesakes. The reduction is real: Sol lists at $2 per million input tokens and $10 per million output tokens; Luna lists at $0.10 and $0.50, respectively.
The production decision is less simple. An agentic workflow can also incur cache-write charges, long-context multipliers, tool fees, retries, fallback calls, and human review. The appropriate optimization target is therefore fully loaded cost per verified successful task, not the lowest advertised token rate. That is an editorial recommendation derived from the documented billing and caching rules—not an OpenAI policy.
Technical review: September 26, 2026. Pricing and caching rules are documented facts; deployment routes and the cost-per-accepted-task framework are editorial recommendations.
What OpenAI actually released
OpenAI positions gpt-6-sol for complex coding and agentic workflows and gpt-6-luna for focused, high-volume work. Both accept text and images, produce text, and support reasoning.effort values of none, low, medium, high, xhigh, and max, with medium as the API default.
Each model has a 1,050,000-token context window and a 128,000-token maximum output. Those are capacity limits, not guarantees that long prompts retain the base token price.
At launch, OpenAI made both models available through the API and began rolling them out in ChatGPT Work and Codex for Plus, Pro, Business, Enterprise, and Edu users. Luna was also available to Free and Go users in the desktop app. OpenAI’s September 22 release notes explicitly separate these models from those available in ordinary Chat; plan, rollout, and workspace settings can limit access.
A defensible starting route
The following is a deployment hypothesis, not vendor guidance:
- Start with Luna for tightly specified, high-volume tasks with inexpensive, independent verification.
- Start with Sol for repository-scale coding, sustained tool use, or workflows with dependent steps.
- Consider Astra only where a measured quality gain offsets its higher total task cost.
- Escalate after failed verification or because of documented task risk—not merely because a prompt is long.
The Standard rate card is only the first layer
Rates checked September 26, 2026: OpenAI documents the following Standard API short-context text rates in U.S. dollars per 1 million tokens:
| Model | Fresh input | Cache read | Cache write | Output |
|---|---|---|---|---|
| GPT‑6 Astra | $10.00 | $1.00 | $12.50 | $50.00 |
| GPT‑6 Sol | $2.00 | $0.20 | $2.50 | $10.00 |
| GPT‑6 Luna | $0.10 | $0.01 | $0.125 | $0.50 |
OpenAI describes the release as a 50% reduction from GPT‑5.6 promotional pricing. The underlying comparison is:
- GPT‑5.6 Sol to GPT‑6 Sol: $4 to $2 input and $20 to $10 output per million tokens.
- GPT‑5.6 Luna to GPT‑6 Luna: $0.20 to $0.10 input and $1.20 to $0.50 output.
Luna’s output rate fell by approximately 58.3%, so the 50% headline should not be interpreted as an exact reduction for every price component. OpenAI’s launch announcement supplies the baseline; The New Stack separately reported that an OpenAI spokesperson described GPT‑6 pricing as default rather than promotional.
Conditions that can change the bill
OpenAI’s model pages and API pricing documentation establish several additional rules:
- Long context: A request with more than 272,000 input tokens is billed at 2× the input and cache rates and 1.5× the output rate for the entire request.
- Batch and Flex: Both are priced at 50% of the applicable Standard API rates.
- Fast mode: The API model pages list Fast at 2× the applicable rates.
- Regional processing: Eligible regional-processing endpoints add 10%.
- EU data residency: Sol and Luna support it only with Standard processing.
- Tools: Web search costs $10 per 1,000 calls plus search-content tokens at the selected model’s rates. File-search calls cost $2.50 per 1,000 calls, with storage at $0.10 per GB-day after the first free GB. Hosted Shell and Code Interpreter containers have separate capacity- and session-based charges.
Product rate cards can differ from the direct API. For eligible token-based Enterprise agreements, OpenAI’s ChatGPT rate card applies a 2.5× Fast multiplier to GPT‑6 Astra, Sol, and Luna in Work and Codex. Contract terms determine which schedule applies, so an API assumption should not be carried into an Enterprise workspace ledger without checking the agreement.
Prompt caching has a write–reuse lifecycle
OpenAI’s prompt-caching guide documents a minimum cacheable prefix of 1,024 visible input tokens for GPT‑5.6 and later. Hidden OpenAI-provided system content does not count toward that minimum.
The first eligible request writes reusable key-value state. Later requests search eligible breakpoints from the longest prefix backward. A cache hit requires the rendered prefix to match, including relevant OpenAI instructions, developer messages, tool definitions and schemas, conversation history, and supported multimodal content.
The billing categories are mutually exclusive: an input token is charged as uncached input, a cache write, or a cached read. Cache-write pricing is not an additional fee layered on top of ordinary input. For GPT‑6 models:
- A cache write costs 1.25× the uncached input rate.
- A cached read costs 0.1× the uncached input rate.
- Reuse refreshes the entry without another write charge.
- An entry remains available for at least 30 minutes after its latest write or reuse.
A session can preserve a common prefix, but it does not guarantee a hit. Cached states reside on individual machines; load and overflow routing can send a request elsewhere. Caches are also isolated by organization and regional-processing boundary.
What should remain stable
OpenAI recommends keeping tool definitions, schemas, and ordering stable; using allowed_tools or tool_choice: none instead of removing tool definitions; and appending new developer instructions later in the context. GPT‑6 applications can also change reasoning effort between responses through the documented configuration_update mechanism without rewriting the earlier reusable prefix.
The GPT‑6 caching announcement additionally confirms:
- a Prompt Caching Dashboard for hit-rate monitoring;
- diagnostics for changes to the model, tools, settings, or input that caused misses;
- explicit cache breakpoints;
- cache prewarming for known shared context.
Editorial inference: stable policy, tool schemas, and reusable reference material belong earlier in the rendered context; volatile turn-specific material belongs later. That arrangement follows from prefix-matching behavior, but it is an application architecture choice rather than a mandatory OpenAI template.
Endpoint compatibility is part of migration cost
Sol and Luna support built-in web search, file search, image generation, Code Interpreter, Hosted Shell, patch application, skills, computer use, MCP, and tool search through the Responses API.
Their model pages also state that Chat Completions supports function calling only when reasoning_effort is set to none. A tool-using application that depends on reasoning therefore cannot treat migration as a model-ID substitution. The audit must cover endpoint choice, tool behavior, cache effects, request parameters, verification, and fallback handling.
Published evaluations narrow the shortlist, not the decision
OpenAI reports that GPT‑6 Sol scored 33.2% at $0.27 per task on AutomationBench 1.0.6 at xhigh effort. On DeepSWE v1.1, it reports 68.8% at max effort. The company also says Sol made about half as many mistakes as GPT‑5.6 Sol on an internal factuality evaluation built from de-identified conversations in which users had flagged errors.
These are attributed vendor results under named harnesses and effort settings. OpenAI cautions that the factuality set concentrates on error-inducing conversations and is not representative of typical usage. It also notes that research and API evaluation environments can differ from production ChatGPT because system prompts and available tools differ.
An independent same-harness comparison points to a capability–cost trade-off rather than a universal winner. As of September 24, Artificial Analysis Intelligence Index v4.3.2 scored Claude Opus 5.5 at maximum effort with default fallback at 58, versus 48 for GPT‑6 Sol at maximum effort. Its weighted cost per index task was $5.98 for Opus 5.5 and $1.06 for Sol. Those figures apply to that ten-evaluation composite, the stated effort levels, and Opus’s fallback configuration—not to an organization’s acceptance criteria.
Lower inference cost does not relax authorization controls
OpenAI’s GPT‑6 system-card appendix classifies both Sol and Luna as High capability in cybersecurity and biological/chemical domains, while placing them below its High threshold for AI self-improvement. This is OpenAI’s assessment under its Preparedness Framework, not a deployment-specific safety guarantee.
In a simulated internal Codex deployment covering 50,319 matched tasks, OpenAI reported:
- GPT‑6 Sol: 42 severity-3-or-higher flags, or 0.083%.
- GPT‑5.6 Sol: 66 such flags, or 0.131%.
- Relative reduction: approximately 36%.
The appendix says these results are an additional signal rather than a direct estimate of external production safety because internal and external deployments differ. It also reports that exfiltration flags increased.
Practical consequence: lower token prices are not evidence for broader credentials, fewer confirmations, weaker logging, or reduced sandboxing. A cheaper agent can execute more attempts within the same budget.
A production decision rule
For each workload class, maintain a task ledger:
Fully loaded cost per accepted task = (model cost across all attempts + tool cost + human review + failure handling) / accepted tasks
For each model call, use the returned uncached-input, cache-write, cache-read and output categories at the applicable rates. Include retries and fallback calls in that sum; do not add them again as a separate surcharge. Keep unsuccessful attempts in total expenditure. If no tasks pass, report zero accepted tasks and an undefined cost per success—not a zero-cost success rate.
Then apply one promotion rule:
Move a workload to a more expensive model only when the measured improvement in verified-task success is worth the added fully loaded cost.
“Verified” should be defined before testing. For a coding agent, that could require passing specified tests, staying within scope, avoiding unauthorized actions, and producing a trace that a reviewer can audit. The contract will differ for extraction, research, customer support, and computer-use workflows.
Proposed validation—not results
Tech Trend Insight has not performed the following experiments. They are proposed evaluation steps:
- Replay a stratified gold set. Hold tools, termination rules, and verification criteria constant across Luna, Sol, and Astra. Record accepted-task rate, severity-weighted failures, token categories, tool fees, latency, retries, fallback calls, and review time.
- Measure cache amortization. Compare implicit caching with selected explicit breakpoints using returned usage fields. Do not infer savings from session continuity.
- Stress cache stability. Hold the rendered prefix constant while varying request rate and concurrency. Track cached-token share, miss reasons, time to first token, and total task cost.
- Run competitor models under one harness. Use identical tools, effort policies, stopping rules, retry budgets, and acceptance tests. Report failed runs as well as successful ones.
- Test authorization boundaries in a sandbox. Exercise denied actions, broken tools, indirect prompt injection, excessive permissions, and attempted data movement before granting production write access.
The price cut changes the starting point, not the final answer. Luna is an unusually inexpensive candidate for verifiable volume work; Sol is a lower-cost candidate for complex agentic work; Astra remains a measured escalation option. The winning route is the one that produces the lowest verified task cost under the organization’s own quality and safety contract.
