GPT-5.6 Sol vs Terra vs Luna: Which Size to Use (Tested September 2026)

GPT-5.6 is not one model. It is three: Sol, Terra and Luna, in descending order of size and price, with the same 1.05 million token context window and the same 128K output ceiling. OpenAI's naming tells you the order and nothing else, so on September 2, 2026 we asked all three the same three questions through our own API, streamed the answers, and read what each request was billed. The full twelve-model version of this test, with Claude Opus 5, Kimi K3, Gemini 3.7 Flash and the rest, is in our same-day comparison. This post is just the family.

The finding that matters: Terra was the fastest model to first token in the whole twelve-model set, not just the family, spent no reasoning tokens on any of the three prompts, and wrote answers a blind reader could not tell from Sol's on two prompts out of three. Sol earned its price exactly once, on the judgment question, and paid for it with a ten-second answer billed at nearly four times Terra's. Luna was billed about a tenth of a cent for the whole exercise, got nothing wrong, and had one slow moment worth knowing about.

The prompts and the settings

Same three prompts as the full test, copied verbatim from the Real Outputs sections of our model pages:

1. "Write a Python function that merges overlapping intervals, plus three short tests. Keep the whole answer under 40 lines of code."
2. "In about 120 words, tell a first-time founder when to choose a monolith over microservices, and the one signal that means it's time to split."
3. "Rewrite this sentence three ways, each in a clearly different tone (plain, playful, executive): 'Our app makes budgeting easy.' Label each."

Every request went to the NinjaChat API from a laptop on a home connection in the US on September 2, 2026, one at a time, after a warm-up request to each model, with temperature 0.7, a 2,500-token output cap, streaming with usage reporting, and reasoning left on the model's default. All three sizes were served by OpenAI directly. Time to first token is the first visible character after any hidden reasoning, so the latency includes our routing. Cost is what our API reported billing for the request. Single runs move around; treat the decimals as weather and the pattern as climate.

What happened

Three things stand out.

The code was the same code. All three sizes returned a sort-then-sweep merge function with three asserts, differing only in whether they return lists or tuples and whether they bother with a docstring. Terra did it in 2.9 seconds with no reasoning at all, the fastest answer on that prompt across all twelve models we tested that day. Sol spent 26 reasoning tokens, added a docstring and took 10.7 seconds, most of it before the first character. Luna reasoned for 374 tokens and took 7.2 seconds to produce the shortest function of the three, its slowest answer of the day.

Sol thinks when the question asks for judgment. On the founder question Sol spent 238 reasoning tokens before writing, took seven seconds to first token, and produced the best paragraph of the three: "split when one well-defined part of the product repeatedly needs to be deployed or scaled independently, and the monolith measurably prevents it," then "extract only that boundary, give it a clear interface and owner, and leave everything else together." Terra said nearly the same thing without the second sentence, in 4.6 seconds, and was billed a quarter as much. Luna reasoned only briefly, 75 tokens, and its answer had the sentence the other two forgot: extract that component first, "measure the improvement," and stop.

On short copy they are one model. The three rewrites are close to interchangeable. Sol and Terra began the plain version with the same seven words, "Our app helps you manage your budget," Luna reshuffled the same idea, and all three used "streamlines budgeting" in the executive line. Luna answered in 2.1 seconds and was billed a hundredth of a cent.

Price, context and limits

List prices on NinjaChat's API as of September 2, 2026, plus what the whole three-prompt exercise was billed on each size.

The ratios are the point. Terra is half of Sol's price on input and 60 percent on output; on the day, its three answers were billed at 37 percent of Sol's. Luna is a twentieth of Sol on input and a seventeenth on output, and its three answers were billed at about a fifth of Terra's. Cached input follows the same ladder, which matters for agents that resend a long system prompt on every turn: a 50K-token prompt cached on Luna costs a tenth of a cent per call.

Context is identical across the three, which is unusual and useful. You can prototype on Luna with the full million tokens of context and move a single call up to Sol when the answer is not good enough, without changing how you chunk anything.

When to use which

