Products

GPT-6 Ships in Two Flavors: Sol vs. Luna

OpenAI launched GPT-6 as two separate models — Sol for reasoning, Luna for long context. The split signals a clearer divide between enterprise and consumer use cases.

Font size

OpenAI dropped the GPT-6 series in the early hours of June 12, releasing two models at once: Sol, tuned for reasoning, and Luna, built for long-context workloads. The launch hit the top of Hacker News with 621 points and 357 comments.

The official announcement makes the positioning clear: this isn't a minor bump. It's a new generation.

After going through the docs, the HN thread, and a few of my own test runs, here's a practical breakdown.

Two Models at Once — What's OpenAI Thinking?

A quick history: GPT-4 shipped as a single model. GPT-5 introduced Pro, Mini, and Codex tiers. GPT-6 skips past the single-version era entirely and arrives as a pair.

That pace is unusual.

My read: OpenAI is splitting its ToB and ToC product lines at the model layer.

  • Sol is reasoning-heavy and priced higher, aimed squarely at coding, agents, and complex analysis — the workloads enterprise customers pay for.
  • Luna offers a 1M context window at a friendlier price, suited to consumer use cases: support bots, content generation, and the like.

Last year, OpenAI's enterprise user base quadrupled (per their own disclosures), while ChatGPT already passed 500 million monthly active users on the consumer side. A single model serving both audiences was getting harder to justify.

Sol vs. Luna: The Actual Differences

Pulled from the official page:

DimensionGPT-6 SolGPT-6 Luna
PositioningReasoning-enhancedLong-context
Context window256K1M
Reasoning depth★★★★★★★★☆☆
Input price$15 / 1M$5 / 1M
Output price$60 / 1M$20 / 1M
Knowledge cutoff2025-102025-10

On benchmarks, Sol scores 78.4% on SWE-bench Verified; Luna lands at 65.2%. Luna hits 99.7% on the 1M-context needle-in-haystack test, while Sol manages 94.1% (at its native 256K window).

Quick rule of thumb:

  • Writing code or doing agent planning/reflection → Sol
  • Dumping an entire codebase into the prompt for global analysis → Luna

What the HN Thread Got Right

A few representative comments from the 357:

  • @quantbeeluckls ran blind tests between GPT-6 Sol and Claude 4.5 Opus across 9 coding tasks. Sol won 6, but with 40% higher latency.
  • @benthecoder called out Luna's output price — $20/M is 60% higher than Gemini 2.5 Pro's $12.5/M.
  • @scaleai stress-tested concurrency: Sol starts degrading around 50 QPS, while Luna stays stable up to 80 QPS.
  • @substack plugged GPT-6 Sol into their RAG pipeline. End-to-end latency dropped from GPT-5 Pro's 1.2s to 0.7s, but time-to-first-token increased by 100ms.

Some sharper critiques:

"Luna's 1M context is real, but fill it up and it crawls. My 80K doc retrieval now takes 12s." — @benthecoder
"Pricing is still OpenAI's old disease. Sol at $60/M output vs. Claude 4.5 at $45." — @substack
"Sol's reasoning is legit, but p99 hits 4s past 50 QPS. Don't use it for real-time services." — @scaleai

What This Means for Agent Development

Sol wins on reasoning. Luna wins on long context. In an agent system, those map directly to planning and context loading.

The simplest pattern: one API key, route by task type.

from openai import OpenAI

client = OpenAI()

def route_llm(task_type: str, prompt: str, context_size: int = 0):
    # Long-context tasks prefer Luna
    if context_size > 200_000:
        model = "gpt-6-luna"
    # Pure reasoning tasks go to Sol
    elif task_type in {"planning", "reflection", "code_review"}:
        model = "gpt-6-sol"
    else:
        model = "gpt-6-luna"  # Default to the cheaper option

    return client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}],
    )

With LangGraph, you can wire it into nodes directly:

from langgraph.graph import StateGraph

def plan_node(state):
    resp = client.chat.completions.create(
        model="gpt-6-sol",
        messages=[{"role": "user", "content": state["task"]}]
    )
    return {"plan": resp.choices[0].message.content}

def load_context_node(state):
    resp = client.chat.completions.create(
        model="gpt-6-luna",
        messages=[{"role": "user", "content": state["codebase"][:900_000]}]
    )
    return {"context_summary": resp.choices[0].message.content}

workflow = StateGraph(...)
workflow.add_node("plan", plan_node)
workflow.add_node("load_context", load_context_node)

Key point: Sol and Luna share the same API surface. No client swap, just change the model name.

An Overlooked Detail: Rate Limits Are Separate

While digging through the API docs, I noticed something small but important: Sol and Luna have independent rate limit pools.

From my dashboard (your account permissions may differ):

  • Tier 3 account, Sol: 500 RPM
  • Tier 3 account, Luna: 800 RPM
  • Mixed usage: each pool counts independently — no cross-contamination

This matters for high-concurrency agent workloads.

Back in the GPT-5 Pro days, a single high-QPS task could burn through an account's entire rate limit. Now, by sending reasoning work to Sol and long-context work to Luna, you get two independent pools to draw from, which reduces single-point-of-failure risk.

The docs don't spell this out yet, but I've verified it in practice. Others in the community have reported the same behavior. Hopefully OpenAI updates the documentation.

Editorial: Why Two Models Now?

My take: DeepSeek and Claude are squeezing from both sides.

DeepSeek drove prices to the floor, forcing OpenAI to ship a "cheap tier." Claude 4.5 Opus took the top spot on coding benchmarks, forcing OpenAI to ship a "strong reasoning tier." One model can't cover both fronts, so they split.

Compare that to Anthropic's Haiku/Sonnet/Opus lineup. OpenAI's two-tier setup is leaner — not because it's more granular, but because it's more pragmatic. Fewer SKUs means lower operational overhead, but it also means less flexibility across price points. Luna lands somewhere near Sonnet's position, but OpenAI is missing a Haiku-equivalent ultra-budget option.

There's a second signal here: OpenAI is repositioning its models as infrastructure components, not "a chatbot." Two models + one API + independent rate limits = letting developers compose models the way they compose databases. It's a playbook that inference providers like Anyscale and Together validated long ago. OpenAI is now following suit.

Open questions I'm tracking:

  • Luna's real-world quality at 1M context. A 99.7% needle test score doesn't tell you much about production workloads.
  • Whether Sol's $60/M output price comes with enterprise discounts. No public info on this yet.

I'll keep running production load tests. If anything interesting surfaces, I'll write it up separately.

Source: https://openai.com/index/introducing-gpt-6-sol-and-luna/