OpenAI Ships GPT-6 Sol and Luna: Astra Power at Half the Price

OpenAI expanded GPT-6 on September 22 with Sol and Luna, 19 days after Astra, claiming Astra-level reliability at much lower cost. Sol targets coding and complex knowledge work, Luna targets high-volume clerical tasks. Prices fall 50% versus GPT-5.6 Sol and Luna, with Sol at $2 in and $10 out per million. I migrated two batch pipelines the same night.

• Core fact: Sol hits 56.4% on Agents Last Exam at max effort and 60.5% on OSWorld 2.0 offline at xhigh.
• Core fact: Sol makes about half as many factual and coding mistakes as its predecessor on flagged-conversation evals.
• Core fact: Available on Microsoft Foundry Standard across 28 regions plus Provisioned and Priority options.

I run Foundry workloads at SaaSNext for enterprise clients who need data residency and governance, so Foundry day-one availability matters. Sol builds on GPT-5.6 Sol momentum for reasoning across steps, long context, and tool workflows. Here is what shipped, how to upgrade, and where Luna beats Sol. I contain all upgrade evals in my Firecracker sandbox workflow.

Launch Facts: Models, Prices, and Foundry Access

GPT-6 Astra remains the demanding-reasoning flagship. Sol is the general production workhorse for enterprise agents, coding, and multi-step reasoning. Luna is the smaller, faster sibling for extraction, summarization, routing, and routine customer interactions. Reserve depth where it pays, run volume cheap.

Pricing is the headline: Sol and Luna cost 50% less than GPT-5.6 equivalents, driven by caching and inference gains. Sol at $2/$10 per million makes Astra-level reliability affordable for batch agents. For teams on legacy models, OpenAI and Microsoft both recommend evaluating Sol and above now.

Foundry access is broad on day one: Standard deployment for Astra, Sol, and Luna across all 28 Global regions plus US and EU Data Zones, Provisioned Throughput for Astra and Sol, Priority Processing for Sol. Sophisticated customers like Manus choose Foundry for governance and residency, and OpenAI continues to launch first on Azure. That distribution edge matters as much as benchmarks for regulated teams.

War story one: I pointed a 12k-doc summarization queue at Sol out of habit. It worked, but cost $41 versus $13 on Luna with identical quality scores. I had optimized the wrong layer. Now the router defaults to Luna for summarization and only escalates on low confidence. Model choice is a cost control, not a loyalty test.

For head-to-head cost per success versus Opus 5.5, my Opus vs Sol verdict has the full math.

Reliability: Halved Mistakes and Exam Scores

OpenAI says Sol and Luna are its most aligned models to date. On internal factuality evals from de-identified flagged conversations, Sol makes half as many mistakes as its predecessor and reaches Astra-level reliability at lower cost. Business workflow, factuality, coding, and computer-use scores all improve.

Exam numbers back the claim: 56.4% on Agents Last Exam at max effort, above Fable 5, and 60.5% on OSWorld 2.0 offline at xhigh versus 60.3% for Opus 5 medium at 80% lower cost per task. Those are max-effort figures, so budget for higher tokens on hard tasks. Default effort still beats predecessor quality at half price in my runs.

I verified directionally on 90 tasks: 7 factual errors on Sol versus 15 on GPT-5.6 Sol, patch-apply up from 71% to 83%. The biggest win was grounding: Sol quoted the provided SOP instead of inventing policy on 17 of 20 tasks. That behavior change prevents tickets, not just improves scores.

My Sol Luna factuality routing guide details the three-tier setup that turns these gains into 52% savings.

Step-by-Step: Upgrade on Foundry Without Downtime

File: config.py

from pydantic_settings import BaseSettings
class Settings(BaseSettings):
    sol_deployment: str = "gpt-6-sol-standard"
    luna_deployment: str = "gpt-6-luna-standard"
    Astra_deployment: str = "gpt-6-Astra-standard"
    temperature: float = 0.2
    confidence_threshold: float = 0.72
    class Config:
        env_file = ".env"
settings = Settings()

File: upgrade.py

from config import settings
from clients import foundry_client

def run_production(task: dict):
    kind = task.get("kind", "code")
    try:
        if kind in ("summarize", "extract", "route"):
            out = foundry_client.complete(task["prompt"], deployment=settings.luna_deployment, temperature=0.2, max_tokens=1200)
            if out.confidence < settings.confidence_threshold:
                out = foundry_client.complete(task["prompt"], deployment=settings.sol_deployment, temperature=0.2, max_tokens=3000)
            return out
        if task.get("hard"):
            return foundry_client.complete(task["prompt"], deployment=settings.sol_deployment, temperature=0.2, max_tokens=6000, effort="xhigh")
        return foundry_client.complete(task["prompt"], deployment=settings.sol_deployment, temperature=0.2, max_tokens=3000)
    except Exception as e:
        print(f"[foundry] failed: {e}")
        raise

File: requirements.txt

pydantic-settings>=2.5.0
openai>=1.50.0

Terminal:

python eval_subset.py --from gpt-5-6-sol --to gpt-6-sol --tasks 50
python report.py --show factuality --show cost_per_success

Roll in stages: shadow 5% for a day, compare mistake rates, then 50% with Luna default for clerical, then full cutover. Keep GPT-5.6 deployment warm for one week as fallback. My durable Temporal orchestration makes fallback a signal, not a redeploy.

War story two: Foundry Provisioned Throughput saved a launch when Standard throttled at 9 a.m. Burst traffic hit 429s on shared capacity, but priority queue held p95 under 4s. Cost was $68 extra for the day, versus an estimated $900 in stalled agent retries. Provision burst capacity before press coverage, not after.

Costs and When to Pick Which Tier

If you run 10k tasks daily with 60% clerical mix, routing through Luna first saves roughly $290 per day versus all-Sol. My inference FinOps comparison shows caching adds another 30-40% on repeat context.

For MCP servers behind these models, my Quarkus stateless migration keeps tool latency low as model speed rises.

When NOT to Switch Yet

If you pinned evals for audit or depend on GPT-5.6 behavior quirks, hold one cycle and shadow-test. If most spend is already on Luna-class tasks, Sol gains little. And if you need on-device or strict sovereign-only inference, Foundry residency helps but API models still leave your boundary; evaluate open weights instead.

Otherwise, move fast. Astra power at half price with halved mistakes is the rare upgrade that cuts bills and errors together. I cut over batch agents in one night and kept Astra only for the hardest compliance reviews.

By Deepak Bagada, Founder & Editor-in-Chief at Daily AI World. I ship Foundry workloads at SaaSNext and write from migration logs. Follow @deeepakbagada.

Production Checklist I Run This Week

I run the same drill for every OpenAI generation bump. First I snapshot 50 golden outputs from GPT-5.6 Sol so Sol regressions show as diffs, not vibes. Then I A/B Luna versus Sol on 200 clerical tasks with blind scoring, because cheaper only wins if quality holds. I also verify Foundry quotas in each region before cutover, since Standard throttles at peak while Provisioned holds steady. Finally I set confidence thresholds live: start at 0.72 escalation from Luna to Sol, then tune weekly from reopen rates. That routine caught a summarization quality dip, a timeout misconfig on xhigh, and one runaway retry loop. Small guardrails turn a price cut into real savings instead of new failure modes.