GPT-5.6 Models: Sol, Terra, Luna—When to Use Which

Updated November 2, 2026. o4-mini was deprecated on October 23, 2026, and o3, o3-pro, and the gpt-5 family will be deprecated on December 11, 2026. The GPT-5.6 family remains available, but OpenAI now recommends the GPT-6 family for new projects: gpt-6-astra (most capable), gpt-6.1-sol, gpt-6.1-terra, and gpt-6-luna (see ChatGPT in 2026: From GPT-5.6 to GPT-6, Lesson 9). Both GPT-5.6 and GPT-6 support a pro reasoning mode (reasoning={"mode": "pro", "effort": "medium"}) for difficult tasks. Sources: Deprecations · Models · Reasoning.

The Models: Choosing the Right One for Each Task

As of July 9, 2026, the GPT-5.6 family is generally available: three models, each optimized for a different use case, with a reasoning level adjustable per request. Choosing the right model + reasoning combination is the single most impactful decision for your application’s quality and cost—a 25x factor separates the most expensive model from the most economical, and a comparable factor separates extreme reasoning settings.

All three models accept text and images as input, are multilingual, and are used via the Responses API. For detailed specifications (context windows, limits), consult the official models page at platform.openai.com.

Terra: Your Default Starting Point

Terra is the model you will use most often because it offers the best quality-to-price ratio for the majority of tasks: chatbots, content generation, summaries, translation, and general Q&A. The right approach is to start with Terra, measure the quality you get, and then move up to Sol only if the result isn’t good enough—not the other way around.

from openai import OpenAI
client = OpenAI()

# General use — Terra is perfect
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Write a professional email to request a meeting."
)
print(response.output_text)

Sol When Mistakes Are Costly

Sol is the highest-performing model in the family. Reserve it for situations where maximum quality is essential: analyzing high-stakes documents, tasks that benefit from deep reasoning, or anything a human would need to proofread line by line if the model made a mistake. Analyzing an annual report to extract key risks fits exactly into this category—an omission here carries a cost far outweighing the few cents saved on the API call.

# Demanding document analysis
with open("annual_report.txt", "r") as f:
    document = f.read()

response = client.responses.create(
    model="gpt-5.6-sol",
    input=f"Analyze this annual report and identify the 5 main "
          f"risks:\n\n{document}"
)
print(response.output_text)

Luna for Volume

Luna is optimized for speed and cost, making it ideal for large-scale repetitive processing: classification, data extraction, paraphrasing, and rapid prototyping. A flagship model’s reasoning adds no value when deciding whether a customer review is positive or negative; however, across 100,000 reviews, the price difference becomes the only variable that matters.

# Fast text classification
texts = [
    "This product is fantastic, I recommend it!",
    "Late delivery, non-existent customer service.",
    "Okay, nothing special.",
]

for text in texts:
    response = client.responses.create(
        model="gpt-5.6-luna",
        input=f"Classify the sentiment (positive/negative/neutral): {text}",
    )
    print(f"{text[:50]}... → {response.output_text}")

# Result:
# This product is fantastic, I recommend it!... → Positive
# Late delivery, non-existent customer service.... → Negative
# Okay, nothing special.... → Neutral

Reasoning: A Parameter, Not a Model

With the previous generation (o3, o3-pro, o4-mini), reasoning was embodied by dedicated models: you switched models to get reasoning capabilities. That is no longer the case. Every GPT-5.6 model accepts a reasoning parameter per request, with six effort levels—none, low, medium, high, xhigh, max.

# Complex reasoning problem: Sol + high effort
response = client.responses.create(
    model="gpt-5.6-sol",
    input="A snail is at the bottom of a 30-meter well. "
          "Each day, it climbs 3 meters but slips back 2 meters "
          "during the night. How many days does it take to get out? "
          "Explain your reasoning step by step.",
    reasoning={"effort": "high"}  # none, low, medium, high, xhigh, max
)
print(response.output_text)
# Detailed result with structured reasoning:
# Days 1 to 27: net progress of 1m/day → 27m
# Day 28: climbs 3m from 27m → reaches 30m and exits
# Answer: 28 days

The none level simply disables reasoning: the response is immediate and the cost minimal, which suits mechanical tasks like the classification above. The medium and high levels cover most technical tasks. Save xhigh and max for genuinely difficult problems, knowing that internal reasoning consumes tokens billed as output: in the snail riddle, the invisible thinking can weigh more heavily than the displayed answer. An additional setting, ultra, coordinates 4 agents in parallel by default, up to 16 on certain evaluations, for the heaviest tasks—with significantly higher token consumption.

If you are migrating code written for the previous generation (GPT-5.3, GPT-5.4, o3, o3-pro, o4-mini), here are the equivalents:

• o3 → gpt-5.6-sol, and o3-pro → gpt-5.6-sol with reasoning={"mode": "pro"} (designated replacements per the official deprecation table; then set effort to high, xhigh, or max based on difficulty)
• o4-mini → gpt-5.6-terra with reasoning set to medium
• gpt-5.3 / gpt-5.4 (general use) → gpt-5.6-terra
• High-volume tasks → gpt-5.6-luna

Dynamic Routing in Production

In production, you won’t have just one type of request but many, and hard-coding a single model means either overpaying for simple tasks or botching difficult ones. The router pattern involves centralizing the decision in a function, called before each request, that returns the appropriate configuration. You can then adjust it without touching the rest of the application.

def choose_config(task: str, complexity: str, budget: str) -> dict:
    """Selects the optimal model and reasoning effort."""
    if complexity == "high" and task in ["math", "code", "logic"]:
        return {"model": "gpt-5.6-sol", "reasoning": {"effort": "high"}}
    elif budget == "minimal" or complexity == "low":
        return {"model": "gpt-5.6-luna", "reasoning": {"effort": "none"}}
    elif task in ["diagnostic", "fine_classification"]:
        return {"model": "gpt-5.6-terra", "reasoning": {"effort": "medium"}}
    else:
        return {"model": "gpt-5.6-terra", "reasoning": {"effort": "low"}}

# Usage
config = choose_config(task="chatbot", complexity="medium", budget="standard")
response = client.responses.create(
    input="Your question here",
    **config
)

Pricing as of August 5, 2026—prices change regularly: before any budget calculation, verify the current rate card on the official OpenAI pricing page.

Key Takeaways

• Terra is the default choice for most tasks ($2 / $12 per MTok)
• Sol for maximum quality and deep reasoning ($5 / $30); Luna for volume ($0.20 / $1.20)
• Reasoning is a per-request parameter (none → max, plus ultra), not a separate model
• Migration equivalents: o3 → Sol; o3-pro → Sol in pro mode; o4-mini → Terra medium; GPT-5.3/5.4 → Terra
• In production, dynamically route to the right model + effort combination based on context