GPT-5.6 Sol vs Terra vs Luna: Which Tier Fits Your Workload?

GPT-5.6 turns a familiar model-selection question into a three-way routing problem. Sol is OpenAI’s flagship for complex professional work, Terra targets the middle of the cost-capability curve, and Luna is designed for high-volume workloads where efficiency matters most.

The tempting answer is to use Sol for everything important and Luna for everything cheap. That misses the point. The three models share a surprisingly broad technical envelope, so the practical decision depends on task difficulty, error cost, latency, and how well the result can be verified.

OpenAI released all three for general availability on July 9, 2026. They are available through the API, while selection inside ChatGPT Work and Codex depends on plan and rollout. This comparison focuses primarily on the documented API models, where the boundaries are clearest.

What all three models share

Sol, Terra, and Luna each have a 1,050,000-token context window, a maximum output of 128,000 tokens, a February 16, 2026 knowledge cutoff, configurable reasoning effort, text and image input, and text output. The model documentation lists support for functions, web and file search, code execution, hosted shell, computer use, MCP, skills, and tool search.

That shared surface is important. Choosing Luna does not necessarily mean giving up the ability to inspect an image or call a tool. Choosing Sol does not turn it into an audio or video generator. All three can act as the reasoning layer around specialized systems.

These launch prices exclude tool-specific charges. Prompts longer than 272,000 tokens also receive a long-context multiplier. If an agent searches the web, runs code, retries a failed call, and invokes a media API, model tokens are only one line in the cost ledger.

GPT-5.6 Sol: buy judgment, not prestige

Sol is the natural choice for tasks with ambiguous goals, many interacting constraints, or expensive failure. Examples include planning a cross-system migration, resolving contradictory evidence, reviewing a security-sensitive change, or synthesizing a board-ready artifact from messy sources.

OpenAI positions Sol as its strongest coding model and highlights gains in computer use and design judgment. The company’s launch evaluations show high performance across coding agents, professional knowledge work, science, and cybersecurity. Those results support Sol’s role as the escalation tier, but they do not mean it will dominate every narrow internal task.

Sol makes the most sense when:

• correctness is difficult to evaluate automatically;
• a weak plan will cause costly downstream work;
• the task spans several domains or repositories;
• the model must recover from incomplete or contradictory context;
• a senior human would otherwise spend substantial time reviewing the plan.

It makes less sense for deterministic extraction, routine polling, simple metadata transforms, or templated summaries. Paying for more capability cannot add value when the task itself leaves little room for judgment.

GPT-5.6 Terra: the default candidate

OpenAI describes Terra as the balanced model and says it roughly corresponds to the mini tier in earlier GPT-5 families. Its input and output prices are half of Sol’s, while its context, maximum output, modalities, and listed tool support remain the same.

That combination makes Terra a strong starting point for everyday agent workflows: code changes with tests, document analysis with structured outputs, multi-step tool calls, content operations, and support automation. It can also serve as a reviewer for Luna-produced work or as the first escalation when a cheaper attempt fails.

Terra is not automatically the best default. A simple classification system may still be dramatically cheaper on Luna, while a complex planning product may save money by starting on Sol and avoiding a failed intermediate run. The useful hypothesis is that Terra will cover a broad middle—not that every task belongs there.

GPT-5.6 Luna: scale with guardrails

Luna is priced at one-fifth of Sol for both uncached input and output. OpenAI calls it the fastest and most affordable GPT-5.6 tier and says it roughly corresponds to the nano tier used in earlier families.

High-volume, well-bounded work is the obvious fit:

• tagging and routing incoming requests;
• extracting fields into a strict schema;
• normalizing names, timestamps, or metadata;
• checking outputs against simple rubrics;
• drafting predictable variations from approved templates;
• monitoring task state and summarizing machine-readable errors.

Luna is most valuable when the application can detect a bad result. Schema validation, confidence thresholds, unit tests, media probes, and deterministic business rules turn a low-cost model into a reliable pipeline component. Without those controls, cheap mistakes may create expensive review work.

Compare successful outcomes, not token rates

Suppose Luna costs one-fifth as much per token but requires three attempts and a Terra review. It may still win—or it may not. The only reliable measure is cost per accepted task:

Total task cost = model tokens + tool charges + retries + external services + human review + failure impact

Latency should be measured the same way. Fast model output is irrelevant if it triggers an unnecessary five-minute rendering job. A slower planning pass can improve end-to-end time by selecting the right operation on the first try.

Build an evaluation set from actual requests, including awkward cases. Run each model with the same tools and acceptance criteria. Record pass rate, p50 and p95 completion time, token use, tool errors, and reviewer corrections. Avoid tuning the prompt only for one tier during the comparison.

A practical routing policy

Start with task classes rather than model names:

1. Routine and verifiable: route to Luna and validate automatically.
2. Multi-step but familiar: route to Terra, with bounded retries.
3. Ambiguous or high-impact: route directly to Sol.
4. Unexpected failure: preserve state, summarize the failure, and escalate one tier.
5. Final high-risk review: use Sol or require a qualified human, depending on the domain.

Do not ask one model to decide its own escalation solely from subjective confidence. Combine its signal with observable facts: context size, tool failures, contradictory sources, validation errors, or the monetary value of the action.

Caching adds another dimension. A stable policy and tool schema reused across many calls can make a larger model more economical than the headline rate suggests. Conversely, continually changing prompts prevent cache reuse and weaken cost predictability.

From model routing to a production media workflow

Media automation makes the routing tradeoff concrete because reasoning cost and rendering cost are separate. An agent may spend only seconds deciding what to do, while a video operation consumes minutes and paid credits. The cheapest model is not the one with the lowest token rate; it is the one that avoids launching the wrong media job.

Consider a batch of approved social clips that need brand marks and occasional subtitle cleanup. A layered workflow could use:

• Luna to inspect filenames, collect requested placements, and normalize a job manifest;
• Terra to select the correct operation and coordinate uploads and task status;
• Sol only when instructions conflict, a reference frame is ambiguous, or final visual review needs stronger judgment.

The actual editing remains a separate service. Medux can provide operations such as adding a logo or removing embedded subtitles through agent-accessible tools; this does not mean GPT-5.6 is built into Medux or that Medux is a native OpenAI feature.

The Codex MCP logo tutorial illustrates a concrete sequence: inspect the source and logo, request upload URLs, upload the files, start the task, poll its status, and download the finished video. The subtitle-removal tutorial shows the same asynchronous pattern for a different operation.

Routing should happen before an irreversible or billable action. A safe controller can let Luna prepare the request, Terra verify required parameters, and a human approve the upload or media job when the content is sensitive. If the job fails, keep its task ID and error payload; do not blindly start a duplicate on Sol.

This separation produces a durable architecture. Model tiers handle reasoning at different price points, deterministic code handles policy and validation, and specialized media tools perform the transformation. As Sol, Terra, and Luna evolve, the routing rules can change without rewriting the media workflow itself.