OpenAI Sol, Terra, and Luna, Mattsplained

OpenAI has three new model names: Sol, Terra, and Luna.

The names are friendly. The model picker is not always so friendly. You still have to decide whether you want the strongest model, the sensible middle option, or the cheaper one that can do a whole pile of smaller jobs without setting your API budget on fire.

Here is the short version:

• GPT-5.6 Sol is the strongest choice for hard reasoning, coding, and complex professional work.
• GPT-5.6 Terra is the balanced choice when you want plenty of intelligence at half the API price of Sol.
• GPT-5.6 Luna is the economical choice for repeatable, high-volume work.

That is the family portrait. Now let us figure out which one you should invite into your project.

Quick comparison

Those are API prices from OpenAI’s current model catalog. ChatGPT plans and usage limits are a separate thing, so do not stare at this table and start invoicing yourself for every question you ask in ChatGPT.

All three models support text and image input, text output, vision, multilingual work, and the same core tools: functions, web search, file search, and computer use. They also share a 1.05 million-token context window, a 128,000-token maximum output, and a February 16, 2026 knowledge cutoff.

The big difference is the tradeoff between capability and cost.

GPT-5.6 Sol: bring out the big brain

Sol is OpenAI’s flagship GPT-5.6 model for complex professional work. It is the one to reach for when the task is genuinely difficult and a weak answer could create more work than it saves.

I would start with Sol for things like:

• planning a complicated feature across a large codebase
• debugging a problem with several possible causes
• reviewing an architecture or security-sensitive change
• reasoning across long documents, research, or messy requirements
• handling important work where accuracy matters more than saving a few dollars

For vibe coders, Sol is the model I would put on the job when the app has stopped being a cute weekend experiment and started developing opinions.

Maybe authentication is interacting with payments. Maybe the database structure needs to change without breaking existing data. Maybe three errors are taking turns wearing the same trench coat.

That is Sol territory.

The tradeoff is simple: Sol costs the most. Its API input and output prices are twice Terra’s and five times Luna’s. Using the strongest model for every tiny task is a bit like hiring an architect to hang a picture frame. The frame will probably be extremely level, but this may not be the best use of anyone’s resources.

GPT-5.6 Terra: the everyday default

Terra is designed to balance intelligence and cost.

That middle position is not very dramatic, but it is extremely useful. Most real app work lives in the middle. It is not trivial, but it also does not require the most powerful model every single time.

I would try Terra first for:

• building normal product features
• drafting and revising website copy
• creating structured data from documents
• summarizing customer feedback
• answering questions inside an app
• coding tasks with clear requirements
• tool-using workflows that still need good judgment

Terra costs half as much as Sol for both input and output tokens while keeping the same context window, maximum output, reasoning settings, and listed tools.

That makes Terra the model I would expect many builders to use as their practical default. Start there, test it on the real job, and move up to Sol only when the work proves it needs more horsepower.

You do not get extra points for using the fanciest model. The user only sees whether the feature works.

GPT-5.6 Luna: small price, lots of laps

Luna is optimized for cost-sensitive workloads, especially when you need to do the same kind of job many times.

Think less “solve this tangled mystery” and more “please process the next 10,000 items without requiring me to sell a kidney.”

Luna can make sense for:

• tagging or categorizing large batches of content
• extracting known fields from consistent documents
• generating simple variations from a stable template
• routing support requests
• powering high-volume app features
• running first-pass analysis before escalating harder cases

Luna’s API price is one-fifth of Sol’s: $1 per million input tokens and $6 per million output tokens. At small scale, the savings may barely register. At large scale, they can become the difference between a useful feature and a monthly bill that causes you to quietly close the laptop.

Cheap does not mean automatic. Test Luna against examples from your actual app. A low token price is not a bargain if you have to rerun the task, repair bad output, or apologize to everyone named “Billing Question” because your support classifier got confused.

What the three models have in common

Sol, Terra, and Luna are not three completely different species. They are members of the same GPT-5.6 family.

According to OpenAI’s model catalog, each one includes:

• a 1.05 million-token context window
• up to 128,000 output tokens
• text and image input
• text output and vision
• multilingual capabilities
• function calling
• web search
• file search
• computer use
• reasoning effort settings from none through max

That shared foundation matters. You can design one workflow and test different family members without rebuilding the whole thing around a tiny model with completely different limits.

It also means the names do not tell you what a model can technically accept. They mostly tell you where OpenAI wants each model to sit on the capability-versus-cost curve.

Which OpenAI model should you choose?

My beginner-friendly answer is: start with Terra.

Terra is the middle lane. It should give you a useful baseline without immediately paying Sol prices for every output. Then let the work tell you where to go.

Move up to Sol when:

• the task requires deeper reasoning
• coding quality is not good enough
• the consequences of an error are expensive
• your prompts include lots of context and conflicting requirements
• you keep fixing the model’s work by hand

Move down to Luna when:

• the task is narrow and repeatable
• the output format is tightly defined
• you are processing a lot of requests
• Terra performs no better on your real examples
• cost or response volume is becoming the main constraint

A sensible production setup may use all three. Luna handles routine cases. Terra handles the normal app experience. Sol gets the complicated work or the cases the other models cannot resolve confidently.

The fanciest name for this is model routing. The less fancy name is not sending every grocery run in a rocket ship.

A simple way to test them

Do not choose a model based only on a product page, a benchmark chart, or somebody online declaring that one of them “changes everything.” The internet changes everything approximately four times before lunch.

Build a small test set from your real use case:

1. Collect 20 to 50 examples, including easy cases and ugly edge cases.
2. Run the same prompt and settings with Luna, Terra, and Sol.
3. Score the outputs for correctness, usefulness, consistency, speed, and cost.
4. Look at where each cheaper model fails, not just its average score.
5. Choose the least expensive model that reliably clears your quality bar.

If Luna nails the job, use Luna. If Terra is clearly better, use Terra. If only Sol can untangle the hard cases, pay for Sol where those cases appear.

That is less exciting than picking a favorite celestial object, but it is a much better way to build software.

The bottom line

OpenAI’s GPT-5.6 lineup is easier to understand once you ignore the space names for a second:

• Sol gives you the most capability for the hardest work.
• Terra gives you the strongest all-around balance.
• Luna gives you the lowest cost for repeatable work at scale.

For most new projects, I would begin on Terra, test Luna for routine tasks, and save Sol for the parts where stronger reasoning actually changes the result.

Use the model that fits the job. Your app does not care whether its JSON was generated by the sun, the Earth, or the moon. It just wants the comma in the right place.

Read more

• OpenAI’s current model catalog
• OpenAI’s model selection guide
• My OpenAI Codex tool page