GPT-5.6 Sol vs Terra vs Luna: which tier should you actually use?

When GPT-5.6 landed as three models instead of one, my first reaction was mild annoyance. Sol, Terra, Luna — great names, zero help when I'm staring at a config file deciding which string to paste into model. So I did the boring thing: I wired all three into the same app, ran a week of real traffic through them, watched the token meter, and wrote down what I learned. This is that write-up — the decision tree I wish someone had handed me on day one.

The 30-second version

Three tiers, same API shape, same features. The only thing that changes is depth vs. cost vs. latency. Official OpenAI list prices, per million tokens:

Note the shape of that output column: $30, $15, $6. Output tokens are where the money goes, and they scale 5:1 against input across all three. Keep that ratio in your head — it makes tier choice mostly a question of how much the model talks, not how much you feed it.

Terra is the plot twist

I expected to run Sol everywhere and grumble about the bill. Then I A/B'd Sol against Terra on my actual coding-assistant traffic — diffs, refactors, "why is this test flaky" spelunking. OpenAI's own line is that Terra hits about 97% of Sol's benchmark performance, and honestly? On day-to-day dev work I couldn't feel the missing 3%. Same fixes, same explanations, half the list price.

That reframed the whole exercise for me. The question stopped being "can I afford Sol?" and became "do I have a specific reason to escalate off Terra?" For most requests the answer is no. Terra became my baseline and Sol became the exception I reach for deliberately — not the reverse.

Where Sol still earns its keep for me: genuinely hard reasoning where the cost of being wrong dwarfs the token bill. Architecture reviews, gnarly migrations, research synthesis across a big pile of context. And ultra mode — the 5.6 family can orchestrate parallel sub-agents on complex tasks, and that coordination is exactly the kind of work where the deepest tier pays for itself.

Luna is not a downgrade, it's a different job

Luna is the one people mis-read. It's not "watered-down Sol," it's the tier you point at work where per-token cost dominates and the quality ceiling basically never binds: bulk classification, tagging, extraction, summarizing a firehose of records. When you're doing the same small operation ten thousand times, a dollar of input vs. five dollars of input is the entire P&L. Luna is also the fastest of the three, so it's my pick for anything latency-sensitive — autocomplete, a streaming chat UI — paired with stream: true.

The cache math nobody puts on the slide

Here's the part that actually changed my routing, and it's the reason I'd tell you not to just default to the smallest tier.

GPT-5.6 ships with predictable caching: a prompt prefix is guaranteed to stay cached for at least 30 minutes, and you can drop your own cache breakpoints. Cache reads bill at 10% of the input price. That number quietly rewrites the arithmetic for any prefix-heavy workload.

Think about a RAG setup where every request re-sends the same fat corpus prefix. Without caching you pay full input rate on that prefix every single call. Pin it behind a breakpoint and you pay full rate once per 30-minute window, then 10% on every hit after. Run the numbers on a realistic prefix-to-suffix ratio and Terra-with-cache can land below Luna-uncached on effective per-request cost — while giving you Terra-grade answers. I stopped reaching for the smallest tier reflexively and started modeling the prefix ratio first. Sometimes the "more expensive" tier is the lower-cost system.

My actual routing rules

After all that, here's the decision tree I run in production:

• 
  Deep reasoning / high-stakes (architecture, tricky migrations, ultra-mode agent pipelines) → Sol. Output quality wins when a mistake is expensive.


• 
  Everyday work (coding assistant, general chat, most product features) → Terra. ~97% of Sol at half the list price; escalate specific request types to Sol only when your evals show the gap is real.


• 
  High-frequency / bulk (classification, extraction, summarization, latency-critical UX) → Luna, with stream on where it helps.

The meta-rule: start on Terra, promote to Sol by request-type when evals justify it, route the bulk lane to Luna. Match the workload, not the badge.

Trying all three behind one key (no OpenAI account)

The nice part is that testing this costs almost nothing in effort. I ran all three tiers through byesu — an AI API gateway that speaks the OpenAI-compatible Chat Completions API (and an Anthropic-native /v1/messages endpoint from the same host, same token). One sk- key covers all three GPT-5.6 tiers, so comparing them is a one-string change in a loop, and billing is pay-as-you-go per token — no subscription, no separate OpenAI account to provision.

If you already have OpenAI SDK code, it's a base_url swap:

from openai import OpenAI



client = OpenAI(

    api_key="sk-YOUR_TOKEN",

    base_url="https://byesu.com/v1",

)



prompt = "Refactor this function and explain the trade-offs."



for tier in ("gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna"):

    r = client.chat.completions.create(

        model=tier,

        messages=[{"role": "user", "content": prompt}],

    )

    u = r.usage

    print(f"{tier:16} in={u.prompt_tokens:5}  out={u.completion_tokens:5}")

    print(r.choices[0].message.content[:200], "\n")

Log usage on every call — that in/out split is the whole game. Once you can see input vs. output tokens per tier on your prompts, the pricing table above stops being abstract and the right tier basically picks itself.

One gotcha worth flagging: when you create the token, put it in the OpenAI GPT group. Wrong group is the usual cause of a "no available channel" error, and the model string has to be exactly gpt-5.6-sol / -terra / -luna.

Bottom line

Default to Terra. Escalate to Sol for the handful of requests where being right is worth $30-per-million output. Push bulk and latency-sensitive lanes to Luna. And before you assume the smallest tier is the lowest-cost one, do the cache math — predictable caching plus 10% reads can flip the ranking entirely. Wire all three behind one key, log your token usage, and let your own traffic settle the argument.