OpenAI Launches GPT-6 Sol and Luna: 1M Context, 50% Price Cuts, DeepSWE 68.8%, and Independent Benchmark Analysis

On September 22, 2026, OpenAI launched GPT-6 Sol and GPT-6 Luna, expanding its sixth-generation frontier family beneath the previously released flagship GPT-6 Astra. Both models feature 1-million-token context windows, native prompt caching, and a 50% price reduction relative to the preceding GPT-5.6 generation.

OpenAI designed GPT-6 Sol for long-horizon software engineering, computer use, and enterprise agent workflows. GPT-6 Luna handles high-volume, latency-sensitive tasks such as extraction, customer support triage, and classification.

Both models became available simultaneously on the OpenAI API, ChatGPT (Work and Codex), Amazon Bedrock, and GitHub Copilot. Independent evaluations from Artificial Analysis and community developers reveal significant economic efficiency gains alongside nuanced trade-offs in reasoning verbosity.

1. Specifications & Pricing Matrix

2. Architecture & Inference Pipeline

Both Sol and Luna operate on a multi-stage reasoning architecture. OpenAI separated inference-time compute into distinct reasoning effort modes (low, medium, high, xhigh, and max), allowing developers to tune token consumption to task difficulty.

                 User Request & Context (Up to 1M Tokens)
                                    │
                                    ▼
                     ┌──────────────────────────────┐
                     │   Prompt Prefix Cache Hit    │
                     │ ($0.20/M Sol / $0.01/M Luna) │
                     └──────────────┬───────────────┘
                                    │
                                    ▼
                     ┌──────────────────────────────┐
                     │ Dynamic Reasoning Router     │
                     │ (Selects Thinking Trajectory)│
                     └──────────────┬───────────────┘
                                    │
             ┌──────────────────────┴──────────────────────┐
             ▼                                             ▼
  [Standard Mode (Sol / Luna)]                [Pro Mode (Luna Pro / Sol Max)]
   - Direct output decoding                    - Latent chain-of-thought verification
   - Minimal thinking tokens                   - Tool execution loops (Bash, Python)
   - Real-time interaction (85+ TPS)           - Branching solution scoring
             │                                             │
             └──────────────────────┬──────────────────────┘
                                    ▼
                     ┌──────────────────────────────┐
                     │ Output Synthesizer & C2PA    │
                     │ (Code, JSON, Computer Action)│
                     └──────────────────────────────┘

A. Context Window and Cache Economics

Supporting 1 million tokens at $0.20 per million cached input tokens changes the economics of continuous repository ingestion. A developer feeding a 400,000-token repository into an agent loop pays $0.08 per iteration on cached reads, compared to $0.80 per call on non-cached models.

B. Luna Pro Mode

GPT-6 Luna introduces a dedicated configuration: reasoning.mode: pro. When enabled, Luna runs extended self-consistency checks on its latent reasoning tokens before streaming final text. This allows Luna to solve intermediate coding problems at one-twentieth of Sol’s token price.

3. Empirical Benchmarks: Artificial Analysis & DeepSWE Data

Independent evaluations conducted by Artificial Analysis and published research platforms quantify the trade-offs between GPT-6 Sol, GPT-5.6 Sol, Claude Opus 5.5, and Claude Fable 5.1.

A. Core Benchmark Comparison

DeepSWE 1.1 vs Cost-Per-Task Pareto Frontier

DeepSWE Score (%)
  75% │                                 ● Claude Opus 5.5 ($5.12)
      │
  70% │               ● Claude Fable 5.1 ($4.80)
      │      ● GPT-6 Sol ($1.06) ── [80% Cost Reduction]
  65% │
      │
  60% │
      └─────────────────────────────────────────────────────────────
         $1.00          $2.00          $3.00          $4.00     $5.00+
                               Cost Per Task (USD)

B. The 80% Cost Reduction Factor

While Claude Opus 5.5 maintains a narrow lead on absolute DeepSWE 1.1 (73.7% vs 68.8%), executing an evaluation task on Opus 5.5 costs $5.12, whereas GPT-6 Sol completes the same benchmark test for $1.06. For automated continuous integration (CI) pipelines running thousands of test fixes per week, GPT-6 Sol delivers a Pareto improvement in compute cost.

C. Factuality and Hallucination Reductions

In Artificial Analysis's AA-Omniscience test (which evaluates whether a model hallucinating edge-case facts detects its own ignorance and declines to answer), GPT-6 Sol reduced unforced error rates from 92% (on GPT-5.6 Sol) down to 60%.

4. Computer Use & OSWorld 2.0 Results

GPT-6 Sol includes native support for OpenAI’s Computer Use API. Rather than using an external vision model to caption desktop screenshots, Sol accepts raw PNG frame buffers alongside OS event streams (mouse clicks, keypresses, scroll gestures).

                 Computer Use Architecture in GPT-6 Sol

