OpenAI Launches GPT-6 Luna: 1.05M Context, 157 Tokens/Sec, $0.10/M Input, and Luna Pro Mode Deep Dive

On September 22, 2026, OpenAI launched GPT-6 Luna alongside GPT-6 Sol, completing the deployment of its sixth-generation foundation model tier. Priced at $0.10 per million input tokens and $0.50 per million output tokens, Luna serves as OpenAI’s high-speed utility engine, succeeding GPT-5.6 Luna with a 50% price cut and an expanded 1,050,000-token context window.

Independent benchmarks from Artificial Analysis confirm that GPT-6 Luna generates text at speeds up to 157.2 tokens per second (t/s) with a 60% reduction in average cost per evaluation task. The model also introduces Luna Pro mode, which applies latent chain-of-thought verification to bridge the performance gap with larger models.

1. Specifications & Pricing Matrix

2. Architecture & Inference Engine

GPT-6 Luna uses an optimized distilled transformer backbone designed for high-density GPU deployment. OpenAI decoupled token generation speed from sequence length by implementing multi-head latent caching and speculative draft heads.

                         High-Throughput Request Pipeline
                                        │
                                        ▼
                      ┌────────────────────────────────────┐
                      │    Input Context (Up to 1.05M)     │
                      │   - $0.01/M Prompt Cache Hits      │
                      └─────────────────┬──────────────────┘
                                        │
                                        ▼
                      ┌────────────────────────────────────┐
                      │    Dynamic Speculative Decoding    │
                      │  (Multi-Token Prediction Heads)    │
                      └─────────────────┬──────────────────┘
                                        │
             ┌──────────────────────────┴──────────────────────────┐
             ▼                                                     ▼
  [Standard Mode: Fast Generation]               [Luna Pro Mode: Latent Search]
   - 157.2 tokens / sec                           - Interleaved reasoning passes
   - Zero CoT overhead                            - Self-consistency scoring
   - Sub-second first-byte latency                - Complex code & logic validation
             │                                                     │
             └──────────────────────────┬──────────────────────────┘
                                        ▼
                      ┌────────────────────────────────────┐
                      │ 128K Output Buffer / SSE Stream    │
                      └────────────────────────────────────┘

A. The 1.05M Context Window at Scale

Handling 1,050,000 tokens of input with prompt caching at $0.01 per million tokens enables continuous document monitoring. An application that ingests a 300,000-token legal corpus or software repository pays $0.003 per cached query, making Luna viable for continuous automated audits that run every few minutes.

B. Luna Pro Mode Mechanics

When developers specify reasoning.mode: "pro" in the API call, the model switches execution paths:

1. Latent Search: Before generating user-visible tokens, Luna allocates an internal reasoning budget to test intermediate candidate solutions.
2. Dynamic Verification: It discards erroneous branches without emitting failed tokens to the output stream.
3. Economics: Because the base input token price remains $0.10 per million tokens, running Luna Pro costs a fraction of dispatching the same request to GPT-6 Sol or Claude Opus.

3. Empirical Benchmarks: Artificial Analysis Independent Audits

Artificial Analysis conducted standardized evaluations of GPT-6 Luna across its operational reasoning tiers (low, medium, high, and max).

A. Throughput and Latency Metrics

Output Generation Speed by Configuration (Tokens / Second)

GPT-6 Luna (Max)      ████████████████ 157.2 t/s
GPT-6 Luna (Low)      ███████████████ 151.6 t/s
GPT-6 Luna (Medium)   ██████████████ 143.0 t/s
GPT-6 Luna (High)     ████████████ 127.0 t/s
Gemini 2.5 Flash      ██████████████ 142.0 t/s
GPT-6 Sol             █████████ 94.0 t/s

1. Output Throughput: Luna Max reaches 157.2 t/s, delivering a 60% speed increase over GPT-5.6 Luna.
2. First Token Response: On non-reasoning calls, the time-to-first-token is 0.86 seconds, meeting latency thresholds for interactive customer support widgets and terminal auto-completions.

B. Quality & Error Rates

In the AA-Omniscience evaluation, which tests whether a model identifies unanswerable questions rather than generating false information, GPT-6 Luna cut hallucination rates from 93% down to 77%.

