GPT-5.6 Tiers: Which of Sol, Terra, Luna to Run (2026)

Three tiers, one generation. GPT-5.6 ships as Sol, Terra, and Luna: same 1M context, same 128K output cap, three different points on the price-and-power curve. Sol is the flagship at $5/$30 per million tokens, Terra the balanced mid tier at exactly half ($2.50/$15), Luna the cheap workhorse at $1/$6. The hard part is not running it. The hard part is picking the right tier for each job and not overpaying for capability you never use. This guide covers both: how to reach all three, and how to decide which one handles which request.

GPT-5.6 in 30 Seconds: What You Can Do, and What You Can’t

The one-sentence version: default your bulk traffic to Luna or Terra, keep Sol for the hard tail, always pass an explicit tier ID, and use the Responses API when you need max effort. Everything after this is detail.

Decision Frame: When This Tiering Pays Off (and When It Doesn’t)

Tiering is a habit, not a config flag. It pays off when your traffic is genuinely mixed and it wastes your time when it is not.

When to run all three tiers. Route across Sol/Terra/Luna when your workload spans capability levels: cheap classification and routing next to hard multi-file refactors in the same product. When your monthly bill is large enough that a 2x or 5x price gap on the bulk traffic is real money. When you are cost-sensitive but cannot drop capability on the hard 10% of requests. This is the case a router is built for, and it is where the price spread from $1 to $30 per million output tokens turns into a lever you can pull.

When not to bother. If every request is roughly the same difficulty, pick one tier and stop. A single-purpose classifier should run Luna and nothing else; a research agent that only ever does hard reasoning should run Sol and skip the routing logic. If your total spend is under a few dollars a day, the engineering time to build tier routing costs more than it saves. And if you are on OpenAI’s direct API and rely on the bare gpt-5.6 alias resolving to Sol, adding tier logic buys you nothing until you actually need Terra or Luna.

Stop rule. If your goal is just to call the flagship, use gpt-5.6-sol (or openai/gpt-5.6-sol on a gateway) and stop reading at the next section. The tier-selection and routing material below only earns its keep once you have at least two request types with different difficulty.

System Requirements

Nothing exotic. You need one of two access surfaces and an SDK that speaks the OpenAI protocol.

The difference between the two columns is small on purpose. The gateway path exists so that one key reaches all three GPT-5.6 tiers plus every other model you use, without three separate provider accounts. If you are already on the OpenAI SDK, moving to the gateway is a base-URL and model-string change, nothing more.

The Three Tiers, Side by Side

Here is what each tier actually ships, with prices verified against the ofox model catalog on July 13, 2026. Every rate is per million tokens.

Two facts drive most of the decision. First, the spec envelope is identical across tiers: same 1M context, same 128K output ceiling. You never trade context for cost. A whole-module prompt fits on Luna exactly as it fits on Sol; you are choosing capability per token, not capacity. Second, the price spread is wide. Luna’s output token is a fifth of Sol’s. On output-heavy work, which is where agent bills concentrate, that ratio is the entire argument for pushing traffic down the ladder wherever quality allows.

Sol’s sticker ($5/$30) matches the previous flagship, GPT-5.5. Terra reprices that same workload at exactly half. Luna sits a further step below. The generation number stays 5.6 across all three; the tier name is what moves the price.

Which Tier for Which Job

The clean way to choose is by request shape, not by gut feel about “how smart” a task is. Map the job to a tier and let the router enforce it.

The pattern almost every team converges on is a two-tier split: bulk requests go to Luna or Terra, and a small hard tail escalates to Sol. That captures the price spread on the 90% of traffic that does not need a flagship, and spends the flagship budget only where a few extra points of pass rate change the outcome.

Here is the same logic as a flowchart you can lift straight into a routing function.

flowchart TD
    A[Incoming request] --> B{Bounded output?<br/>classify / route / extract}
    B -->|Yes| L[openai/gpt-5.6-luna]
    B -->|No| C{Everyday coding<br/>or agentic work?}
    C -->|Yes| D{Latency or cost<br/>the priority?}
    D -->|Yes| T[openai/gpt-5.6-terra]
    D -->|No, hardest tasks| S[openai/gpt-5.6-sol]
    C -->|No, hardest reasoning| S
    S --> U{Needs max effort or<br/>Ultra heavy compute?}
    U -->|Yes| R[Sol via Responses API]
    U -->|No| S2[Sol via chat/completions]

What Tier Choice Costs You Per Task

