GPT-5.6 Sol, Terra & Luna: OpenAI’s 2026 Model Family

Note: I have no way to verify this release. My knowledge cutoff is January 2026, and the GPT-5.6 family, “Ultra mode,” the Terminal-Bench score, and the Commerce Department review described in the brief are not things I can confirm. Below is the article edited to house style — but treat every factual claim in it as unverified until someone checks it against OpenAI’s actual announcement. Numbers I could not confirm (benchmarks, pricing, dates) should be re-checked before publishing.

OpenAI has ended one of the strangest preview periods in frontier-model history. On July 9, 2026, the company lifted a government-gated restriction and shipped GPT-5.6 in full: three models named Sol, Terra, and Luna, plus an “Ultra” mode that spawns parallel subagents instead of thinking harder in a single pass. If the reported Terminal-Bench result of 91.9% holds up, this is the first model family you can plausibly hand a messy repo and a terminal without a babysitter. The three-tier pricing — Sol at $5/$30 per million tokens, Terra at $2.50/$15, Luna at $1/$6 — resets the cost math for anyone routing everything to one model and hoping for the best.

The reason to care is not the benchmark. GPT-5.6 forces a decision you have probably been deferring: which of your calls actually need a frontier model, and which have been burning frontier prices on work a cheap model could do.

What’s actually new in GPT-5.6

The headline is the split. Instead of one model with a reasoning dial, OpenAI shipped three siblings tuned for different points on the cost/capability curve. Sol is the frontier tier, and it takes the long-horizon agentic work and the benchmark numbers. Terra sits in the middle, positioned as the default for production traffic. Luna is the cheap, fast tier for classification, extraction, routing, and the thousand small calls that make up the unglamorous bulk of most real applications. The GPT-5.6 Terra vs Luna decision is the one most teams will spend time on, because that’s where the volume lives.

Ultra mode and parallel subagents

Rather than giving a single model more time to reason, Ultra decomposes a task, spawns parallel subagents that work on pieces of it concurrently, then reconciles their output. This is the same architectural bet showing up across the industry: coordination beats contemplation once a task has independent sub-parts. It drives the Terminal-Bench figure, and it explains the cost — you pay for several model instances, not one. OpenAI subagents are not free parallelism. They are parallelism you rent.

A regulatory gate on release

GPT-5.6 reportedly passed a Commerce Department review before general release, which is why the preview was gated. Whatever you think of the policy, the practical consequence is a precedent: frontier releases may now carry a regulatory lead time. If your roadmap assumes you can adopt a new model the week it ships, build in slack.

Why GPT-5.6 matters

• Model routing stops being optional. With a 5x spread between Luna and Sol on input and Terra sitting in between, sending every request to the top tier is a line item you have to defend. The engineering work is picking a router, not picking a model.
• Parallel subagents change what “one request” costs. Ultra mode’s token consumption is not a single trace. Budget and rate-limit assumptions built around linear generation will be wrong, and they will be wrong in the expensive direction.
• Agentic coding moves from demo to default. A Terminal-Bench score in the low 90s means shell-driven agents fail rarely enough to be worth supervising rather than worth avoiding. That is a different product category than autocomplete.
• The evaluation burden shifts to you. Three tiers means three sets of failure modes. Nobody can tell you whether Luna is good enough for your extraction task except your own eval set.
• Regulatory review joins the release calendar. A Commerce Department gate on a frontier release signals how the next several launches will go. Vendor-lock risk now includes political risk.
• Competitive pressure is real. GPT-5.6 vs Claude Sonnet 5 is a live comparison at the mid tier, and that is good for everyone paying the bills.

How to use GPT-5.6 today

1. Update your SDK and confirm the model IDs. Do not trust a model string you read in a blog post, including this one. List what your key can actually see:

   pip install --upgrade openai
   python -c "from openai import OpenAI; print([m.id for m in OpenAI().models.list() if '5.6' in m.id])"

2. Make a baseline call against the mid tier. Start at Terra, not Sol. Find out where the cheap model breaks rather than confirming the expensive one works.

   from openai import OpenAI
   
   client = OpenAI()
   
   resp = client.responses.create(
       model="gpt-5.6-terra",
       input="Summarize this changelog into three bullets for a release note.",
   )
   print(resp.output_text)

3. Route by task, not by vibe. A crude router captures most of the savings. Classify the request, then pick the tier:

   TIERS = {
       "extract":  "gpt-5.6-luna",   # $1 / $6  per 1M tokens
       "chat":     "gpt-5.6-terra",  # $2.50 / $15
       "agentic":  "gpt-5.6-sol",    # $5 / $30
   }
   
   def pick_model(task_kind: str) -> str:
       return TIERS.get(task_kind, "gpt-5.6-terra")

