GPT-5.6 Sol, Terra and Luna: which one to use for coding

OpenAI shipped GPT-5.6 in three versions: Sol, Terra and Luna. At first glance it looks like new names for the same old split, the expensive one, the middle one and the cheap one. But the choice affects your working day more than that, especially if you use AI to write code.

Sol has the highest reasoning ceiling. Terra sits in the middle, trading intelligence against cost. Luna was built for fast, repetitive, high-volume work.

That's the short answer. In practice the useful question isn't which one is best, it's this: how much does a wrong answer cost here, and how much work will it take to check it?

Swapping a string in a component doesn't need the same model as chasing an intermittent auth bug, reviewing a database migration or making sense of a monorepo with hundreds of packages.

Quick summary: which GPT-5.6 should you pick?

The strategy that works most of the time: start on Luna or Terra, move up to Sol when the task carries ambiguity, high risk or dependencies scattered across the project.

What Sol, Terra and Luna actually are

The 5.6 identifies the generation. Sol, Terra and Luna are permanent capability tiers that can evolve independently from here on.

Compared to the previous families, Sol takes the place of the flagship with no suffix, Terra lands roughly where "mini" used to be, and Luna where "nano" was.

That doesn't make Luna weak. In the published tests it comes close to, or beats, flagship models from earlier generations on several tasks, and it costs a lot less.

Technical comparison

On the API the three look nearly identical on paper:

The API IDs:

gpt-5.6-sol
gpt-5.6-terra
gpt-5.6-luna

The gpt-5.6 alias points to Sol.

Same context is not the same as using the context

All three take 1.05 million tokens. That doesn't mean all three can find and connect information spread across a huge input.

In an OpenAI evaluation with multiple facts hidden between 512k and 1M tokens, Sol scored 73.8%, Terra 72.5% and Luna 41.3%.

Translated: Luna will happily swallow the whole repository, but it struggles more to link details that sit far apart. Fitting in the context and understanding the context are different things.

GPT-5.6 Sol: for when being wrong is expensive

Sol is the most capable model in the family. It was built for heavy professional work: advanced coding, research, security, science, tool use and tasks that keep running for a long time.

For coding, it pays off when the problem needs investigation, not just code generation.

When to use Sol

• Chasing an intermittent bug that crosses frontend, backend and infrastructure.
• Making sense of a large or poorly documented codebase.
• Planning an architecture change.
• Reviewing auth, payments, permissions or handling of sensitive data.
• Running database migrations.
• Finding vulnerabilities and suggesting fixes.
• Implementing a feature spread across several packages.
• Working with agents that run commands, read the output and correct their own approach.
• Doing the last review before a risky change goes to production.

Sol is also the safer pick when the problem description arrives half-finished and the model has to work out for itself which parts of the system matter.

Is it really better at code?

On the Artificial Analysis Coding Agent Index, which mixes implementation, terminal use and work in real repositories, Sol scored 80. Terra scored 77.4 and Luna 74.6.

On Terminal-Bench 2.1, Sol hit 88.8%, against 87.4% for Terra and 84.7% for Luna. On DeepSWE: 72.7%, 69.6% and 67.2%.

The gap is real. It just isn't wide enough to justify Sol for everything. On a CSS tweak, paying for the reasoning ceiling doesn't buy you a proportionally better result.

GPT-5.6 Terra: the everyday model

Terra is positioned as the middle ground between intelligence and cost, and it's probably where most developers will spend most of their time.

It costs half of Sol per token and handles scoped features, refactors, reviews and multi-step debugging that doesn't demand maximum reasoning.

When to use Terra

• Building a feature with clear requirements.
• Refactoring components or services.
• Turning a synchronous implementation into an asynchronous one.
• Reviewing a pull request.
• Writing tests for code that already exists.
• Chasing a bug that lives in a handful of files.
• Updating an API or a library.
• Writing moderately complex SQL queries.
• Producing implementation plans.
• Working with coding agents across several steps.
• Building screens against an existing design system.

In GitHub Copilot, Terra is described as the balanced option for interactive coding and everyday agentic work. Cursor recommends it for day-to-day development too.

Should it be everyone's default?

Not necessarily. In an independent Artificial Analysis breakdown, some Luna and Sol configurations landed in a better cost-and-intelligence position than the equivalent Terra configurations. Depending on the reasoning level, there's a cheaper Luna with a similar result, or a smarter Sol for the same total cost per task.

That doesn't make Terra pointless. It just means price per token isn't the whole story. The number of tokens generated, the number of attempts and the reasoning level all land in the final bill.

GPT-5.6 Luna: cheap doesn't mean incapable

Luna is the fastest and cheapest of the three. It was built for high-volume workloads with a cost ceiling.

For small, well-explained, easy-to-verify tasks, it usually gives you the best result per dollar.