The tier gap is abstract until you put a task shape on it. Take a single multi-turn agentic task: 50K input tokens (repo context, tool results, a few turns) and 15K output (edits, explanations, retries). Same task, three tiers, using the ofox rates from the table above.

At a thousand tasks a day, the gap between running everything on Sol and running everything on Luna is roughly $16,800 a month. Nobody should run everything on Luna, because plenty of those tasks need more than Luna gives. But the number explains why tiering is worth the routing code: if even a third of that traffic is bounded enough for Luna and another third clears Terra, the blended bill lands far below the all-Sol line without touching the hard tail.

Two things about this math are worth internalizing. First, output is the expensive half. Sol’s output token is five times Luna’s, while its input token is also five times but input is usually the larger raw count, so on output-light tasks the tiers compress and on output-heavy tasks they spread. Route your output-heavy generation (test scaffolding, codemods, long explanations) down the ladder first, because that is where the tier gap bites hardest. Second, cache does not change the ranking. Each tier’s cached-input rate is exactly a tenth of its own uncached input rate ($0.10 vs $1 on Luna, $0.25 vs $2.50 on Terra, $0.50 vs $5 on Sol), so caching lowers every tier’s input bill by the same proportion and leaves Luna cheaper than Terra cheaper than Sol at every hit rate. Turn caching on for the absolute savings; do not let it change which tier you pick.

Step-by-Step: Run All Three Tiers on One Key

This is the ofox path, because one key reaching all three tiers is the point. The OpenAI-direct path is identical apart from the base URL and dropping the openai/ prefix.

Step 1: Set your key and base URL

export OFOX_API_KEY="sk-..."      # from app.ofox.ai
export OFOX_BASE_URL="https://api.ofox.ai/v1"

Expected result: two environment variables set. No network call yet.

Step 2: Call each tier once to confirm access

from openai import OpenAI
import os

client = OpenAI(base_url=os.environ["OFOX_BASE_URL"], api_key=os.environ["OFOX_API_KEY"])

for tier in ["openai/gpt-5.6-luna", "openai/gpt-5.6-terra", "openai/gpt-5.6-sol"]:
    r = client.chat.completions.create(
        model=tier,
        messages=[{"role": "user", "content": "Reply with your tier name only."}],
    )
    print(tier, "->", r.choices[0].message.content.strip())

Expected result: three lines, one per tier. If any line raises a not-found error, check the model string spelling first, then confirm your key has GPT-5.6 access.

Step 3: Build the tier router

One function turns request type into a model string. This is the whole tiering system.

def pick_tier(job: str) -> str:
    if job in {"classify", "route", "extract", "autocomplete"}:
        return "openai/gpt-5.6-luna"
    if job in {"code", "review", "refactor", "docgen"}:
        return "openai/gpt-5.6-terra"
    return "openai/gpt-5.6-sol"   # hard reasoning / agentic tail

resp = client.chat.completions.create(
    model=pick_tier(job_type),
    messages=messages,
)

Expected result: each request lands on the cheapest tier that clears its quality bar. The model column on your invoice shows exactly what each request cost, and pick_tier is the one place to tune the split.

Step 4: Node, same shape

If your stack is JavaScript, the router is identical in shape.

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: process.env.OFOX_BASE_URL,
  apiKey: process.env.OFOX_API_KEY,
});

const pickTier = (job) => {
  if (["classify", "route", "extract"].includes(job)) return "openai/gpt-5.6-luna";
  if (["code", "review", "refactor"].includes(job)) return "openai/gpt-5.6-terra";
  return "openai/gpt-5.6-sol";
};

const resp = await client.chat.completions.create({
  model: pickTier(jobType),
  messages,
});

Step 5: Reach max effort and Sol Ultra (Responses API)

max reasoning effort and Sol’s heavy-compute Pro/Ultra modes do not run on /v1/chat/completions. They need the Responses API. Sol supports reasoning efforts across none, low, medium, high, xhigh, and max; the top of that range plus the sub-agent Ultra mode is where the flagship earns its price.

resp = client.responses.create(
    model="openai/gpt-5.6-sol",
    input="Trace this deadlock across the four files below and propose a fix.",
    reasoning={"effort": "high"},   # max also valid here; not on chat/completions
)
print(resp.output_text)

Expected result: a reasoning-heavy answer. Try the same call against chat.completions with a high effort setting plus function tools and you will get the 400 in the next section instead.

Common Errors When Running GPT-5.6 (and Fixes)

