OpenAI launched its newest flagship model on July 9, 2026, and this time there is no single model to pick. Instead, GPT-5.6 comes in three sizes: Luna (the smallest and cheapest), Terra (the middle option), and Sol (the largest and most expensive). The naming scheme is new, the pricing is aggressively competitive, and the benchmark claims center on a specific kind of task: long-running agent workflows where a model works autonomously through many steps.
GPT-5.6 Sol scored 53.6 on Agents' Last Exam, a benchmark of long-running professional tasks across 55 fields, beating Anthropic's Claude Fable 5 by 13.1 points. Even the smaller Terra and Luna models reportedly outperform Fable 5 at roughly one-sixteenth the cost. If those numbers hold up, the pricing landscape for AI models just shifted significantly.
But before you rush to switch your project over, the picture is more complicated than the headline suggests. One major coding benchmark tells a different story, and the early hands-on reports are mixed.
What did OpenAI actually launch on July 9?
Three models, all sharing the same architecture family but at different scales:
- GPT-5.6 Luna: $1 per million input tokens, $6 per million output tokens. The smallest and fastest of the three.
- GPT-5.6 Terra: $2.50 per million input tokens, $15 per million output tokens. The middle tier.
- GPT-5.6 Sol: $5 per million input tokens, $30 per million output tokens. The flagship.
If you are new to token pricing: "tokens" are the chunks of text that models read and produce. One million tokens is roughly 750,000 words, or about the length of a long novel. "Input tokens" are what you send to the model: your prompt, your code, any documents you attach. "Output tokens" are what the model generates back. Output tokens always cost more because generating text takes more computation than reading it.
All three models share a few key specs. They have a knowledge cutoff of February 16, 2026, meaning they have not been trained on events after that date. They support a 1 million token context window, which is the maximum amount of text you can include in a single prompt. And they can produce up to 128,000 output tokens in a single response, which is more than enough for most tasks but matters for things like generating long code files.
For context on pricing, Anthropic's Claude Opus series costs $5 per million input tokens and $25 per million output tokens. Claude Fable 5, Anthropic's top reasoning model, costs $10 per million input and $50 per million output. So GPT-5.6 Sol sits between those two on price, while Luna and Terra are substantially cheaper than anything in Anthropic's lineup.
The chart below lays out the full pricing picture side by side.
How much cheaper are the smaller GPT-5.6 models really?
The headline efficiency claim is striking. OpenAI says that on Agents' Last Exam, even GPT-5.6 Terra and Luna outperform Claude Fable 5 at around one-sixteenth the cost. That is a big claim, and it comes with a caveat built in: the cost comparison depends on "reasoning tokens."
Reasoning tokens are a relatively new concept. When you ask a model a complex question, it can spend extra computation "thinking" before it produces its answer. These internal thinking steps consume output tokens, and different models use wildly different numbers of them for the same task. A model that produces 10,000 reasoning tokens to solve a problem costs more than one that solves it with 2,000, even if both arrive at the same answer.
This is why Simon Willison, who had early access to GPT-5.6 Sol, notes that price per million tokens "doesn't tell us much now that the number of reasoning tokens can differ so much between models for the same task." The sticker price is a starting point, not the final bill.
GPT-5.6 introduces a sliding scale of reasoning effort. You can set the model to "none," "low," "medium," "high," "xhigh," or "max." Lower effort means fewer reasoning tokens and lower cost, at the risk of lower quality. Higher effort means the model thinks longer, costs more, and may produce better results on hard problems.
Willison ran the same task (describing an image of pelicans) across all 18 combinations of model and effort level. The cheapest result was GPT-5.6 Luna at effort "none" for 0.71 cents. The most expensive was GPT-5.6 Sol at effort "max" for 48.55 cents. That is a 68x difference in cost for the same task, depending on which model and effort level you choose.
For a beginner, the practical takeaway: start with Luna at medium effort for most tasks. Bump up to Terra or Sol only when you hit quality problems you cannot solve with better prompting. Most everyday coding, writing, and analysis tasks do not need max reasoning.
Do the benchmarks mean GPT-5.6 is better for coding?
Here is where the story gets messy. On Agents' Last Exam, which tests long-running multi-step workflows, the GPT-5.6 family looks strong. But on SWE-Bench Pro, a benchmark that tests whether a model can fix real bugs in real open source projects, Claude Fable 5 scored 80% while GPT-5.6 Sol scored 64.6%.
That is a significant gap in the opposite direction. OpenAI's response was to publish an article the day before the launch calling out problems with SWE-Bench Pro itself, estimating that about 30% of SWE-Bench Pro tasks are broken and advising developers to examine results carefully.
Read that timing however you want. The practical point is that two well-known benchmarks disagree about which model is better for coding, and the benchmark disagreement maps to what early users are reporting. Willison says GPT-5.6 Sol is "definitely very competent" but that it "hasn't struck me as better than Fable at the kind of complex coding tasks" he has been using.
If you are choosing a model for serious software development work today, the benchmark picture does not give you a clean answer. The best approach is to test both on your own tasks and trust your own results over any leaderboard.
The chart above shows the two benchmarks side by side, and the disagreement is plain to see.
What new API features should a beginner care about?
GPT-5.6 ships with several new API features that matter even if you are just starting to build with AI:
- Programmatic Tool Calling: The model can write and run JavaScript code that coordinates multiple tool calls in a single step. If you have used MCP (Model Context Protocol) servers, this is a step toward letting the model orchestrate tools more intelligently rather than calling them one at a time. For beginners, this means the model can handle more complex multi-step actions without you writing as much glue code.
- Multi-agent support: The model can spin up subagents for parallel, focused work. Instead of one model doing everything sequentially, it can delegate pieces of a task to smaller copies of itself and combine the results. This is the subagent pattern that advanced developers have been building by hand, now baked into the API.
- Prompt cache breakpoints: You can now tell OpenAI's API exactly where to cache your prompt to reduce costs on repeated calls. Previously, OpenAI detected cache points automatically. Anthropic has offered manual cache breakpoints for a while. If your app sends the same large system prompt with every request, this feature can cut your input costs significantly.
- Image detail control: You can now set "detail: original" on image requests to prevent the API from resizing your images before processing. This matters if you are working with screenshots or diagrams where small details carry meaning.
None of these are beginner-only features, but they all push toward the same trend: the API is becoming more capable of autonomous, multi-step work with less hand-holding from your code. If you are just starting, you do not need any of them on day one. But knowing they exist helps you understand what your tools can grow into.
For a deeper dive on how tool-calling APIs work under the hood, our MCP explainer for beginners covers the fundamentals.
Which GPT-5.6 model should you start with?
The honest answer for most beginners: start with Luna. At $1 per million input tokens, it is cheap enough that you can experiment freely without worrying about your bill. Use medium reasoning effort as your default. You will get good results on most tasks: writing code, summarizing documents, answering questions, drafting emails.
Move up to Terra when you notice Luna struggling with multi-step reasoning or producing shallow answers on complex tasks. The jump from $1 to $2.50 per million input tokens is modest, and the quality improvement is real.
Reserve Sol for the hardest problems: complex debugging, long-form generation, tasks that require the model to reason through many steps. At $5 per million input and $30 per million output, it is not expensive by historical standards, but those reasoning tokens add up fast if you are running it at max effort in a loop.
If you are already using Claude Fable 5 and it is working well for your coding tasks, there is no urgent reason to switch. The benchmark evidence does not clearly favor GPT-5.6 for software development. Test Sol on your own codebase, compare the results, and decide based on your actual work, not the leaderboard.
One more thing worth knowing: OpenAI also recently shipped GPT-Live full-duplex voice mode, which is a separate capability from the model family itself. The GPT-5.6 models can be used with voice, text, and image inputs, so the choice of model size and the choice of interface are independent decisions.
What should I watch for over the next few weeks?
Three things will determine whether GPT-5.6 lives up to its launch claims.
First, whether independent developers reproduce the Agents' Last Exam results. OpenAI's own benchmark numbers are a starting point, not a verdict. Watch for third-party evaluations over the coming weeks.
Second, whether the coding benchmark gap is real or an artifact of SWE-Bench Pro's reported flaws. If other coding benchmarks also favor Fable 5, the gap is probably genuine. If they favor GPT-5.6, then SWE-Bench Pro may indeed be misleading.
Third, how the reasoning effort settings hold up in production. The 68x cost range between Luna at "none" and Sol at "max" gives you a lot of room to tune, but it also means you need to monitor your actual token usage, not just your model choice. A model running at max effort in a loop can burn through a budget faster than you expect.
The bottom line
GPT-5.6's real contribution is the pricing structure that lets you pick the right size for each task, plus an API that is learning to do more of the orchestration work on its own. Start small, measure your actual costs, and let your own results guide the upgrade path.
Sources
- simonwillison.net: The new GPT-5.6 family: Luna, Terra, Sol