[Desktop Display Buffer] ──► [Native Visual Tokenizer] ──► [Spatial Coordinate Head]
                                                                   │
                                                                   ▼
                                                    [Predicted Screen Action]
                                                    - Click (X=1420, Y=840)
                                                    - DoubleClick
                                                    - KeyCombination (Cmd+S)
                                                                   │
                                                                   ▼
[Updated UI State]       ◄── [Local Agent Sandbox]    ◄── [JSON Action Execution]

1. OSWorld 2.0 Score: GPT-6 Sol scored 60.5% at xhigh effort, matching Claude Opus 5 (61.2%) while processing screen frames at half the input token price.
2. Screen Geometry Resolution: Sol accepts multi-monitor virtual viewports up to 4K resolution (3840x2160) without spatial downscaling, locating small UI elements (such as 12px menu icons) accurately.
3. Cross-Application Workflows: In automated testing, Sol completed end-to-end tasks spanning browser data extraction, CSV compilation in LibreOffice Calc, and filing bug tickets in Jira.

5. Developer & Community Reception: Critical Evaluations

Following the September 22 release, engineering discussions on Reddit (r/singularity) and Hacker News highlighted distinct practical strengths and shortcomings.

A. The GPT-6 Sol Consensus

Developers praised Sol’s software engineering reliability. In GitHub Copilot and Cursor, Sol produced fewer compilation regressions in multi-file refactoring runs compared to GPT-5.6 Sol. The $2.00/$10.00 pricing tier makes it a viable daily driver for engineering teams that found GPT-6 Astra cost-prohibitive.

B. The GPT-6 Luna Criticism: "Token Minimization"

Community testing on GPT-6 Luna produced mixed reactions:

• Terse Responses: At low reasoning effort, Luna frequently answers questions with minimal token output. Users noted that Luna sometimes omits step-by-step explanatory prose in favor of bare-bones code snippets, requiring follow-up prompts to elaborate.
• Remedy: Developers discovered that setting reasoning.effort: "high" or switching to reasoning.mode: "pro" restores thoroughness, though this increases output token counts.

Community Verdict Breakdown:

GPT-6 Sol:
  [Strengths]: 80% lower cost per coding task, reliable 1M context cache, strong computer use.
  [Weaknesses]: Absolute top-end score on DeepSWE (68.8%) slightly trails Opus 5.5.

GPT-6 Luna:
  [Strengths]: $0.10/M input price, sub-200ms latency, handles high-volume routing.
  [Weaknesses]: Overly brief output at default settings; requires explicit prompting for detail.

6. Developer Integration Guide: OpenAI API & Amazon Bedrock

Both models are accessible through standard client libraries.

A. Python Implementation (OpenAI API)

from openai import OpenAI

client = OpenAI()

# Calling GPT-6 Sol with 1M context and reasoning effort configuration
response = client.chat.completions.create(
    model="gpt-6-sol",
    messages=[
        {
            "role": "system",
            "content": "You are an autonomous staff software engineer. Refactor the provided multi-file codebase."
        },
        {
            "role": "user",
            "content": "Analyze the attached 120,000-token repository architecture and locate memory leaks in the Vulkan pipeline."
        }
    ],
    reasoning_effort="high",  # Options: low, medium, high, max
    temperature=0.2,
    max_completion_tokens=8192
)

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

B. Amazon Bedrock Invocations

aws bedrock-runtime invoke-model \
  --model-id "openai.gpt-6-sol-v1:0" \
  --body '{"prompt": "Generate a Terraform module for a multi-region Kubernetes cluster with SEPP gateways.", "max_tokens": 4096, "temperature": 0.1}' \
  --cli-binary-format raw-in-base64-out \
  output.json

7. Strategic Outlook: OpenAI’s Three-Tier Model Hierarchy

With the launch of Sol and Luna, OpenAI’s sixth-generation portfolio settles into three clear operational tiers:

1. Frontier Tier (GPT-6 Astra): $10.00 / $50.00 per million tokens. Reserved for breakthrough mathematical synthesis, autonomous theorem proving, and scientific discovery.
2. Workhorse Tier (GPT-6 Sol): $2.00 / $10.00 per million tokens. The standard production model for software development, complex tool invocation, and business process automation.
3. Utility Tier (GPT-6 Luna): $0.10 / $0.50 per million tokens. Designed for high-frequency micro-tasks, document classification, conversational triage, and routing.

By slashing prices by 50% while expanding context to 1 million tokens, OpenAI pressures competitors (Anthropic, Google, and open-weight providers) to defend their enterprise pricing models on compute-cost efficiency.