GPT-6 Astra vs Sol vs Luna: Which OpenAI Model (and Effort Level) to Use When

OpenAI's old lineup split into two kinds of model: GPT-4o, which answered fast with no internal reasoning, and the o-series (o1, o3, o3-mini), which thought before answering and cost more for it. Picking a model meant picking a family.

That split is gone. GPT-6 Astra, Sol and Luna are three sizes of the same reasoning-capable family, and how much they think is a request-level setting, not a model choice. This guide covers how to pick a tier and an effort level for your task.

What changed: one family, an effort dial

Under the old system you chose whether to reason (GPT-4o vs. o-series) and separately how capable a model to use. Under GPT-6, every tier reasons, and reasoning.effort controls how much:

• GPT-6 Astra ($10 / $50 per 1M tokens): the flagship. OpenAI recommends it for most reasoning workloads.
• GPT-6 Sol ($2 / $10): the balanced tier for everyday production work.
• GPT-6 Luna ($0.10 / $0.50): the fast, cheap tier for high-volume classification and extraction.

All three take a 1.05M-token context window, output up to 128K tokens, and accept text and images.

The old "GPT-4o for speed, o-series for hard reasoning" mental model becomes two separate decisions now: which tier, and how much effort.

Choosing a tier

Pick the cheapest tier that could plausibly do the job, then test it on real examples:

Luna fits:

• Simple classification and routing
• Short extraction and structured output
• FAQ-style Q&A with well-defined answers
• First-pass filtering before a bigger model sees anything
• Any high-volume task where the cost of a bigger model isn't justified

Sol fits:

• Writing, summarization, translation, explanation
• Multi-turn chat and interactive workflows
• Standard coding tasks — writing functions, explaining code, routine debugging
• Most multimodal tasks (image analysis, document understanding)
• Tool calling and structured output at moderate volume

Astra fits:

• Multi-step math, proofs, competition-level problems
• Complex coding: algorithmic design, subtle logic bugs, whole-system invariants
• Strategic analysis with many interacting constraints
• Long-horizon agentic work
• Anything where a smaller tier is consistently giving you wrong or inconsistent answers

Choosing an effort level

Within whichever tier you pick, reasoning.effort is the second dial:

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-6-sol",
    reasoning={"effort": "low"},
    input="Classify this support ticket: 'I was charged twice for my annual plan.'",
)

• none / low: simple lookups, classification, routing. Fast and cheap.
• medium: everyday writing and coding where low starts losing quality.
• high: multi-step reasoning, careful analysis.
• xhigh / max: the hardest problems, where correctness matters more than cost.

Raising effort on a cheaper tier often gets you further than jumping to Astra. Test both before assuming you need the bigger model. See how to prompt reasoning models for the full picture, and reasoning effort in the glossary for a one-line definition.

A practical decision tree

Is the task time-sensitive (user waiting for a response)?
  → Yes: Luna or Sol at low/medium effort
  → No: continue

Is the task primarily creative, communicative or generative?
  → Yes: Sol at low/medium effort
  → No: continue

Does the task involve multi-step math, proofs or complex algorithmic reasoning?
  → Yes: Astra, effort high or xhigh
  → No: continue

Is your current tier already giving correct, consistent results?
  → Yes: stick with it
  → No: raise effort one level before moving up a tier

Running this at high volume with moderate complexity?
  → Yes: Sol or Luna, with effort tuned per route

Prompting differences from the GPT-4o era

Drop "think step by step." Every GPT-6 tier reasons internally. The phrase is redundant and can crowd out the model's own plan. Give the task, constraints and output format instead.

Don't script the reasoning. "First check X, then verify Y, then compute Z" constrains a model that already plans its own approach. Describe the result you want.

Effort, not model choice, is now your main lever for depth. Where you used to escalate from GPT-4o to o1 to o3, you now raise effort on the same model first, and switch tiers only when effort alone doesn't close the gap.

The Responses API is the current default. OpenAI recommends it over Chat Completions for reasoning models; see the GPT-6 prompting guide for the full API walkthrough, including structured outputs and function calling.

The cost reality

Rough cost hierarchy, most to least expensive per token: Astra > Sol > Luna, a roughly 100x spread from top to bottom. Reasoning tokens are billed as output at every tier, so a high-effort Luna call can still cost more than expected — measure, don't assume.

The right mental model: start with the cheapest tier and lowest effort that could work, and escalate one axis at a time — effort first, tier second — only where testing shows you need it.

For model selection across providers, not just OpenAI, see GPT-6 vs Claude vs Gemini and which AI model should I use. For structuring reasoning tasks, chain of thought in 2026 and tree of thought cover the surrounding techniques.