4. The "Token Minimization" Behavior: Community Findings

Following the model's rollout on GitHub Copilot and ChatGPT, engineering discussions on Reddit (r/singularity) and Hacker News identified a specific behavioral tendency: aggressive token minimization.

Token Minimization Contrast:

Prompt: "Explain how TCP flow control handles window resizing."

GPT-5.6 Luna Response (~420 tokens):
  - Long introduction on TCP protocol headers.
  - Three paragraphs detailing sliding window math.
  - Explanation of ACK timing and congestion control differences.
  - Concluding summary.

GPT-6 Luna Default Low Effort (~110 tokens):
  - "TCP flow control uses the 16-bit Window Size field in the TCP header. 
     The receiver advertises available buffer capacity. 
     When the buffer fills, the window drops to 0 (Zero Window Probe). 
     Once space clears, an ACK updates the window."

Root Cause and Remediation

• Why It Happens: OpenAI tuned GPT-6 Luna to reduce output token consumption, prioritizing speed and cost-per-call.
• When It Is Advantageous: For classification, JSON extraction, and database record parsing, concise output prevents unnecessary token spend.
• When It Causes Issues: Users seeking explanatory prose or exploratory brainstorming may find default responses terse.
• The Solution: Developers can set reasoning_effort: "high" or prepend the prompt with explicit structural requirements (e.g., "Provide a detailed, step-by-step architectural explanation with code samples").

5. Developer Implementation: OpenAI API & OpenRouter

GPT-6 Luna is supported across standard SDKs.

A. Python API Implementation

from openai import OpenAI

client = OpenAI()

# Standard low-latency streaming call
response = client.chat.completions.create(
    model="gpt-6-luna",
    messages=[
        {
            "role": "system",
            "content": "You are a low-latency routing agent. Categorize incoming support tickets into JSON."
        },
        {
            "role": "user",
            "content": "User cannot authenticate via OAuth SSO. Error code 403 invalid redirect URI."
        }
    ],
    temperature=0.1,
    max_completion_tokens=256
)

print(response.choices[0].message.content)

B. Invoking Luna Pro Mode

import requests

# Calling GPT-6 Luna Pro via API endpoint with reasoning mode
url = "https://api.openai.com/v1/chat/completions"
headers = {
    "Authorization": "Bearer $OPENAI_API_KEY",
    "Content-Type": "application/json"
}

data = {
    "model": "gpt-6-luna",
    "messages": [
        {"role": "user", "content": "Prove that the square root of 2 is irrational using contradiction."}
    ],
    "reasoning": {
        "mode": "pro",
        "effort": "high"
    }
}

res = requests.post(url, headers=headers, json=data)
print(res.json())

6. Workload Allocation: When to Choose Luna Over Sol

With Sol priced at $2.00 / $10.00 and Luna at $0.10 / $0.50, engineering teams face a 20x price differential between the two tiers.

Decision Framework for Model Selection:

[Incoming Request]
       │
       ├─► Software refactoring, multi-file codebases, computer use?
       │     └──► Route to GPT-6 Sol ($2.00 / $10.00)
       │
       ├─► High-volume JSON extraction, classification, search reranking?
       │     └──► Route to GPT-6 Luna ($0.10 / $0.50)
       │
       ├─► Complex logic or math on a strict cost budget?
       │     └──► Route to GPT-6 Luna Pro ($0.10 / $0.50 + reasoning tokens)
       │
       └─► Frontier scientific synthesis or formal verification?
             └──► Route to GPT-6 Astra ($10.00 / $50.00)

7. Summary

GPT-6 Luna solidifies OpenAI’s lower-tier infrastructure:

1. Speed and Cost: Generates up to 157.2 tokens per second at $0.10 per million input tokens, cutting task costs by 61% compared to GPT-5.6.
2. Capacity: Offers a 1.05M token context window and 128K maximum output length.
3. Versatility: Combines rapid non-reasoning classification with Luna Pro mode for higher-order problem-solving.

Developers can access GPT-6 Luna today through the OpenAI API, Amazon Bedrock, OpenRouter, and GitHub Copilot.