When to use Luna

• Renaming variables, functions and files.
• Small HTML or CSS tweaks.
• Generating documentation.
• Explaining a function.
• Summarizing a pull request.
• Writing commit messages.
• Generating test names and skeletons.
• Creating mocks and sample data.
• Classifying errors or tickets.
• Extracting structured data from logs.
• Producing boilerplate.
• Converting data formats.
• Doing a first pass before handing the problem to a bigger model.
• Running repetitive automation at volume.

CodeRabbit suggests Luna for summaries, simple code explanations, pull request digests, first-pass checks, test names and changelog structure.

Can it ship features?

Yes, as long as the scope is closed. Early reports from Codex users say Luna handles ordinary fixes and small features when the instructions are clear. A tactic making the rounds in the community is Luna first, Terra when you need to explore more of the repository, and Sol for architecture, auth, payments or migrations.

Those reports are anecdotal and very recent, but they line up with the benchmarks: Luna loses ground as ambiguity and task horizon grow.

Reasoning level matters as much as the model

Sol, Terra and Luna all run at different reasoning levels:

none
low
medium
high
xhigh
max

The higher the level, the more time and tokens the model can spend weighing alternatives, running checks and revising its own solution.

That produces some odd results. On CursorBench 3.2:

• Luna High: 56.8%, average cost of US$ 0.82 per task.
• Terra High: 54.2%, average cost of US$ 0.89.
• Sol Low: 52.6%, average cost of US$ 1.01.

In that test, cranking up reasoning on the cheap model beat using a bigger model with little reasoning, and cost less. The takeaway isn't that Luna always wins. It's that picking by model name alone is a bad shortcut.

OpenAI's own advice is to start at medium reasoning, test lower levels when latency matters, and use High, XHigh or Max only when a real evaluation shows a gain. Max is for the hard jobs, not for everything.

What's the difference between Max and Ultra?

Neither is a new model.

Max lets a single model burn more compute exploring alternatives, running checks and revising its approach.

Ultra runs four agents in parallel by default. Each one can investigate a different part of the problem before the system stitches the results together.

On Terminal-Bench 2.1, plain Sol scored 88.8% and Sol Ultra reached 91.9%. The gain is real, and so is the much larger consumption.

Ultra makes sense when the work can actually be split up:

• Analyzing frontend, backend, database and infrastructure separately.
• Comparing architecture proposals.
• Investigating competing hypotheses for a critical bug.
• Planning a large migration.
• Auditing a whole codebase.
• Breaking technical research into independent tracks.

To fix a button, build a component or change a query, Ultra is a waste. Codex users report burning a sizable chunk of their limits in a single Ultra run. That depends on the plan and the task, so it isn't an official measurement, but it's a fair warning.

What GPT-5.6 costs on the API

OpenAI's published prices, per 1 million tokens:

For a task with 100k input tokens and 20k output tokens, no cache, Sol comes to roughly US$ 1.10, Terra US$ 0.55 and Luna US$ 0.22.

That's back-of-the-envelope math. Different models spend different amounts of reasoning tokens and may need more or fewer attempts to land on something you accept.

Watch out above 272k input tokens

The window goes to 1.05M, but requests with more than 272k input tokens move into a higher billing tier: input is multiplied by two and output by 1.5, for the entire request. Shipping the whole repository on every call gets expensive even on Luna.

Writing to the cache costs money too. A cache write runs at 1.25 times the normal input price, while reading already-stored tokens keeps the 90% discount. If your agent keeps pulling the same instructions, the same docs and the same parts of the repository, organizing the cache properly cuts the total bill.

Which model for which coding task

Small, mechanical edits

Luna Low or Medium. Copy changes, spacing tweaks, renaming symbols, generating docs, creating mocks, converting JSON, summarizing a diff.

A well-specified feature

Start on Luna High or Terra Medium. Pick Terra when the feature touches several files, depends on business rules or needs some exploration of the project.

A bug with no obvious cause

Terra Medium for the first pass. Move up to Sol Medium or High when you have several hypotheses, intermittent behavior or dependencies across systems.

Architecture, auth, payments and migrations

Sol Medium or High. Here an answer that looks right can plant a failure you won't find for weeks. The extra model cost is small next to the cost of a wrong implementation.

Code review

Luna for triage, Terra for the normal review, Sol for the critical changes. A flow that works:

Luna: summarize the diff and flag risk areas
Terra: review logic, tests and possible regressions
Sol: dig into only the critical points found

Frontend and interfaces

Luna is enough for small tweaks. For complete components and screens built against an existing system, Terra is usually the better call. Sol earns its keep when the task involves visual judgment, tricky responsive behavior, many states or inspecting the rendered result.

The official guidance for GPT-5.6 is to preserve existing components, design tokens and patterns, avoid adding elements nobody asked for, and render the interface before calling the task done.