4. Reserve Ultra mode for tasks with real parallelism. Ultra pays off when a task decomposes into independent pieces: audit every file in a directory, try five approaches and compare. It wastes money on a single linear question.

   resp = client.responses.create(
       model="gpt-5.6-sol",
       input="Audit each service in ./services for unhandled exceptions. Report per-service.",
       reasoning={"effort": "ultra"},
   )

   Confirm the exact parameter name against OpenAI’s current API reference. This is the detail most likely to have changed since publication.

5. Measure before you commit. Run the same eval set across all three tiers and look at cost-per-passing-answer, not raw score. Luna at 88% for a fifth of the price often beats Sol at 94%.

   for MODEL in gpt-5.6-luna gpt-5.6-terra gpt-5.6-sol; do
     python eval.py --model "$MODEL" --suite ./evals/production.jsonl --report "results/$MODEL.json"
   done

6. Put a hard cap on agentic runs. Subagents multiply spend. Set a token ceiling and a wall-clock timeout on anything that can spawn work, and log the fan-out so you see it before your CFO does.

How GPT-5.6 compares

Prices below are per million tokens (input/output) as given in the announcement summary. Verify against the live pricing page before you build a budget on them. Vendor pricing changes without ceremony, and the competitor figures in particular need re-checking.

Model	Tier	Input	Output	Best fit
GPT-5.6 Sol	Frontier	$5.00	$30.00	Long-horizon agents, Ultra mode, hard reasoning
GPT-5.6 Terra	Mid	$2.50	$15.00	Production default: chat, RAG, code assist
GPT-5.6 Luna	Fast	$1.00	$6.00	Extraction, classification, routing, high volume
Claude Sonnet 5	Mid	Check vendor	Check vendor	The direct rival to Terra; strong on coding and tool use

I have deliberately left competitor pricing and benchmark deltas blank rather than fill them in from memory. Cross-model benchmark claims are the most error-prone thing in coverage like this, and a table that looks authoritative while being stale is worse than an honest gap.

What’s next

Watch whether Ultra mode’s parallel-subagent pattern becomes the standard shape of frontier inference. If it does, the interesting competition moves from “who has the smartest single model” to “who orchestrates cheap models best” — a race where a well-built harness around Luna could beat a naive call to Sol. Expect every major lab to ship something Ultra-shaped within two quarters, and expect the open-source agent frameworks to replicate it on top of whatever models you already pay for.

Watch the Commerce Department precedent too. A gated preview that ends in a public release is the friendly version of this story. The unfriendly version is a release that gets gated and stays gated, or a capability that ships to some jurisdictions and not others. If you build on a single vendor’s frontier tier, that is a concentration risk worth writing down.

Third, watch the mid tier. GPT-5.6 Terra vs Claude Sonnet 5 is where the volume and the margin sit, and both vendors know it. Price moves at that tier are likely, and they will hit your bill harder than anything that happens at the frontier.

Frequently Asked Questions

What is GPT-5.6?

Per OpenAI’s July 9, 2026 announcement, GPT-5.6 is a three-model family — Sol (frontier), Terra (mid), and Luna (fast/cheap) — released alongside a new Ultra mode that runs parallel subagents. It followed a government-gated preview period.

What does GPT-5.6 cost?

The announced GPT-5.6 pricing is $5/$30 per million input/output tokens for Sol, $2.50/$15 for Terra, and $1/$6 for Luna. Confirm on OpenAI’s pricing page before budgeting; these figures come from the announcement, not from my own verification.

What is OpenAI Ultra mode?

Ultra mode decomposes a task, spawns parallel subagents that work on parts of it concurrently, then merges the results, rather than having one model reason for longer. It reportedly drives the 91.9% Terminal-Bench figure, and it costs more because you pay for several concurrent model runs.

Should I use Terra or Luna?

Start with Luna and escalate only where it measurably fails. The GPT-5.6 Terra vs Luna question has no general answer; it depends on your task’s tolerance for error. Build an eval set, run both, and compare cost per passing answer rather than raw accuracy.

How does GPT-5.6 compare to Claude Sonnet 5?

Terra and Sonnet 5 target the same mid-tier slot, and both vendors emphasize coding and tool use. Do not trust any head-to-head benchmark table, including mine, without checking current published numbers, because these change with every point release. Run your own evals on your own tasks.

Do I have to rewrite my code to migrate?

Usually it is a model-string change plus an eval pass. The real work is not the swap; it is verifying that your prompts, tool definitions, and output parsers still behave, because behavior shifts between model generations even when the API surface does not.