Skip to content
loke.dev
Three mechanical modules of different sizes travel on parallel rails beside a shared routing switch

GPT-5.6 Sol vs Terra vs Luna: Which Model Should You Use?

Compare GPT-5.6 Sol, Terra, and Luna for coding, agents, high-volume API work, context limits, reasoning controls, and current pricing.

Published 11 min read

GPT-5.6 gives developers three model names, but the choice is simpler than the naming suggests. Sol is the quality-first flagship, Terra is the practical default for everyday agent work, and Luna is the low-cost option for clear, repeatable, high-volume tasks.

The useful part is knowing when that default breaks. A model can be cheap per token and still cost more if it needs retries, produces longer answers, or misses cases that matter. A flagship model can also be wasteful when the task is a well-specified extraction job. This guide turns the current model and pricing docs into a routing process you can test.

The short answer

  • Choose GPT-5.6 Luna when the task is narrow, repeatable, easy to grade, and run at high volume.
  • Choose GPT-5.6 Terra for normal production coding, document work, tool use, and agent tasks that need judgment without the full cost of Sol.
  • Choose GPT-5.6 Sol for ambiguous architecture work, difficult debugging, deep research, high-value reviews, and tasks where polish or missed edge cases are expensive.

OpenAI's current model guide gives the same high-level split: Sol for complex reasoning and coding, Terra for a balance of intelligence and cost, and Luna for cost-sensitive high-volume workloads. If you have no evaluation data yet, Terra is the sensible operational baseline, while OpenAI recommends Sol when you are unsure and quality matters more than usage.

What is actually the same across all three

The individual pages for Sol, Terra, and Luna currently publish the same technical envelope:

  • 1,050,000-token context window.
  • 922,000 maximum input tokens and 128,000 maximum output tokens.
  • February 16, 2026 knowledge cutoff.
  • Text and image input, with text output.
  • Responses, Chat Completions, and Batch endpoints.
  • Streaming, Structured Outputs, function calling, file search, image input, web search, and prompt caching.
  • The same documented tool set, including web search, file search, image generation, code interpreter, hosted shell, apply patch, skills, computer use, MCP, and tool search.

That shared feature list matters. Luna is not a tiny text-only endpoint and Sol does not get a larger context window. The main documented differences are intended workload, capability, price, and the amount of usage you can get from a Codex plan. Model choice is an economic and quality decision, not a basic compatibility decision.

Sol: use it when the task is hard to specify

Sol is the frontier member of the family. It is the right fit when you cannot reduce the task to a stable checklist before the run starts, or when the model must discover important work while inspecting code, files, tools, or external evidence.

  • Large code changes that cross architectural boundaries.
  • Debugging where the failure mechanism is still unclear.
  • Security review, high-value code review, and migration planning.
  • Research that requires reconciling sources and tracking caveats.
  • Polished documents or interfaces where judgment and finish matter.

Do not route every request to Sol because it is the flagship. A clear transformation, classifier, or templated support task rarely needs the most expensive model. Sol earns its place when failure is costly, the search space is large, or you cannot describe the correct path in advance.

The unsuffixed gpt-5.6 alias currently routes to gpt-5.6-sol. Use the explicit gpt-5.6-sol ID when a router or evaluation report must make the choice visible.

Terra: the production default

Terra is the middle tier and usually the best first deployment target. It keeps the full context, modalities, endpoints, and tool support while charging 40 percent of Sol's standard short-context token rates.

  • Feature work with a clear issue and normal repository context.
  • Routine code review, test generation, and documentation.
  • Tool-using agents with bounded goals and several steps.
  • Document analysis, reporting, and structured research.
  • Workflows where Luna's errors would cause enough retries to erase its price advantage.

Terra is also a good coordinator in a multi-model system. Let it classify risk, choose a specialist path, and escalate only the difficult cases to Sol. That keeps routing explainable and gives you a useful audit trail when costs change.

Luna: cheap enough to change the architecture

Luna is designed for cost-sensitive, high-volume work. Its current standard short-context input and output prices are one tenth of Terra's. That gap is large enough to justify a separate fast path rather than treating Luna as a minor discount.

  • Classification, extraction, normalization, tagging, and routing.
  • Structured summaries with a strict schema and easy validation.
  • Background maintenance tasks with a cheap retry path.
  • Focused coding tasks with a precise definition of done.
  • Parallel workers that return small, checkable results to a stronger coordinator.

The boundary is grading. Luna fits when your application can quickly tell whether the result is usable. If correctness depends on subtle judgment that you cannot encode in tests, a low token price is not enough evidence that Luna is cheaper in production.

GPT-5.6 API pricing, checked August 2, 2026

OpenAI's API pricing page lists prices per one million tokens. The short-context standard rates are:

Standard API pricing, short context, USD per 1M tokens

Model   Input   Cached input   Cache write   Output
Sol     $5.00   $0.50          $6.25         $30.00
Terra   $2.00   $0.20          $2.50         $12.00
Luna    $0.20   $0.02          $0.25         $1.20

