GPT-5.6 Sol, Terra, and Luna: The Developer's Tier-Selection Guide

OpenAI previewed GPT-5.6 on June 26, 2026, and for the first time the flagship release isn't a single model — it's a named family with three tiers built for different cost and latency profiles. Sol handles frontier agentic work, Terra is your everyday driver, and Luna is the cheapest and fastest option for high-frequency tasks. If you're routing every request to the same model by habit, you're either overpaying or underperforming. This guide tells you exactly where the lines are.

The tiers are currently in limited preview — available to trusted API partners and Codex users — with general availability expected in the coming weeks. But the pricing and capabilities are confirmed, and you can design your routing logic today.

What changed from GPT-5.5

GPT-5.5 was a single model with a single price point. The problem was that developers were paying frontier-model prices for tasks that didn't need frontier intelligence: linting suggestions, docstring generation, quick type lookups. GPT-5.6 forces an explicit choice — which is actually a gift, because the price spread between Luna and Sol is 5x on input and 5x on output.

Beyond tiering, GPT-5.6 advances on three axes that matter to developers: software engineering benchmarks (Sol scores highest on Cognition's FrontierCode evaluation), explicit cache breakpoints for predictable prompt caching, and Sol Ultra mode — a new setting that spawns internal subagent processes for complex multi-step reasoning without you having to orchestrate anything.

The three tiers explained

Each tier has a distinct design center. Sol is built for long-horizon agentic work — the kind that requires planning, tool invocation, and multi-step reasoning across large contexts. Terra is the everyday balanced model: strong on code, fast enough for interactive use, and priced for sustained daily use. Luna is the speed-optimized tier — the model you reach for when you need a response in under a second and correctness is secondary to throughput.

Sol is the only tier that supports Ultra mode — where the model internally spawns subprocesses for complex reasoning without you writing orchestration code. It's also the only tier launching on Cerebras at up to 750 tokens per second in July, bringing frontier-class reasoning at unprecedented output speed.

Pricing math for coding workflows

The choice of tier is a cost decision first. Here's how to think about it concretely. A typical interactive coding session — 10 turns, ~2,000 input tokens and ~500 output tokens per turn — costs:

Sol:   (20,000 × $5 + 5,000 × $30) / 1,000,000 = $0.25 per session
Terra: (20,000 × $2.50 + 5,000 × $15) / 1,000,000 = $0.125 per session
Luna:  (20,000 × $1 + 5,000 × $6) / 1,000,000 = $0.05 per session

At 100 sessions/day:
  Sol:   $25/day   = ~$750/month
  Terra: $12.50/day = ~$375/month
  Luna:  $5/day    = ~$150/month

For a developer running Claude Code or Codex all day, the difference between always picking Sol and always picking Terra is roughly $375/month — before prompt caching kicks in. Caching cuts those numbers significantly for repeated system prompts and skill files.

Sol ultra mode and cache breakpoints

Sol ultra is the headline capability that distinguishes GPT-5.6 from every prior release. When you set reasoning_effort: "ultra" on a Sol request, the model internally decomposes the problem into parallel reasoning chains, synthesizes them, and returns a single response. From the API surface, it looks like a normal completion — the orchestration is entirely internal.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6-sol",
    reasoning={"effort": "ultra"},
    input=[
        {
            "role": "user",
            "content": "Refactor this 800-line auth module to use the new OAuth2 PKCE flow. "
                       "Identify all callers, update them, add tests.",
        }
    ],
    # Explicit cache breakpoint: mark the system prefix as stable
    cache_control={"type": "breakpoint"},
)

print(response.output_text)

The explicit cache breakpoints are the other major developer-facing change. Previously, prompt caching in the OpenAI API was automatic and opaque — you couldn't control which prefix got cached or guarantee the cache lifetime. GPT-5.6 gives you both. Mark a breakpoint after your stable prefix (system prompt + skill files + repo context), and the API guarantees a 30-minute minimum cache life for that prefix across requests.

When to use each tier

The practical decision tree is simpler than it looks. Most codebases need at most two tiers in their routing logic:

Use Sol when:

• The task requires multi-file reasoning — a refactor that touches 10+ files, a security audit across the whole repo, a migration from one framework to another.
• You're running an agentic loop that will make 5+ tool calls before completing, and you need the model to plan correctly on the first pass rather than recover from wrong intermediate steps.
• The cost of a mistake is high — generating an incorrect DB migration, a broken API contract, a security regression. Sol's higher accuracy on FrontierCode is the relevant metric here.
• You want Ultra mode for complex multi-step reasoning.

Use Terra when:

• Interactive coding: writing a new function, debugging a failing test, explaining a piece of unfamiliar code, writing a PR description.
• Daily Codex sessions where you're working within a bounded context — a single file or a small subsystem — and the task has clear inputs and outputs.
• You need a good balance between capability and cost for sustained all-day use. Terra is the most cost-efficient tier for this workload shape.

Use Luna when:

• High-frequency, low-stakes tasks: autocomplete suggestions, docstring generation, quick type lookups, commit message drafts.
• Preprocessing pipelines — classifying code chunks, extracting metadata from files, generating embeddings inputs — where volume is high and per-request quality requirements are low.
• Any background job that fires on every keystroke or every file save. Luna on Cerebras at 750 tok/s makes this viable in ways Sol never could be.

Wiring the tiers into Codex and Claude

In Codex CLI, you set the model per-command or in your config file. The tier selection belongs in config for session-level defaults, with per-command overrides for heavyweight tasks.

# Default to Terra for everyday sessions
model = "gpt-5.6-terra"

# Per-task overrides are applied with --model
# codex run --model gpt-5.6-sol "refactor the auth module"

In a multi-agent setup — Claude Code orchestrating Codex subagents, or a custom Responses API pipeline — the routing logic belongs in the orchestrator. A simple heuristic that works well in practice: count the number of files the task will touch. Under 3 files → Terra. Over 3 files or cross-module → Sol.

function selectTier(task: CodingTask): "gpt-5.6-sol" | "gpt-5.6-terra" | "gpt-5.6-luna" {
  if (task.type === "autocomplete" || task.type === "docstring") {
    return "gpt-5.6-luna";
  }
  if (task.filesAffected > 3 || task.crossModule || task.requiresPlanning) {
    return "gpt-5.6-sol";
  }
  return "gpt-5.6-terra";
}

If you're using Claude Code alongside Codex, the model routing skill on skills-hub.ai handles this automatically — it inspects the task description, estimates scope, and routes to the appropriate OpenAI or Anthropic tier. Install it once and stop thinking about it.

Tier-routing on skills-hub.ai

The gpt-5-6-tier-routing skill on skills-hub.ai encodes this decision tree as a SKILL.md file you can install in Claude Code, Codex, or any MCP-compatible tool. It evaluates task scope, applies the Sol/Terra/Luna routing logic, and includes the explicit cache breakpoint wiring for SKILL.md files and system prompts.

# install the GPT-5.6 tier-routing skill
npx @skills-hub-ai/cli install gpt-5-6-tier-routing

# once installed, your coding agent will auto-select the right tier
# based on task scope and estimated token volume

For teams that use both Claude and Codex, browse the productivity skills category — there are complementary skills for Sonnet 5 effort tuning and Claude fallback model selection that pair well with the GPT-5.6 router.

The three-tier model is OpenAI's clearest signal yet that the era of "pick the best model and use it for everything" is over. The right architecture in 2026 is a routing layer that matches task complexity to model cost. The math is simple, the payoff is real, and the skills to automate it are already in the registry.

npx @skills-hub-ai/cli install gpt-5-6-tier-routing