GPT-5.6: Choosing Between Sol, Terra, and Luna in Production

OpenAI moved GPT-5.6 to general availability on July 9, 2026, with three tiers: Sol, Terra, and Luna. All three have a 1M-token context window and a 128K-token maximum output. Prices range from $1 input and $6 output per million tokens for Luna to $5 input and $30 output for Sol.

Those shared limits make it easier to route different tasks to different models without changing how much context each request can carry. The harder decision is how much quality a task needs and whether the higher-priced tier earns its extra cost. Explicit prompt cache breakpoints add another consideration: repeated context can cost much less, but the savings depend on how prompts are structured and reused.

The release follows OpenAI's June 26 preview announcement. The July 9 general availability launch makes those pricing and routing decisions immediate for teams adopting the family.

What each tier offers

The three tiers differ in price and reported performance, while keeping the same standard context and output limits.

Sol is the flagship. Alongside its reported 88.8% score on Terminal-Bench 2.1, it reached a new high of 53.6 on Agents' Last Exam, an evaluation of long-running professional workflows across 55 fields. That puts it 13 points ahead of Claude Fable 5 on that evaluation. Sol is the strongest candidate in the family for difficult reasoning, long-running agent workflows, and tasks with a minimum quality requirement that cheaper models can't meet.

Sol Ultra, its parallel-subagent mode, extends the effective context to 1.5M tokens and coordinates four specialized agents by default. That effective context figure is separate from the standard 1M-token window shared by all three tiers.

Terra costs exactly half as much as Sol. OpenAI describes its performance as competitive with GPT-5.5. Its Terminal-Bench 2.1 result is 4.5 percentage points below Sol's, a gap that may matter on difficult reasoning tasks. For customer-facing responses, structured extraction, document analysis, and moderate reasoning, Terra is a reasonable starting point for workload testing.

Luna is intended for high-volume, lower-complexity work such as classification, routing, triage, summarization, and short-form generation. Its 82.5% Terminal-Bench score is lower than the other tiers, but a classification pipeline doesn't necessarily need the capabilities measured by the hardest benchmark tasks. At hundreds of calls per user session, its lower token prices can make a substantial difference.

The shared context and output limits allow identical prompts to fit across the family without tier-specific truncation. That removes one obstacle to routing. It doesn't establish that every tier will handle the same prompt equally well, so quality still needs to be measured on the tasks being routed.

How the cache changes the bill

GPT-5.6 introduces explicit prompt cache breakpoints. These let an application mark positions in a prompt where caching should apply, rather than relying only on automatic detection. The announced terms are a 90% discount on cache reads, a cache-write price of 1.25 times the standard input rate, and a guaranteed minimum cache lifetime of 30 minutes.

Consider a workflow that sends 200K tokens of stable context on each call. That could be a shared knowledge base, a codebase snapshot, or a long product specification. At Sol's uncached input rate, those tokens cost $1 per call. A cache hit reduces the cost to $0.10.

Across 10,000 calls per day against that context, the difference is $9,000 in daily context-read costs. That example assumes each task makes one such call and those reads hit the cache. It excludes cache writes, variable input, and output tokens. At the stated write rate, writing the 200K-token context costs $1.25, so repeated writes also need to be included in the cost model.

Explicit breakpoints give teams more control over which portion of a prompt is reusable. Stable system instructions, reference data, and tool definitions can sit before the cache boundary, with the changing user task after it. A successful cache read then discounts the stable portion while the variable portion remains billed at the standard input rate.

This control is useful when automatic detection is too unpredictable for a production budget. The breakpoint marks the intended boundary; the cost calculation still needs to account for cache hits and writes rather than assuming every request gets the read discount.

The minimum lifetime also helps with multi-step workflows. Under the announced 30-minute guarantee, a workflow that returns to the same cached context after 20 minutes can reuse it while refining a plan or making another tool-assisted query. That gives application designers a more concrete reuse window to work with.

For stable system prompts above 10K tokens, explicit caching deserves attention before routing logic is finalized. The useful question is how often that context repeats within the cache lifetime. Large, frequently reused prefixes offer a much stronger savings case than prompts that change on every call.

Subagents and JavaScript tool calling

The release also includes a multi-agent beta in the Responses API. Sol can start subagents for focused parallel work within the API, reducing the orchestration an application has to implement itself. Ultra mode coordinates four agents by default, each assigned a specialized part of the problem.

Because this feature remains in beta, it isn't a sound default for production-critical orchestration yet. It does show OpenAI taking on coordination work that would otherwise live in application code.

Programmatic tool calling adds another form of coordination. Models can compose and execute JavaScript to connect tool calls across MCP servers and command-line utilities, replacing some custom glue code.

That capability also creates security and auditability concerns. Model-generated JavaScript that coordinates tools introduces an execution surface, especially when those tools can affect external systems. Caution is warranted before deploying it in such environments. Less orchestration code in the application doesn't remove the need to understand what ran and which systems it could reach.

The coding comparison is different

Sol's Agents' Last Exam lead doesn't settle the choice for software engineering. On SWE-Bench Pro, which evaluates work against real codebases and pull requests, Claude Fable 5 reportedly substantially outperforms the entire GPT-5.6 family.

Agents' Last Exam covers professional workflows across 55 fields. Sol's reported 13-point lead there supports a broad workflow-performance claim, but it isn't a dedicated coding result. For agentic pull-request review, codebase-scale refactoring, or complex debugging, Fable 5's SWE-Bench Pro advantage remains relevant.

Terra at $2.50 input and $15 output per million tokens is still a useful comparison for teams weighing coding quality against cost. If it performs well enough on a particular set of code tasks, a lower bill may justify accepting a performance gap. That decision needs workload-specific evaluations. Aggregate scores can't show whether the gap occurs on the tasks an application handles most often.

Routing by task rather than session

A practical starting point is to assign tiers by the work each call performs:

• Sol: difficult reasoning, complex multi-step problem solving, and long-running agent workflows where quality takes priority over token cost.
• Terra: routine production work, including customer-facing responses, extraction, document analysis, and moderate reasoning, provided evaluations show acceptable results.
• Luna: frequent, lower-complexity calls such as classification, triage, routing, summarization, and short-form generation.

A single user session may need all three. Routing a simple classification call to the same tier as a difficult planning task spends money without an established quality benefit. Sending every task to the cheapest tier creates the opposite risk: savings may come with failures on the calls that need more capable reasoning.

OpenAI appears to be moving more of the application stack into its API through subagents, JavaScript-based tool coordination, and explicit caching. That may reduce custom orchestration work, while leaving teams responsible for evaluating quality, execution risks, and total cost.

Keep routing adjustable and collect production cost and quality data. After several weeks, that evidence should give a better basis for tier selection than launch benchmarks alone, particularly where different calls within the same session have different requirements.