A request with more than 272,000 input tokens uses the long-context rates for the full request. Input doubles and output rises by 50 percent:

Standard API pricing, long context, USD per 1M tokens

Model   Input    Cached input   Cache write   Output
Sol     $10.00   $1.00          $12.50        $45.00
Terra   $4.00    $0.40          $5.00         $18.00
Luna    $0.40    $0.04          $0.50         $1.80

Batch and Flex currently cost half of the matching standard rates. Fast mode costs twice the short-context standard rates. Regional processing for eligible data-residency endpoints adds a 10 percent uplift. Amazon Bedrock bills through AWS, so do not apply the direct OpenAI table to a Bedrock deployment.

Cache writes cost 1.25 times the uncached input rate, while cache reads are discounted. A cache is not automatically a saving if the prefix changes often enough that you keep paying to write it. Track cache writes and reads separately.

A worked cost example

Suppose a short-context Terra request reads 100,000 input tokens, of which 80,000 are cached, and produces 10,000 output tokens:

uncached input: 20,000 / 1,000,000 × $2.00  = $0.040
cached input:   80,000 / 1,000,000 × $0.20  = $0.016
output:         10,000 / 1,000,000 × $12.00 = $0.120
total                                              $0.176

For the same token counts, Luna costs $0.0176 and Sol costs $0.44 at current standard short-context rates. Those numbers compare billing only. A real evaluation must also measure whether a model changes output length, tool calls, retries, or task success.

Long context changes the calculation sharply. A 300,000-token uncached input plus 10,000 output tokens costs about $3.45 on Sol, $1.38 on Terra, or $0.138 on Luna at the current long-context standard rates. Before sending a whole repository or archive, test whether retrieval can narrow the input without removing evidence the task needs.

A verified short-context cost calculator

This JavaScript example was run with Node.js 24. It intentionally rejects inputs above 272,000 tokens so it cannot silently apply the short-context table to a long-context request.

const rates = {
  "gpt-5.6-sol": { input: 5, cachedInput: 0.5, output: 30 },
  "gpt-5.6-terra": { input: 2, cachedInput: 0.2, output: 12 },
  "gpt-5.6-luna": { input: 0.2, cachedInput: 0.02, output: 1.2 },
};

function estimateStandardCost({
  model,
  inputTokens,
  cachedInputTokens = 0,
  outputTokens,
}) {
  const price = rates[model];
  if (!price) throw new Error(`Unknown model: ${model}`);
  if (inputTokens > 272_000) {
    throw new Error("Use the long-context rate card above 272K input tokens");
  }
  if (cachedInputTokens > inputTokens) {
    throw new Error("cachedInputTokens cannot exceed inputTokens");
  }

  const uncachedInputTokens = inputTokens - cachedInputTokens;
  return (
    (uncachedInputTokens * price.input +
      cachedInputTokens * price.cachedInput +
      outputTokens * price.output) /
    1_000_000
  );
}

console.log(
  estimateStandardCost({
    model: "gpt-5.6-terra",
    inputTokens: 100_000,
    cachedInputTokens: 80_000,
    outputTokens: 10_000,
  }),
); // 0.176

Codex and ChatGPT pricing is a different system

A ChatGPT plan does not bill each local Codex message from the API dollar table. Codex pricing uses included limits and credits, while API-key authentication uses standard API token billing. ChatGPT Work and Codex share the same usage budget.

  • Plus is currently $20 per month and includes the GPT-5.6 family.
  • Pro starts at $100 per month for 5x Plus limits, with a $200 tier for 20x limits.
  • Business is $20 per user per month when billed annually, or $25 monthly, with a two-user minimum.
  • API-key usage is token-based and does not include cloud-only features such as GitHub code review or Slack integration.

OpenAI presents Codex local-message limits as ranges because repository size, context, reasoning, tools, retrieval, caching, and task length all affect a turn. The current Plus ranges per shared five-hour window are roughly 10 to 100 local Sol messages, 25 to 200 Terra messages, or 250 to 2,000 Luna messages. Weekly limits can also apply.

After included usage, the current credit rate card per one million tokens is 125 input, 12.5 cached input, and 750 output credits for Sol; 50, 5, and 300 for Terra; and 5, 0.5, and 30 for Luna. Check the live pricing page before budgeting because plan limits and rates can change independently of the model API.

Choose the model and reasoning effort together

The GPT-5.6 guidance lists none, low, medium, high, xhigh, and max reasoning efforts. Model size and reasoning effort are separate controls.

  • Start with low for latency-sensitive, well-scoped work.
  • Use medium as a balanced baseline for tool use and multi-step work.
  • Move to high or xhigh only when your evaluation shows a useful quality gain.
  • Reserve max for the hardest quality-first tasks.