For the full walk-through of the not-found and access failures, including the models-list check and the VPN region-block case, see the GPT-5.6 model-not-available error fix. The short version lives in the table; the long version has the diagnostic order.

What the Benchmarks Actually Say (and Don’t) About Each Tier

Pick a tier on price and on your own eval, not on launch headlines, because the headline numbers do not cover every tier. Here is the honest attribution, split by exactly who scored what.

The practical read: Sol has real published numbers. Terra and Luna have a price cut plus one vague relative claim against Claude Fable 5, and nothing more. So when the marketing says GPT-5.6 hit 91.9% on Terminal-Bench, that is Sol in Ultra mode, not the tier you would route everyday coding through. Do not carry Sol’s benchmarks over to Terra in your planning. If you are moving a workload down from Sol to Terra to cut cost, run a 20-to-30-task A/B on your own logs first. Terra is cheap, so the eval is cheap, and it is the only number that describes your traffic rather than OpenAI’s. The Terra vs GPT-5.5 cost breakdown works through that A/B math and the benchmark attribution in more depth.

Team and Multi-Developer Configuration

Tier selection gets more valuable, not less, once a team shares it. The failure mode on a team is every developer hardcoding a different model string, so half your traffic quietly runs the flagship on tasks that Luna would clear.

Centralize the tier map. Put pick_tier (or its Node twin) in a shared internal package and forbid raw model strings in application code. That gives you one place to shift the Luna/Terra/Sol boundaries when your eval or your budget changes, and it makes cost attribution readable, since the invoice’s model column now reflects a policy rather than a hundred individual guesses.

Share one key surface. Running all three tiers through a single https://api.ofox.ai/v1 key means one billing line, one access grant, and no per-developer OpenAI org juggling. New engineers get the same three model IDs and the same router. When you add a fourth model later, from a different vendor, it joins the same key and the same routing function instead of a new integration. For the general pattern of routing a whole catalog behind one endpoint, see the multi-model router guide and the Codex CLI custom-provider configuration for wiring the same key into a coding CLI.

Cap the flagship. If Sol spend is a concern, gate it behind the router so only the escalation path can reach it, and log every Sol call with its job type. Most teams discover a chunk of Sol traffic that Terra handled fine in the A/B, and the router is where you move it.

Alternatives: Other Ways to Reach GPT-5.6 (and Beyond)

ofox gateway. One https://api.ofox.ai/v1 key runs all three tiers (openai/gpt-5.6-sol, openai/gpt-5.6-terra, openai/gpt-5.6-luna) alongside your other models on the OpenAI-compatible protocol, pay-as-you-go, with the tier router deciding cost per request. This is the setup this guide is built around, and it is the least-friction way to A/B a tier before you commit to it. Prices track the live console.

OpenAI direct. platform.openai.com serves the same three tiers under the bare IDs (gpt-5.6-sol and friends), with the Responses API for max effort and the Sol Pro/Ultra modes. Pick this if you are already deep in OpenAI’s org tooling and do not need a second vendor on the same key. The trade-off is that access is scoped per surface and per org, so a key from the wrong org will 404 even when the same person can use the model in ChatGPT.

GitHub Copilot and other surfaces. GPT-5.6 also went live in Copilot at GA. That is fine for interactive coding inside the editor, but it is not an API you route programmatic traffic through, so it does not replace the gateway or direct paths for building an app.

Honest note on the others: OpenAI direct is the source of truth for the models and the only place the alias behavior and Responses-API features are guaranteed; the gateway’s advantage is the single key across tiers and vendors plus the drop-in cost A/B. Pick by whether you value one-vendor simplicity or multi-model routing.

FAQ

The frontmatter FAQ block above answers the eight questions that show up most in People Also Ask for GPT-5.6 tier selection: what the three tiers are, how to run them, which to pick, whether gpt-5.6 equals gpt-5.6-sol, what Ultra mode is, per-token cost, the 400 reasoning-effort error, and switching tiers without code changes.

Sources Checked for This Refresh

• OpenAI GPT-5.6 Sol model reference
• OpenAI API pricing
• OpenAI reasoning guide (effort levels, Responses API)
• Simon Willison: the new GPT-5.6 family (Luna, Terra, Sol)
• OpenAI community: GPT-5.6 chat-completion reasoning-effort behavior
• ofox model catalog: GPT-5.6 Sol
• ofox model catalog: GPT-5.6 Terra
• ofox model catalog: GPT-5.6 Luna