OpenAI's GPT-6 Sol and Luna Pricing Cuts API Costs in Half

OpenAI just gave project managers something rarer than a new model: a price list they can actually plan a budget around. On September 22, 2026, OpenAI shipped GPT-6 Sol and GPT-6 Luna, the two lower-cost members of the GPT-6 family, and cut GPT-6 API pricing to half of what GPT-5.6 charged for the equivalent tiers. OpenAI says the cut is permanent, not a launch-week promotion.

What actually shipped

The GPT-6 family now has three tiers, and for once the naming tells you what each one is for:

• GPT-6 Astra (shipped September 3): the reasoning flagship, $10 per million input tokens and $50 per million output tokens.
• GPT-6 Sol: the mid-tier workhorse, $2 in and $10 out, down from $4 and $20 on GPT-5.6 Sol. OpenAI positions it for "complex tasks like coding."
• GPT-6 Luna: the clerical tier, $0.10 in and $0.50 out, down from $0.20 and $1.20 on GPT-5.6 Luna. Built for high-volume, clear-goal work: summarizing documents, extracting fields, answering quick questions.

Sol is available now through ChatGPT Work, Codex, and the API. Luna is rolling into the ChatGPT desktop app for free and Go users, plus the API. On benchmarks, Sol hits 68.8% on DeepSWE v1.1 coding tasks versus Luna's 66.6%, and OpenAI reports Sol now makes about half as many factual errors as GPT-5.6 Sol while approaching Astra-level reliability. The one regression worth flagging: Sol scored 60.5% on OSWorld 2.0 computer-use tasks, down from GPT-5.6's 65.7%, so anything driving a UI directly is worth testing before you swap models.

Why this matters if you manage AI delivery, not just code it

Most GPT-6 API pricing coverage this week is aimed at engineers picking a model for a coding agent. That's not the decision in front of a project manager. Your decision is which tier to wire into which recurring, boring, expensive workflow: status digests, sprint retros, backlog triage, executive summaries, risk logs.

Before this week, the honest answer for a lot of those was "GPT-6 Sol, because Luna wasn't confidently good enough and Astra was overkill." Now Luna costs a fifth of what GPT-5.6 Luna did, and Sol is priced where Luna used to be. That changes the math on tasks you'd previously routed to Sol out of caution. A cheap LLM for project management tasks, extracting due dates from a Slack thread, tagging a backlog item's priority, drafting a first-pass status update, is now cheap enough to run on every ticket instead of a sampled batch.

What to do with it Monday morning

Map your recurring PM workflows to a tier by how much judgment the task needs, not by habit:

| Task | Tier | Why | |---|---|---| | Extract dates, owners, blockers from standup notes | Luna | High volume, low ambiguity | | Draft a weekly status report from ticket data | Luna or Sol | Depends on how much synthesis vs. templating | | Triage and tag incoming backlog items | Luna | Clear categories, needs speed at volume | | Write an executive summary with tradeoffs | Sol | Needs judgment about what matters | | Assess program-level risk across dependencies | Astra | Needs actual reasoning, not summarization |

Here's a minimal way to route a task to the right tier from your own tooling:

from openai import OpenAI

client = OpenAI()

MODEL_BY_TASK = {
    "extract": "gpt-6-luna",
    "status_draft": "gpt-6-luna",
    "exec_summary": "gpt-6-sol",
    "risk_review": "gpt-6-astra",
}

def run_pm_task(task_type: str, prompt: str) -> str:
    model = MODEL_BY_TASK[task_type]
    response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}],
    )
    return response.choices[0].message.content

summary = run_pm_task(
    "exec_summary",
    "Summarize this sprint's blockers and tradeoffs for a steering committee: <sprint_notes>",
)

This is a dispatch table, not a framework: pick the cheapest tier that reliably clears your accuracy bar for that task, and only escalate to Sol or Astra where Luna's outputs need a human to fix them more often than they're worth.

Before you flip anything to Luna at volume, spend an afternoon running your last month of real tickets through it and comparing the output to what a human or GPT-5.6 Sol produced. The 50% price cut only pays off if the cheaper model is actually good enough for the task you point it at, not just good enough on OpenAI's benchmark.

Gotcha worth knowing

Astra's pricing didn't move, and it's the one tier with pricing modes: Batch and Flex processing halve it to $5 and $25 per million tokens if your workflow can tolerate delay, while Fast mode doubles it. If a PM workflow is running through Astra for reasoning-heavy risk assessment and isn't latency-sensitive, batching it is the cheaper win this week, not switching models.

For anyone shipping AI into how a team actually manages work, the news isn't that a model got smarter. It's that the cheap tier finally got cheap enough to trust with the boring 80% of the job, which is usually where the AI pilot either earns its budget or quietly gets cut.