Do not assume Terra at max is always better or cheaper than Sol at low, or that Luna at high beats Terra at medium. Token use, latency, and failure modes depend on the workload. Test those pairs on the same cases.

Pro mode is also separate from the model name. Keep Sol, Terra, or Luna and set reasoning.mode to pro. There is no gpt-5.6-pro slug. Pro mode can improve difficult results by doing more model work, but it increases latency and reports the aggregated tokens for billing.

A small model router

This routing function was checked with Node.js 24. It is intentionally conservative: ambiguity or high value sends a task to Sol, clear high-volume work goes to Luna, and everything else starts on Terra.

const GPT56_MODELS = {
  luna: "gpt-5.6-luna",
  terra: "gpt-5.6-terra",
  sol: "gpt-5.6-sol",
};

function chooseModel({ repeatable, highVolume, ambiguous, highValue }) {
  if (ambiguous || highValue) return GPT56_MODELS.sol;
  if (repeatable && highVolume) return GPT56_MODELS.luna;
  return GPT56_MODELS.terra;
}

const model = chooseModel({
  repeatable: true,
  highVolume: true,
  ambiguous: false,
  highValue: false,
});

console.log(model); // gpt-5.6-luna

In production, replace the booleans with observable rules. Examples include whether a JSON schema validator can grade the output, whether a human must approve the result, the cost of a false negative, and whether the request contains enough context to resolve ambiguity.

Call the selected model with the Responses API

The next snippet follows the current Responses API shape but is illustrative because it requires your own OpenAI SDK installation and API key.

import OpenAI from "openai";

const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-5.6-terra",
  input: [
    {
      role: "user",
      content:
        "Review this deployment plan. Return the five highest-risk failure modes, evidence for each, and one concrete mitigation.",
    },
  ],
  reasoning: {
    effort: "medium",
  },
  text: {
    verbosity: "medium",
  },
});

console.log(response.output_text);

Use the Responses API for reasoning, tools, and multi-turn work. Keep the model ID, reasoning effort, service tier, input tokens, cached tokens, output tokens, latency, and evaluation result in the same trace. Without that record, a routing change is hard to evaluate and harder to roll back.

How to evaluate Sol, Terra, and Luna on your work

A useful comparison starts with real tasks, not a general leaderboard. Create a small set that represents the work you will actually send to the model.

  • Include routine successes, known edge cases, and several tasks that previously failed.
  • Write pass criteria before running the models. Prefer executable tests, schema validation, source checks, or a short human rubric.
  • Run the same prompt and tools against Luna, Terra, and Sol at the same reasoning effort.
  • Record task success, serious defects, latency, input, cache writes, cache reads, output, tool calls, retries, and total cost.
  • Then compare adjacent configurations such as Luna high versus Terra medium, or Terra high versus Sol medium.

Promote the cheapest configuration that meets the quality and latency target. Route only the failure-prone category upward. This is usually cheaper and easier to reason about than a single global model choice.

For generated code, keep the human and test boundaries from the loke.dev AI code review checklist. A cheaper model is not a reason to weaken review around authentication, payments, migrations, secrets, or destructive operations.

Common routing mistakes

Using gpt-5.6 without realizing it means Sol

The alias currently routes to Sol. That is a reasonable quality-first default, but it can hide a cost decision. Use explicit tier names in routers, evaluation reports, and budget alerts.

Comparing only the posted token prices

A model that needs retries or writes twice as much output may not preserve its headline price advantage. Compare completed-task cost, not only the rate card.

Ignoring the 272K pricing boundary

Once input crosses 272,000 tokens, the long-context rates apply to the full request. Retrieval, file selection, and smaller tool results can matter more than switching models.

Turning up reasoning before fixing the prompt

Give the model the goal, hard constraints, approval boundaries, required evidence, and a definition of done. Higher reasoning cannot recover missing business rules or an untestable success criterion.

Treating the model tier as a permanent architecture decision

OpenAI already changed Terra and Luna pricing on July 30, 2026, according to the API changelog. Keep model choice in configuration, rerun a compact evaluation set when prices or snapshots change, and make rollback cheap.

A practical default for each environment

  • Interactive coding: start with Terra medium. Escalate ambiguous debugging, architecture, or final review to Sol.
  • CI and background automation: start with Luna low or medium when output is schema-checked. Escalate failed validation to Terra.
  • Research and document production: start with Terra medium. Use Sol for conflicting sources, high-stakes decisions, or a polished final artifact.
  • Repository-wide migration: use Sol for the plan and risky changes, Terra for well-scoped implementation batches, and Luna for mechanical scans or structured inventories.
  • High-volume API classification: start with Luna and a strict schema. Sample results continuously and keep a Terra fallback for low-confidence cases.

The three models share a large technical envelope, so you can keep one integration and move the routing decision into configuration. Start with Terra when the work is ordinary, Luna when success is easy to check, and Sol when the task is ambiguous or expensive to get wrong. Then let your own evaluations, not the tier names, decide where each boundary belongs.