Use Terra by default. It is the size we would point a new project at. Same context as Sol, no reasoning tax on tasks that do not need it, and on the day it was the fastest of the three on code and within a fifth of a second of Luna on the founder question. Its founder answer was one sentence short of Sol's.

Use Sol for the calls where the answer is the product. A plan a customer will read, a diagnosis of a hard bug, a piece of analysis where a missing caveat costs you. Sol's willingness to pause and reason is exactly what you want there, and ten seconds is nothing against a wrong answer. Budget for it: reasoning tokens are billed as output, and that one answer was billed at nearly four times Terra's.

Use Luna for volume. Classification, extraction, routing, rewriting at scale, first drafts a person will edit, anything you run thousands of times a day. It made no mistakes on our three prompts and the whole set was billed about a tenth of a cent. Note that Luna does reason on its own when a prompt invites it, and on the coding prompt that cost it seven seconds; set a lower reasoning effort on the request if you need it snappy.

A pattern that works: route by Luna, answer by Terra, escalate to Sol. Let Luna decide whether a request is trivial, let Terra handle the normal case, and send the small fraction that needs real thought to Sol. Because all three share a context window, the escalation is a one-line model swap.

Call them by id

All three are live on the NinjaChat API, OpenAI-compatible, one key; a phone-verified account starts with a $0.50 starter balance. The ids are exactly gpt-5.6-sol, gpt-5.6-terra and gpt-5.6-luna.

curl https://www.ninjachat.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $NINJACHAT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.6-terra",
    "messages": [{"role": "user", "content": "Write a Python function that merges overlapping intervals, plus three short tests."}],
    "max_tokens": 2500,
    "stream": true,
    "stream_options": {"include_usage": true}
  }'

from openai import OpenAI

client = OpenAI(base_url="https://www.ninjachat.ai/api/v1", api_key="YOUR_KEY")

def ask(model, prompt, **kw):
    r = client.chat.completions.create(model=model, messages=[{"role": "user", "content": prompt}], max_tokens=2500, **kw)
    u = r.usage
    print(model, "output tokens:", u.completion_tokens, "reasoning tokens:", u.completion_tokens_details.reasoning_tokens)
    return r.choices[0].message.content

# Cheap first pass, then escalate the same prompt with the same context.
draft = ask("gpt-5.6-luna", "Summarise this incident report in five bullets: ...")
final = ask("gpt-5.6-sol", "Summarise this incident report in five bullets: ...", reasoning_effort="high")

The usage object on every response reports reasoning tokens separately from visible output, so you can watch exactly where Sol's money goes. The live price for each id is on GET https://www.ninjachat.ai/api/v1/models with no key. And if you would rather just talk to them, all three are on the consumer side too: Sol, Terra and Luna, on a paid plan.

Frequently asked questions

What is the difference between GPT-5.6 Sol, Terra and Luna? Size and price. Sol is the largest and most capable, Terra the middle, Luna the smallest and cheapest. All three share the same 1.05 million token context window and 128K output limit, so the choice is about quality per dollar, not about what fits.

Is GPT-5.6 Terra good enough for coding? On our September 2, 2026 test it wrote the same interval-merging function as Sol, with passing tests, in 2.9 seconds and without reasoning. For everyday functions it is the size to use. Escalate to Sol for architecture questions or bugs that need real deliberation.

Why did Sol cost so much more on one prompt? Reasoning. On the founder question Sol generated 238 reasoning tokens before writing 164 visible ones, and reasoning tokens are billed as output. On the rewrite it spent none and was billed close to what Terra was.

How much does GPT-5.6 cost through the API? On NinjaChat's API as of September 2, 2026: Sol is $4 input and $20 output per million tokens, Terra $2 and $12, Luna $0.20 and $1.20, with cached input at a tenth of the input price. Prices are live on the models endpoint and can change; check before you budget.

Can I switch between sizes without changing my code? Yes. They share a context window and the same API surface, so switching is the model string. The escalation pattern in the Python snippet above is the whole idea.

Does Luna reason? Sometimes, by default. It spent 374 reasoning tokens on the coding prompt, 75 on the founder prompt and none on the rewrite. If you want it fast on questions that invite deliberation, lower the reasoning effort on the request.