Start small, move up when you have to

The basic routing:

Luna → Terra → Sol

But don't escalate just because the first answer disappointed you. Check first that the prompt states the expected result, the acceptance criteria, the relevant files, the technical constraints, the validation commands and what must not change.

A lot of failures we blame on the model come from a missing requirement or an instruction that contradicts another one. When the prompt is complete and the model still gets it wrong, then it's time to move from Luna to Terra, or Terra to Sol.

An API routing example

An application can pick the model by scope, risk and ambiguity:

import OpenAI from "openai";

const openai = new OpenAI();

type CodingJob = {
  prompt: string;
  scope: "small" | "medium" | "large";
  risk: "low" | "medium" | "high";
  ambiguous?: boolean;
};

function selectModel(job: CodingJob) {
  if (job.risk === "high" || job.scope === "large") {
    return {
      model: "gpt-5.6-sol",
      effort: "medium" as const,
    };
  }

  if (job.ambiguous || job.scope === "medium") {
    return {
      model: "gpt-5.6-terra",
      effort: "medium" as const,
    };
  }

  return {
    model: "gpt-5.6-luna",
    effort: "low" as const,
  };
}

async function runCodingJob(job: CodingJob) {
  const selected = selectModel(job);

  const response = await openai.responses.create({
    model: selected.model,
    reasoning: {
      effort: selected.effort,
    },
    input: job.prompt,
  });

  return response.output_text;
}

In production this router needs calibrating against your application's real tasks. Classifying by prompt size alone works worse than weighing risk, ambiguity, failure history and the cost of human review.

Writing better prompts for GPT-5.6

GPT-5.6 doesn't need a giant prompt. It gets more out of concrete instructions and verifiable criteria. A structure that works:

Goal:
What should be delivered.

Context:
Files, technologies and current behavior.

Acceptance criteria:
What has to work at the end.

Constraints:
What must not change.

Validation:
Tests, lint, build and commands to run.

Output:
How the result should be presented.

For coding, ask the model explicitly to:

1. Inspect the existing implementation before changing anything.
2. Preserve patterns and public APIs.
3. Run the tests related to the change.
4. Run type checking, lint and build where applicable.
5. Say which checks it couldn't run.
6. Not declare success without showing evidence of validation.

These points come straight from OpenAI's own prompting guidance for GPT-5.6.

Where each model is available

It depends on the product. In normal ChatGPT conversations, users on eligible plans reach Sol through the Medium, High and Extra high levels. Terra and Luna don't show up as options there.

In ChatGPT Work and Codex, Plus, Pro, Business and Enterprise users can pick any of the three. Free and Go users get Terra in certain products.

On the OpenAI API, all three are available directly. The family is also rolling out to GitHub Copilot and Cursor, with access depending on your plan and the gradual release.

So which one is best?

There's no outright winner.

Sol is the one you want when you need the highest chance of getting a hard problem right on the first try. Terra is the balanced pick for everyday development, when the scope isn't trivial but doesn't demand the ceiling either. Luna is the most efficient option for small, well-defined, repetitive work.

For a developer, the answer usually isn't one model. It's a flow:

Luna to execute
Terra to investigate
Sol to decide

And none of it has to be rigid. A Luna on high reasoning can beat a Terra on low, and a well-briefed Terra will solve tasks that looked like Sol material.

In the end, the cheapest model isn't the one with the lowest price per token. It's the one that gives you a correct, verifiable answer with fewer attempts and less rework.

Frequently asked questions

Which GPT-5.6 is best for coding?

Sol has the highest capability ceiling and wins on complex problems. For everyday work, Terra gives a better performance-to-cost ratio. For small, well-defined tasks, Luna is usually enough.

Can GPT-5.6 Luna build applications?

Yes, when the requirements are clear. It handles small applications and scoped features fine. Large, ambiguous projects with real architecture decisions belong to Terra or Sol.

Is Sol worth using for everything?

No. Simple changes don't benefit from the extra capability. Save Sol for hard problems, critical changes or situations where a wrong implementation would cost you.

What's the difference between Sol Max and Sol Ultra?

Max lets a single model reason for longer. Ultra coordinates several agents in parallel, four by default. Ultra burns far more and only pays off when the task can be split into independent tracks.

Is Terra always better than Luna?

No. Terra has more general capability, but a Luna set to higher reasoning can beat a cheaper Terra configuration on certain tasks. The choice depends on difficulty, reasoning level and the total cost of the run.

Do all three support 1 million tokens?

Yes, all three have a 1.05M token context window on the API. They just don't work equally well when the information is scattered across a very long context.

Can I select Terra or Luna in ChatGPT?

Not in standard conversations. Depending on your plan, they show up in ChatGPT Work, Codex and the OpenAI API.