GPT-6 Luna: OpenAI's 4.8 CI-First Cost Tier, 90 Percent Cheaper Than the Old List Price, and a Lower Agentic Ceiling
Updated: 2 days ago
Status: Active | Last tested: 2026-09-23 (GPT-6 Luna, gpt-6-luna, released 2026-09-22) | Re-check: trigger-based (max 6 months)
Active: the tool is current and recommended.
Tool Snapshot
Tagline: OpenAI's most efficient model for focused, high-volume tasks. Read from the OpenAI model reference for gpt-6-luna on 2026-09-23.
Category: Applied AI / Large Language Model (cost-sensitive high-volume work)
The cost tier of the GPT-6 family, below GPT-6 Sol and GPT-6 Astra. The tier's work is extraction, classification, routing, summarization, and first-pass triage at volume.
Primary use cases:
Extract structured fields from forms, invoices, emails, and reports at a volume where the input price decides whether the job runs at all.
Classify and route incoming items: support tickets, documents, messages, log lines.
Summarize documents, threads, and transcripts where the input already contains the answer and the job is to condense it.
Run a cheap first pass over a batch so that a more expensive model or a person only looks at the subset that needs it.
Serve as the reading layer under a larger agent, summarizing retrieved material before it reaches the main model.
Rewrite and reformat at volume where speed and price matter more than depth.
Pricing summary: Paid in the API, and free in one specific place. API list price is $0.10 per million input tokens and $0.50 per million output tokens. The input price is 50 percent below the GPT-5.6 Luna promotional rate of $0.20, and the output price is 58 percent below that model's promotional $1.20; measured against GPT-5.6 Luna's original list price of $1 and $6 the cut is 90 percent on input and 92 percent on output. Cached input is $0.01 per million, a 90 percent discount, and cache writes are billed at $2.50 per million. Prompts above 272,000 input tokens pay 2 times the input and cache rates and 1.5 times the output rate for the whole request. Batch and Flex are 50 percent of Standard, which puts output at $0.25 and input at $0.05. Fast mode is 2 times the applicable rate, $0.20 and $1.00. Regional processing adds 10 percent where available, and EU data residency on Sol and Luna is available only with Standard processing. In ChatGPT Work and Codex the models are metered in credits, and Luna costs 2.5 credits per million input tokens and 12.5 per million output against 5 and 30 for GPT-5.6 Luna. Consumer access: paid plans get Luna in ChatGPT Work and Codex, and Free and Go users get it in the desktop app, which is the most generous access change in this release. Prices captured 2026-09-22 and 2026-09-23 from the OpenAI launch page, the model reference pages, the pricing documentation, and third-party transcriptions of the per-effort charts.
Official links:
Launch page: https://openai.com/index/introducing-gpt-6-sol-and-luna/
Prompt caching announcement: https://openai.com/index/better-prompt-caching-for-gpt-6/
Model reference, GPT-6 Luna: https://developers.openai.com/api/docs/models/gpt-6-luna
Model reference, GPT-6 Sol: https://developers.openai.com/api/docs/models/gpt-6-sol
API pricing: https://developers.openai.com/api/docs/pricing
Codex subagents: https://learn.chatgpt.com/docs/agent-configuration/subagents
Codex local memories: https://learn.chatgpt.com/docs/customization/memories
GPT-6 Astra system card: https://deploymentsafety.openai.com/gpt-6-astra
Status page: https://status.openai.com
LLM-specific fields:
API model identifier: gpt-6-luna. No dated snapshot is published; the model ID itself is the snapshot.
Context window: 1,050,000 tokens, with 922,000 maximum input tokens and 128,000 maximum output tokens. Text and image input, text output. Audio and video are not supported.
Knowledge cutoff: 18 May 2026. This is the most recent cutoff of the three GPT-6 models, four weeks later than GPT-6 Astra and Sol.
Effort levels: none, low, medium (default), high, xhigh, max. The parameter is reasoning.effort. Luna is one of the two GPT-6 models that supports none, which GPT-6 Astra does not.
Parameters and architecture: not publicly disclosed. OpenAI publishes no parameter count, no architecture description, and no weights for any GPT-6 model.
Model variants: GPT-6 Luna only. There is no GPT-6 Terra, and OpenAI has not announced one.
Available platforms: ChatGPT Work and Codex (web, CLI, IDE extension, iOS, cloud tasks), the ChatGPT desktop app for Free and Go users, the OpenAI API, and Amazon Bedrock. Enterprise and Edu workspaces need an administrator to turn the model on for ChatGPT Work and Codex. Not open weights and not self-hostable.
License: proprietary hosted service. Zero data retention is available on the API for qualifying accounts.
Comparison references: arena.ai (LMSYS Chatbot Arena) for head-to-head rankings and ollama.com/search for local deployment of other models. GPT-6 Luna cannot be run locally.
Delivery surface to check separately from the model: Codex CLI and the ChatGPT desktop app. OpenAI's own subagent documentation names the Luna tier for fast, narrowly scoped, high-volume agents, so this tier is explicitly intended to run under an orchestrating model that the user is not watching turn by turn. That is what the clause findings in Section 7 of this review rest on.
At a Glance Dashboard
Field | Value |
Category | Applied AI / Large Language Model (cost-sensitive high-volume work) |
CI-First Benefit Score | 4.8 / 10 (CI-First Positive) |
Sub-scores | Time 7 / Quantity 7 / Quality 4 / Skill 1 |
CI-First Profile | Primary Co-Worker and Assistant (level 2); secondary Analyst and Tester (level 4) |
Collaboration Mode | Centaur. Cyborg is not available where more than one agent shares a view or channel (clause 7.5), and this review does not recommend Cyborg even for a single supervised agent session |
Humics Protection | Humics-Neutral (-1 / +3) |
AI Imposture Risk | Medium (Time: Low, Quantity: Medium, Skill Illusion: High) |
Status | Active |
Last tested | 2026-09-23 |
Released | 2026-09-22 |
Access | ChatGPT Work and Codex on paid plans, desktop app for Free and Go, OpenAI API, Amazon Bedrock |
Pricing | $0.10/1M in, $0.50/1M out (Standard); cache read $0.01/1M; Batch and Flex 50 percent |
Context Window | 1,050,000 tokens in (922,000 max), 128,000 tokens out |
For detailed explanations of the CI-First evaluation terms used in this review, including the CI-First Benefit Score, the CI-First Profile, the Humics Protection Badge, the AI Imposture Risk rating, the User Sentiment reading, and the Review Status badge, see the Glossary at the end of this post.
The Problem
High-volume work has an awkward economics problem. The volume is what makes the work worth automating, and the volume is also where a cheap model's mistakes multiply. A model that is wrong one time in fifty is acceptable on a single document and is a queue of fifty corrections on a thousand.
Three specific problems were live before this release.
The first is the cost floor of the previous cheap tier. GPT-5.6 Luna launched at $1 and $6 per million tokens and was cut by 80 percent in July to $0.20 and $1.20, which already put it in the range of open-weights models. At $0.10 and $0.50 the pricing moves past most hosted open-weights options, and that changes the decision from which model to which provider.
The second is the bill for reading. Extraction and routing jobs are input-heavy and output-light. A job that reads 500,000 tokens to produce 2,000 tokens of output is a job whose cost is almost entirely the input line and the cache behaviour. This release's caching changes matter more for Luna than for either of its siblings, because Luna's work is reading.
The third is where the previous tier's ceiling sat. Luna was reliable on a single focused task and unreliable across a long chain of tool calls, so the cheap tier was usable for one-shot work and not for agentic loops. That constraint is the one independent measurement this cycle did not resolve in Luna's favour.
There is a fourth problem this release makes worse rather than better, and it belongs in the same paragraph. At five cents per thousand output tokens, the marginal cost of producing more output approaches zero while the cost of reading it does not move at all. The person is now the bottleneck by a wide margin, and the tool's price gives no signal about that. Section 7 scores it as the Medium trap, and the Skill trap as High for a different reason.
The Outcome
What changes for a reader who adopts this model:
Cost per completed task falls by about 60 percent on independent measurement. Artificial Analysis measured GPT-6 Luna at maximum effort at $0.07 to run its Intelligence Index, against $0.18 for GPT-5.6 Luna at the same setting. Independent measurement also confirms the mechanism: Luna uses more output tokens than its predecessor, about 51,000 against 41,000, so the saving comes from the price cut rather than from doing less work.
A four-times-cheaper tier is available without a paid ChatGPT plan. Free and Go users get Luna in the desktop app. That is the first time this generation of model has been reachable without a subscription, and it is the most concrete access change in the release.
Reliability on factual questions improved on the vendor's test and on the independent one. OpenAI reports Luna at higher effort matches GPT-5.6 Sol's factuality at roughly a hundredth of the cost. Artificial Analysis measured the hallucination rate falling from 93 percent to 77 percent and the AA-Omniscience index moving from -10 to +1, the first non-negative reading for this tier.
The agent context bill falls for a second reason. OpenAI shipped higher default cache hit rates, discounts eligible shared prefixes reused within 30 minutes, and removed two things that used to break the cache: changing reasoning effort mid-conversation and enabling or disabling tools. For an input-heavy job this is a larger saving than the token price change.
Coding at maximum effort reaches a level that used to cost much more. OpenAI reports 66.6 percent on DeepSWE v1.1 at maximum effort, comparable to Claude Opus 5 and Claude Fable 5 at medium effort at 93 percent less per task than the former and 96 percent less than the latter.
ChatGPT allowance rises. OpenAI's published estimate for local messages per five-hour window on Plus goes from 250 to 2,000 for GPT-5.6 Luna to 350 to 3,000 for GPT-6 Luna. Those are the vendor's estimates and cloud chats and image generation draw on the same credit pool.
The honest counterweight, stated once and then carried through this review:
The tier did not get smarter. Artificial Analysis measured the Intelligence Index at 37, identical to GPT-5.6 Luna, and the Coding Agent Index fell 2 points to 41 with regressions on SWE-Atlas-QnA, 49 percent to 44 percent, and DeepSWE, 66 percent to 64 percent. The independent summary is that the cost fell and the capability stayed where it was or moved slightly backwards.
Knowledge work regressed more than on the sibling. Artificial Analysis measured about a 75-Elo drop on GDPval-AA v2.1, against about 100 for Sol, and a further roughly 45 Elo on AA-Briefcase v1.1, which Sol did not lose. Its team attributes the losses to reduced presentation quality and incomplete results.
The agentic ceiling is the tier's real limit. On Terminal-Bench 4.0 the published figure is around 13 percent at maximum effort. Luna reads and transforms well and does not hold a long tool loop together.
Effort selection is not optional and the cheap setting is the dangerous one. On OpenAI's own DeepSWE chart, Luna at low effort produced very few accepted patches, and the figure moves to 44.5 percent at medium and 66.6 percent at max. A team that routes work to Luna at low effort to save money is not saving anything; it is producing unusable output at a low price.
Independent measurement found the effort curve is not monotonic either. On Agents' Last Exam, Luna's medium setting scores above its high setting.
Long context is billed by a step, not a slope. Above 272,000 input tokens the whole request is charged at 2 times the input and cache rates and 1.5 times the output rate. A pipeline built to exploit the 1M window should measure that threshold rather than assume a linear cost.
No open weights and no self-hosting. At this price the argument for a self-hosted open model is about data control rather than cost, which is a narrower argument than it was.
Who Should Use GPT-6 Luna
Learner type | Difficulty | Typical ROI | Career path |
Students (Bachelor, Master) | Beginner for the desktop app, Intermediate for API use | Free in the desktop app, which makes it the cheapest way to work across long documents at this generation. Useful for reading more material than you would otherwise open. The Skill Illusion is the live risk: a summary you cannot defend is not a skill, and at this price nothing prompts you to slow down. | UIT (Technology, AI, Data Science) tracks, plus MCC Research Methods for the reading workload. UDA to confirm the micro-credential mapping. |
Professionals (career upskilling) | Intermediate to Advanced | The strongest case is production plumbing: extraction and classification at volume, routing, first-pass triage, and the reading layer under a larger agent. Measurable in cost per accepted result rather than in output volume. | UIT engineering tracks. UIB (Business Management, Entrepreneurship) for the unit-economics work, because the tier's value is a budget decision before it is a technical one. UDA to confirm the programme mapping. |
Everyone (lifelong learners) | Beginner in the desktop app | A free, fast model with a 1M-token window is a real reading partner for long documents. It offers no teaching mode, so the learning has to come from what you do with the output. | SL-OS information intake, LIPS Collect and Review phases. |
Skill level required: Beginner to reach it in the desktop app. Intermediate to use it well, because the decision that governs the result is which effort level you run and whether you have a validator on the other end.
Prerequisites: A free ChatGPT account for the desktop app. A paid plan for ChatGPT Work and Codex, with an administrator turning the model on for the workspace on Enterprise and Edu. For the API, an OpenAI account with billing. The real prerequisite is a check: extraction and classification only pay off when you can verify the output programmatically, so the schema or the validator is the thing to build first.
Typical time to first result: Under three minutes in the desktop app. Under ten minutes on the API, including writing the request.
Typical time to competence: Five to ten hours of active use to learn where the tier holds and where it breaks: which effort level your own tasks need, and what your validator has to catch. Most of that time is spent building the check rather than learning the model.
U365 Institutes Alignment
The institute rows below were confirmed and corrected by UDA (University 365 Department of Academics), which owns the academic alignment content for this review. Two rows differ from the first URC draft: UIB reads Medium rather than Medium to High, and UIC reads Low to Medium rather than a flat Medium. UIT at High and UID at Low are unchanged. High is a statement about relevance and not about quality, which matters here because the Quality sub-score on this tier is 4.
Institute | Relevance | Why |
UIT (Technology, AI, Data Science) | High (primary) | The tier's named work is the work UIT programmes assess: batch pipelines, structured outputs against a schema, prompt caching, subagent routing, and validator design. It adds a competency the flagship reviews could not teach as sharply, measuring effort against accepted output, which is measurable on a student budget. |
UIB (Business Management, Entrepreneurship) | Medium | The deployment decision is a budget decision before it is a technical one, so the unit economics are the reason the tier exists. UDA corrected this row down from Medium to High: the tier produces the measurement record, not the business artefact the measurement is for. |
UIC (Digital Communication, Marketing) | Low to Medium | A coursework use exists in content operations: summarizing threads and transcripts, reformatting at volume, and a first pass over more material than a person can read. Nothing beyond coursework is supported, because it returns no sourced evidence and its knowledge-work regressions took the form of reduced presentation quality and incomplete results. |
UID (Digital Design, UX/UI) | Low | It reads images, so bulk alt-text drafting and asset classification at volume are possible. That is a production chore rather than a design competency, and the tier generates no images and no video. |
The row for UIT is primary: the tier's named work is the work UIT programmes assess, and it adds a competency the flagship reviews could not teach as sharply, which is measuring effort against accepted output on a student budget. The row for UIB is Medium rather than High because the tier supplies the measurement and not the judgement the measurement is for. The row for UIC is Low to Medium: a coursework use exists in content operations, and nothing beyond coursework is supported, because the tier returns no sourced evidence and independent measurement found its knowledge-work regressions taking the form of reduced presentation quality and incomplete results. The row for UID is Low: reading images for bulk alt-text drafting and asset classification is a production chore rather than a design competency, and the tier generates no images and no video.
Credential anchors
Five credential chains are anchored to programmes verified as published on university-365.com on 2026-09-23. Four belong to UIT and one to UIB, and the UIB chain is conditional. There is deliberately no chain for UIC or for UID.
GPT-6 Luna skill | U365 competency | Credential anchor | Stacks into | Institute |
Defining a schema, separating missing from wrong from invented values, and counting the three failure classes separately | Validation design for machine-readable output | Data Scientist (diploma) | Master of Science in IT | UIT |
Choosing an effort level on accepted results rather than on the price list, and measuring cost per accepted item including the cache share and the long-context threshold | Cost and reliability engineering for AI-dependent systems | Cloud Computing Specialist (diploma) | Bachelor of Science in IT | UIT |
Setting an escalation threshold from the cost of a miss, sampling the items a cheap tier cleared, and measuring the escalation rate | Analysis and routing design under measurement | Data Analyst Expert (diploma) | Master of Science in IT | UIT |
Running a narrowly scoped agent under an orchestrating model with a written task boundary per agent and a review per agent, and reading what it wrote to its own memory | Agent supervision and multi-agent boundaries | AI Developer Specialist (diploma) | Bachelor of Science in IT | UIT |
Building the cost-per-accepted-result case for a high-volume AI workflow, with the long-context step and the review time included, and stating the flip conditions | AI economics and delivery governance for business | AI Business Specialist (diploma), conditional | Bachelor of Business Administration, then Master of Business Administration | UIB |
The first chain is the central credential claim in this review. That competency is the one the tier cannot supply for the user: the model can write the extraction, and only the Fellow can decide what counts as a wrong row. It is also the chain most likely to survive the tool being switched off. Adjacent anchors for neighbouring competencies, all verified live on the same date, include Software Developer, Full-Stack Web Developer, Python Developer, Python Data Scientist, Tech Leader, Data Visualization Consultant, Microsoft Excel Specialist, Business Analysis Professional, Financial Analysis Specialist, Digital Transformation Strategist, and Microsoft 365 Expert.
Two constraints apply to these links. Do not expect a deep link for a micro-credential component page, because none exists for any name, so the institute page is the link. And no access level is asserted for any programme, because the catalogue does not expose one: the rule is that DISCOVERY Fellows hold Basic access, INSIDER Fellows hold Basic and Foundation, and SUPERHUMAN Fellows hold everything including degrees.
Where this tier belongs in the U365 methods
It fits LIPS Collect well, because cost is the constraint that decides how much material a Fellow can bring in. It must not own the Action Plan or the Review phase, which are where judgement accumulates. U.Copilot should route Fellows to it for extraction, classification, routing, summarization, and reading-layer work where a check already exists in code or in a named sampler. U.Copilot should route Fellows away from it for anything that runs longer than a few tool calls, anything the Fellow cannot check in code or arrange for another person to check, anything that will be sent in a Fellow's own name, and any task the Fellow is doing in order to learn it.
How GPT-6 Luna Works
Inputs: Text prompts, documents, images, and structured API requests. Through the API, a conversation history plus tool definitions, or a batch file. Through Codex, a narrowly scoped task from an orchestrating agent.
Outputs: Text, structured output against a schema, and tool calls. Up to 128,000 tokens per response.
Underlying technology:
Model: GPT-6 Luna, API identifier gpt-6-luna. Cost tier of the GPT-6 family below GPT-6 Sol and GPT-6 Astra. OpenAI states Sol and Luna were trained with methods similar to Astra's.
Reasoning effort across six levels: none, low, medium (default), high, xhigh, max. Luna supports none, which GPT-6 Astra does not, and none is the setting that makes the cheapest work cheapest.
Structured outputs are supported, which is the feature that turns this tier into a pipeline component rather than a chat partner.
Responses and Chat Completions are both supported as endpoints, but built-in tools and function calling should use the Responses API. On Chat Completions, function calling works only when reasoning effort is none. Batch is supported and priced at 50 percent of Standard.
Prompt caching: eligible shared prefixes reused within a 30-minute window receive the discount. Cached input reads are $0.01 per million, 10 percent of the uncached rate. Explicit cache breakpoints let you choose where a cached prefix ends. For an input-heavy Luna job this is where most of the saving lives.
Long context: prompts above 272,000 input tokens are billed at 2 times the input and cache rates and 1.5 times the output rate for the whole request, rather than only for the tokens above the threshold.
Not supported on this model: fine-tuning, embeddings, image generation as an endpoint, video, speech, transcription, translation, moderation, and the Assistants API. Rate limits start at 500 requests and 500,000 tokens per minute on Tier 1.
Delivery surface, checked separately from the model: Codex CLI and the ChatGPT desktop app. OpenAI's subagent documentation names the Luna tier for fast, narrowly scoped, high-volume agents and states that subagent workflows are enabled by default in current Codex releases. That surface writes local memory files and runs parallel agents, which is the basis of both clause findings in Section 7.
Integrations: OpenAI API, ChatGPT Work, Codex (CLI, IDE extension, web, iOS, cloud tasks), the ChatGPT desktop app, Amazon Bedrock, and MCP servers.
Benchmark figures, OpenAI-published. OpenAI published selected comparisons rather than a full table this time. Its footnotes state that competitor scores come from public reports, that Claude Fable 5 stands in where Fable 5.1 was unavailable, and that evaluations ran in OpenAI's research environment rather than production ChatGPT.
Benchmark | What it measures | OpenAI's figure for GPT-6 Luna | Comparison OpenAI publishes |
AutomationBench 1.0.6 | Business workflows across 47 tools | 20.7% at `max`, about $0.04 per task | Beats its predecessor by 5.4 percentage points at 58 percent lower cost per task |
Agents' Last Exam V1 | Long-horizon professional tasks across 55 sub-industries | 50.9% at `max`, $0.15 per task | Comparable to much more expensive models at a fraction of the per-task cost |
FrontierCode 1.1 Main | Merge-ready code | 42.4% at `max`, about $0.11 per task | Above Sol at low effort |
DeepSWE v1.1 | Software engineering in real codebases | 66.6% at `max`, about $0.22 per task | Comparable to Claude Opus 5 and Claude Fable 5 at medium effort, at 93 percent less per task than the former and 96 percent less than the latter |
OSWorld 2.0 offline | Computer use, partial reward | 52.7% at `max` | Above GPT-5.6 Sol at medium effort at roughly a tenth of the cost |
Factuality, internal | De-identified conversations where users flagged a mistake | 7.6% error rate at `max` | Matches GPT-5.6 Sol at roughly a hundredth of the cost |
Coding deception, internal | Answers containing detected deception under adversarial prompts | 2.8% | 9.5% for GPT-5.6 Luna |
Warning circumvention, internal | Attempts to work around an explicit access-denied message | 42.4% | 78.5% for GPT-5.6 Luna |
Read the method before the numbers, in four steps.
First, the DeepSWE comparison is the headline and it is a price comparison rather than a capability claim. Luna at max matching a frontier model at medium is a real result and it says more about the cost of frontier-tier capability than about Luna's ceiling.
Second, the effort level in every row is max, which is Luna's most expensive setting and still cheap. Every one of these figures is the model at its best, not at its default. On OpenAI's own DeepSWE chart the same model at low effort produced very few accepted patches, and at medium it reached 44.5 percent. The distance between the number in the table and the number a default deployment would produce is the most important thing in this section.
Third, the competitor set stops at Claude Opus 5 and Claude Fable 5. Claude Opus 5.5 was released by Anthropic about 90 minutes before this launch and appears nowhere in OpenAI's comparisons.
Fourth, the alignment rows come from deliberately adversarial setups and OpenAI states the tests do not measure failure rates in typical use. Luna's improvement here is genuine and larger than Sol's on the warning-circumvention row, moving from 78.5 percent to 42.4 percent. It is still a non-compliance rate above 40 percent on a direct instruction.
Independent benchmark results:
Source | Method | Result |
Artificial Analysis | Intelligence Index v4.3.2, maximum effort | 37, identical to GPT-5.6 Luna, against 48 for GPT-6 Sol, 53 for GPT-6 Astra, and 58 for Claude Opus 5.5. |
Artificial Analysis | Coding Agent Index, maximum effort, in OpenAI's Codex environment | 41, down 2 points from GPT-5.6 Luna's 43. SWE-Atlas-QnA fell from 49 percent to 44 percent and DeepSWE from 66 percent to 64 percent. |
Artificial Analysis | Cost per Intelligence Index task | $0.07 against $0.18 for GPT-5.6 Luna, about 60 percent less, while using more output tokens per task, about 51,000 against 41,000. |
Artificial Analysis | AA-Omniscience, knowledge and hallucination | Hallucination rate 77 percent, down from 93 percent. Accuracy broadly unchanged at 43.8 percent against 43 percent, and the index moved from -10 to +1. |
Artificial Analysis | GDPval-AA v2.1, economically valuable tasks across 44 occupations, Elo | About 75 Elo points below GPT-5.6 Luna, at 1,367. Its team reports the regressions were driven mainly by reduced presentation quality and incomplete results after manually inspecting hundreds of outputs. |
Artificial Analysis | AA-Briefcase v1.1, multi-week knowledge work projects, Elo | About 45 Elo points below GPT-5.6 Luna. GPT-6 Sol was level on this evaluation, so the loss is specific to the cheap tier. |
Artificial Analysis | AutomationBench-AA, its own adaptation | 53 percent against 50 percent for GPT-5.6 Luna. |
Artificial Analysis | Terminal-Bench 4.0, its own run | Around 13 percent at maximum effort. This is the tier's weakest published result on an agentic benchmark and the clearest statement of where it should not be used. |
Available platforms: ChatGPT Work and Codex (web, CLI, IDE extension, iOS, cloud tasks) on paid plans, the ChatGPT desktop app for Free and Go users, the OpenAI API through the Responses, Chat Completions, and Batch endpoints, and Amazon Bedrock. Not open weights, and not available for local deployment.
Getting Started with GPT-6 Luna
Required accounts: A free ChatGPT account for the desktop app. A paid ChatGPT plan for ChatGPT Work and Codex: Plus, Pro, Business, Enterprise, or Edu. Enterprise and Edu administrators must enable the model for the workspace. For the API, an OpenAI account with billing. No account is required to read the documentation.
Installation: Nothing to install for the desktop app. Codex is available as a CLI, an IDE extension, a web surface, and cloud tasks. For API access, nothing beyond an HTTP client or one of the official SDKs.
First-time configuration:
In the desktop app, open the model picker and select GPT-6 Luna. If it is not there, the rollout is gradual and OpenAI's own advice is to try again later.
Set the effort level deliberately and record what you chose. The default is medium and OpenAI's published rows are all at max. Start at max for anything with a consequence, because at this price the difference between medium and max is measured in cents per hundred calls, and the difference in accepted output is measured in tens of percent. On one published coding chart, low effort produced very few accepted patches.
Build the validator before you build the pipeline. Structured outputs let you demand a schema, and the schema is what catches the failure mode that matters here: a well-formed response with a wrong value. Measure missing fields, wrong values, and invented values separately, because they need different fixes.
Turn caching on deliberately for input-heavy jobs. Cached input reads are $0.01 per million against $0.10 uncached. Explicit cache breakpoints let you choose which prefix is cached, and the diagnostics tool explains a cache miss rather than leaving you to guess.
Check the 272,000-token threshold before pointing a large job at it. Above it the whole request is billed at 2 times the input and cache rates and 1.5 times the output rate, so a job that reads 400,000 tokens costs more than double a job that reads 270,000.
Use Batch or Flex where latency is not the constraint. Both are 50 percent of Standard rates, which puts output at $0.25 per million.
If you route Luna under a larger agent, review your memory settings. OpenAI's documentation states that local Codex memories are off by default and that turning them on is deliberate, while the same documentation set and the desktop settings present memory as a feature you manage. Decide where you stand rather than discovering it later. Section 7 explains why this matters more for Luna than for either sibling.
First 15 minutes checklist:
☐ Take one real extraction or classification job you already do by hand and run a batch of twenty items through it.
☐ Build the check before reading the output: define what a correct row looks like and count how many failed.
☐ Run the same batch at low and at max and compare the accepted counts, not the response text.
☐ Compute the cost of the batch from the usage figures, not from the price list.
☐ Confirm you know which endpoint you are on if you are calling tools, because on Chat Completions function calling only works at effort none.
Result: One batch completed, a validator you built, an effort setting chosen on evidence rather than on price, and a measured cost per accepted item. That is a working pipeline rather than a demonstration.
Real Workflows
Workflow 1: Document extraction at volume with a validator built first
Learner type: Professional. Operations, finance, or support engineer. CI-First benefit tags: Time, Quantity. Connects to: UIT engineering tracks and UIB (Business Management, Entrepreneurship) for the unit-economics side. UDA to confirm the programme mapping. Time estimate: Half a day to build the schema and the validator, then minutes per batch.
What you do vs what the tool does:
Step | You do | The tool does |
1 | Define the output schema and, separately, what makes a row wrong rather than merely missing. | (Nothing yet) |
2 | Assemble twenty real documents, including two you expect to be hard. | (Nothing yet) |
3 | Run the batch and record the usage figures. | Reads every document and returns structured rows. |
4 | Run the validator and count three failures separately: missing field, wrong value, invented value. | (Nothing. You measure.) |
5 | Raise the effort level and re-run only if the accepted rate is too low for the job. | Returns better-structured rows at higher effort. |
6 | Compute cost per accepted row and compare it against the manual baseline. | (Nothing. You decide.) |
Sample prompt:
Context: the attached files are [document type]. I need these fields extracted for every file: [field list]. A correct row has every field present and sourced from the document. Task: extract the fields for every file and return them as JSON against the schema I have given you. Constraints: if a field is not present, return null rather than guessing or inferring it. Do not normalise values that are ambiguous; return them as written. Do not add fields. Output format: one JSON object per file, in document order, with a "notes" array listing any field you were unsure about and why.
Verification checklist:
☐ Multi-Model Check: run the same batch on Sol and compare the rows where the two disagree. Disagreement is a better error signal than either model's confidence.
☐ External Source: validate every row against the system of record or a second source. A syntactically valid JSON object can contain a wrong total.
☐ Human Review: have the process owner check a sample of accepted rows, not the rejected ones.
☐ CI-First Test: can you state the extraction rules without reading the prompt? If not, the process is not documented.
Workflow 2: A cheap first pass that decides where the expensive model is needed
Learner type: Professional. Engineer, analyst, or content operations lead. CI-First benefit tags: Time, Quantity. Connects to: UIT engineering tracks. UDA to confirm the programme mapping. Time estimate: One to two hours to set up, then minutes per batch, with most of the saving coming from the reduced volume sent to the expensive tier.
What you do vs what the tool does:
Step | You do | The tool does |
1 | Define the triage rule: what makes an item worth escalating. | (Nothing yet) |
2 | Decide what a false negative costs, because that sets the escalation threshold. | (Nothing yet) |
3 | Run the batch at maximum effort. | Classifies, summarises, and flags each item against your rule. |
4 | Check the escalation rate and sample the items it cleared. | (Nothing. You verify the clears, not the flags.) |
5 | Send only the flagged items to the expensive model. | (Nothing. You route.) |
6 | Measure cost per batch and count how many cleared items were genuinely fine. | (Nothing. You decide.) |
A measured example from the community, reported by a third party rather than by the vendor. A test posted to Reddit ran a cheaper Luna tier and GPT-6 Astra over 50 real pull requests for code review. Astra confirmed 92 bugs, Luna confirmed 69, which is 75 percent of the accuracy at 3.6 percent of the cost. The published breakdown notes that Luna's misses were disproportionately the expensive kind rather than the obvious ones. That is the shape this workflow is designed around, and it is the reason step 4 verifies the clears and not the flags.
Sample prompt:
Context: the attached items are [item type]. They are arriving at about [volume] per day. I will send anything you flag to a more expensive model, and I will not review the items you clear. Task: classify each item against the rule below and flag the ones that need escalation. Rule: [your rule]. Constraints: when the rule does not clearly apply, flag the item. Do not summarise beyond one sentence. Do not attempt a fix or a recommendation. Output format: one row per item with an id, a class, a one-sentence reason, and flag yes or no.
Verification checklist:
☐ Multi-Model Check: run the triage on Sol as well and compare the flag lists. Items only one model flagged are the ones to read.
☐ External Source: for the cleared items, check a sample against the underlying artifact rather than against the summary.
☐ Human Review: a person who owns the outcome reviews the clears, because the flags get a second pass anyway.
☐ CI-First Test: can you defend the escalation threshold without the model? The threshold is the decision that governs the cost, and it is yours.
Workflow 3: A free reading layer for long documents
Learner type: Everyone (lifelong learners), and students working through a reading list. CI-First benefit tags: Time. Connects to: LIPS Collect and Review phases, SL-OS information intake. UDA to confirm the mapping. Time estimate: Under an hour for a first pass over 10 to 20 documents, plus the time you would have spent reading the key sections anyway.
What you do vs what the tool does:
Step | You do | The tool does |
1 | State the question the reading must answer and what would make a document irrelevant. | (Nothing yet) |
2 | Supply the documents, and note that the window is large enough for all of them at once. | Reads the whole set in one request. |
3 | Ask for a comparison across documents rather than a summary of each. | Produces a cross-document view that reading one at a time would not give you. |
4 | Read the two or three source passages that carry the argument. | (Nothing. You verify.) |
5 | Write your conclusion yourself, and say what the first pass could not settle. | (Nothing. This is the part that is yours.) |
Sample prompt:
Context: I am working on [question]. The attached documents are the only sources. My expertise is [level]. Task: tell me what these documents agree on, where they disagree, and what none of them answers. Constraints: no information from outside the attachments. Quote the passage behind each point. Do not smooth over a disagreement. Output format: three headings, Agreement, Disagreement, Not answered. Under each, the points with their document and passage. At the end, list the two passages I should read in full and why.
Verification checklist:
☐ Multi-Model Check: run the same question on Sol and compare the Disagreement heading, which is where a cheap model is most likely to flatten a real difference.
☐ External Source: read in full the two passages the model nominated.
☐ Human Review: discuss the disagreement list with someone who knows the material before you write.
☐ CI-First Test: can you state the disagreement without reopening the conversation? If not, you have a summary rather than an understanding.
Strengths, Limits, and AI Imposture Risk
Strengths
CI-First Benefit | Strength | Evidence |
Time | Cost per completed task fell about 60 percent on independent measurement, at a price where the difference decides whether a job runs at all. | Artificial Analysis measured $0.07 per Intelligence Index task against $0.18. Independent measurement also confirms the mechanism: more output tokens per task, 51,000 against 41,000, with the saving coming from the price cut. |
Quantity | The same budget now buys five times the calls per token, and the tier is free in the desktop app. | $0.10 and $0.50 against $0.20 and $1.20, and against the original $1 and $6 list the cut is 90 to 92 percent. Free and Go users get Luna in the desktop app. |
Quality | Marginal on the common case, and improved on one dimension. | Hallucination rate fell from 93 percent to 77 percent and the AA-Omniscience index moved from -10 to +1, against a Coding Agent Index drop of 2 points and knowledge-work regressions. |
Skill | No. It is delegation at volume with no teaching mode. | No learning affordances are claimed, and the delivery surface writes memory on the user's behalf. |
Limits
The tier did not get smarter. The independent Intelligence Index is identical to GPT-5.6 Luna at 37, against 48 for Sol and 53 for Astra.
Coding regressed on independent measurement. The Coding Agent Index fell 2 points, with SWE-Atlas-QnA down 5 points and DeepSWE down 2.
Knowledge work regressed on two independent benchmarks. About 75 Elo on GDPval-AA v2.1 and about 45 Elo on AA-Briefcase v1.1, and the Briefcase loss is specific to this tier because Sol was level there.
The agentic ceiling is low. The published Terminal-Bench 4.0 figure is around 13 percent at maximum effort. Luna reads and transforms well and does not hold a long tool loop together.
The published benchmark rows are all at max effort, which is not the default and not the cheapest setting.
The effort curve is not monotonic. On Agents' Last Exam, medium beats high.
A low-effort deployment produces very few accepted results on coding work, which is the failure mode a cost-driven rollout is most likely to hit.
Long-context billing is a step rather than a slope, so the 1M window costs more than a linear reading of the price list suggests.
No open weights and no self-hosting, so the tier's price advantage over a local model cannot be combined with data control.
The vendor's comparison set stops at Claude Opus 5 and Claude Fable 5, and Claude Opus 5.5 shipped the same evening.
AI Imposture Risk
Trap | Rating | Evidence |
Time Illusion | Low | The saving is measured rather than claimed, and the overhead is small relative to the benefit: a batch job either validates or it does not, and the validation runs in code. This is the one dimension where the tier is straightforwardly good, and it is why the trap is Low rather than Medium. The caveat is that a badly chosen effort level converts the saving into rework, which is a settings failure rather than a price illusion. |
Quantity Illusion | Medium | Output is cheap and reading is not. At five cents per thousand output tokens, the marginal cost of producing another draft approaches zero while the cost of reading it does not move. Independent measurement also found the knowledge-work regression takes the form of reduced presentation quality and incomplete results, which are the two defects that are easiest to miss when you are accepting more volume than you can read. |
Skill Illusion | High | Two mechanisms. First, the tier is explicitly designed to sit under an orchestrating agent that the user is not watching turn by turn, so its output is consumed by another model rather than by a person, and nobody develops judgement about it. Second, and this is the framework's clause 5.2.3-a: the Codex surface writes local memory files on the user's behalf. See the clause note below. |
Overall Imposture Risk: Medium. One trap is High with identifiable mitigations, and one is Medium. Under framework Section 5.3, one High with clear mitigations is Medium rather than High.
Framework v1.2 clause note
Clause 5.2.3-a, agent-authored procedural memory: APPLIES. The mechanism is Codex local memory, and it applies to this tier for the same reason it applies to the others and for one additional reason.
OpenAI's documentation states that Codex turns useful context from eligible prior chats into local memory files, that the main memory files live under the Codex home directory and include summaries, durable entries, recent inputs, and supporting evidence from prior chats, that the code skips short-lived sessions and redacts secrets, and that updates happen in the background rather than at the end of every chat. The documentation tells the user to treat those files as generated state rather than as a control surface.
The additional reason is that Luna is the tier OpenAI names for fast, narrowly scoped, high-volume agents. A model used that way runs many short sessions, and the memory-generation logic explicitly skips short-lived sessions. So the tier that writes the most sessions is the tier whose writes are least visible in the store the user is told not to read. The no-lower-than-Medium floor is met, because the user holds a documented capability they did not write. The High threshold is met because the writes happen during use without a per-write human decision and the documentation discourages the reading practice that would catch them. As with the sibling review, the documentation's own statement that local memories are off by default sits alongside a settings surface that presents memory as something the user manages; in a configured Codex installation with memory enabled, the store holds generated outputs.
Clause 7.5, team-level rooms: APPLIES, and more directly here than for either sibling. OpenAI's own subagent documentation names the Luna tier for fast, narrowly scoped agents handling clear, repeatable, or high-volume work, states that subagent workflows are enabled by default in current Codex releases, and states that the app surfaces each subagent thread so the user can inspect its work. That is several agents in one view alongside the human, which is the case the clause governs. It sets the consequence directly: each agent needs a written task boundary before it starts, the human reviews output per agent, and Cyborg is not available. The vendor's own warning that read-heavy work suits parallel agents while parallel write-heavy work creates conflicts is the same point from the engineering side, and it is the reason this review recommends Luna for reading roles and not for parallel editing roles.
Clause 4.2-a, agent-mediated conversation: does NOT apply to the model as a generator. The live condition to watch is the one that matters more for this tier than for the others, because it can draft at volume: erosion condition (a) would be met by a setup where an agent sends text in the person's own name through a connected account and the person does not read it first. At $0.10 per million input tokens the cost of sending unreviewed agent-authored messages is close to zero, so the guardrail has to be a rule rather than a budget. That is a property of the connector and of the deployment, not of this model.
Recorded together: clause 5.2.3-a applies, clause 7.5 applies directly through the vendor's own subagent guidance, and clause 4.2-a is a null with a live condition. The clause 7.5 finding is stronger here than in the GPT-6 Sol review, because the vendor names this tier as the one to use for the subagents.
U365 Co-Intelligence Rating
CI-First Profile
Primary profile: Co-Worker and Assistant (level 2). Secondary profile: Analyst and Tester (level 4).
Divergence from the sibling, stated rather than left to be noticed. The published GPT-5.6 Luna review records Coach and Tutor (level 3) as the secondary profile. This review drops it and records Analyst and Tester (level 4) instead. Nothing in this release supports the Coach role: the model has no teaching mode, it does not explain its reasoning in a way a learner could reconstruct, and its accuracy on answered questions is below half. The Analyst role is supported by how the tier is actually used, as a first-pass reader and code triager whose output a person or a larger model then acts on, which is the measured pattern in the community code-review test cited in Section 6.
Collaboration Mode
Recommended mode: Centaur. Alternative mode: Cyborg is not available where more than one agent shares a view or a channel, per clause 7.5. Unlike the GPT-6 Sol review, this review does not recommend Cyborg even for a single agent session. The tier's published agentic ceiling is low, so a tight human-in-the-loop iteration pattern is the only safe way to use it for anything with a consequence. Mode rationale: Two reasons, both from the framework. Section 7.2 says a tool whose Imposture Risk is Medium or High takes Centaur mode. Beyond the general rule, clause 7.5 applies directly because OpenAI's own documentation names this tier as the model for narrowly scoped subagents running under an orchestrating model, with subagent workflows enabled by default. That is by design a division of labour with the human outside the loop, and Centaur mode is what puts a written task boundary and a per-agent review back into it.
CI-First Benefit Score
Dimension | Score (0-10) | Rationale |
Time | 7 | Cost per completed task fell about 60 percent on independent measurement, and validation runs in code rather than by reading. Offset by the effort-selection decision, which can turn the saving into rework, and by the long-context billing step. |
Quantity | 7 | The same budget buys roughly five times the calls per token. The usable-output check holds it at 7 rather than higher: some of the additional volume arrives with lower presentation quality and incomplete results. |
Quality | 4 | The common-case quality did not improve and moved backwards in two places. The hallucination rate fell and the knowledge index turned positive, against a 2-point coding index drop and knowledge-work regressions on GDPval-AA and AA-Briefcase. The framework says to score the common case and the verified output, and the verified output here is roughly where it was. |
Skill | 1 | Pure delegation at volume, with no teaching mode, and the delivery surface writes memory the user did not author. The framework says to score this dimension conservatively when in doubt. |
CI-First Benefit Score: 4.8 / 10 (CI-First Positive)
The score does not move, and that is the finding
4.8 with sub-scores 7 / 7 / 4 / 1 is identical to the published GPT-5.6 Luna review at every dimension. That is not an oversight and it is not a failure to update, and it is a stronger statement for this tier than for either sibling.
The framework's Section 9.2 says to score the honest user, the net benefit rather than the gross benefit, the common case rather than the best case, and the user rather than the tool. GPT-6 Luna cut the price by 50 to 92 percent depending on which base you use, improved the hallucination rate, and improved caching. It also lost 2 points on the independent coding index and roughly 75 and 45 Elo on two knowledge-work benchmarks. The improvements and the regressions are in different places, and neither changes what the person using it has to do: choose an effort level, build a check, read what came back, and decide.
One point needs to be made explicitly, because the framework's own arithmetic makes it easy to misread. A CI-First Benefit Score of 4.8 places GPT-6 Luna in the CI-First Positive band, and the label means exactly what the framework says it means: the tool delivers clear net benefit, Co-Intelligence is greater than Human Intelligence alone for most users, and it is worth adopting with disciplined usage. It does not mean the tool is weak. A 4.8 at $0.10 per million input tokens is a different proposition from a 4.8 at flagship prices, and the framework scores benefit rather than value for money. Readers comparing this review against the GPT-6 Sol review, which scores 6.0, should read the difference as capability rather than as a recommendation against the cheap tier.
Humics Protection Badge
Dimension | Rating | Rationale |
Creativity | Neutral (0) | The tier is used for extraction, classification, and summarization, which are not creative acts. It neither sparks nor replaces ideation, because it is not asked to ideate. Same rating as GPT-6 Sol and GPT-5.6 Luna. |
Critical Thinking | Erodes (-1) | This is the tier's clearest Humics risk and it is a function of price rather than of capability. At $0.10 per million input tokens, the cost of a wrong answer is low enough that checking it feels disproportionate, and the checking is the only part of the process that builds judgement. The published warning-circumvention figure, 42.4 percent of runs attempting to work around an explicit access denial, means the model's compliance should never be assumed rather than checked. Its reliability improvement also partly takes the form of answering less. |
Social Authenticity | Neutral (0) | The model produces text rather than speaking in the user's name, and the framework's clause 4.2-a records agent-mediated conversation as neutral by itself. The erosion condition that would change this rating is a deployment that sends agent-authored text in a person's name without the person reading it, and at this price that deployment is easy to build by accident. The rating stays at 0 for the model and the condition is recorded in Section 7. |
Humics Protection Score: -1 / +3 Badge: Humics-Neutral
Superhuman Usage Guidance
When to invite this tool:
Extraction, classification, routing, and summarization at volumes where the input price decides whether the job runs at all.
A first pass that decides where an expensive model or a person should look, with the escalation threshold set by the cost of a miss.
The reading layer under a larger agent, summarizing retrieved material before it reaches the main model.
Long-document reading where the question is cross-document and you will check the passages that carry the argument.
When to keep this tool out:
Anything that runs longer than a few tool calls. The published agentic figure is around 13 percent on Terminal-Bench 4.0, and long tool loops are where this tier fails.
Anything where the answer cannot be checked by code or by a person who did not write the prompt. At five cents per thousand output tokens the temptation to skip the check is the whole risk.
Anything sent in a person's own name. It produces the same register every time, and at this price an unreviewed agent-authored message costs nothing to send, which is the reason to write the rule before wiring the connector.
Final judgement calls: what to publish, what to tell a client, what to escalate. Those are the Humics this tier does not supply.
Work that needs an auditable artifact, since there are no weights and no way to inspect what the model does internally.
U365 method integration:
LIPS + CARE: a strong fit for the Collect phase, because cost is the constraint that decides how much material you can bring in. It should not own the Action Plan or Review phases, which are where judgement accumulates.
ULM + EVA: relevant to Career through the cost-per-accepted-result framing, which is a business skill as much as a technical one. Weak fit for the other domains.
UP-Context: it responds well to explicit context, a role, a task, constraints, and a named output format, and the schema in the output format is what makes the result checkable. The workflows in Section 6 use that order.
SL-OS: usable as the intake and reading layer of an SL-OS automation stack, with the check on your side of the boundary.
UNOP: no fit. There is no teaching behaviour to align with a pedagogy.
Over-delegation warning: the failure mode with this tier is that the price removes the natural brake. When a wrong answer costs a fraction of a cent, checking it feels optional, and the checking is the entire skill. The specific pattern to watch is the pipeline that grows: a first pass becomes a first and second pass, then a summarization layer, then an agent that drafts the reply, and at no point does anyone read the output end to end because the output was never the expensive part. The framework's clause 5.2.3-a and clause 7.5 both point at the same place from different directions: this tier is designed to run under an orchestrating model, out of a person's sight, and a person who cannot say what it produced is holding a capability they do not have. The CI-First formula is the test. At this price the Artificial Intelligence term is genuinely cheap, which is exactly why the Human Intelligence term needs a rule rather than a budget to stay in place.
What Users Say
Aggregate Rating Table
Platform | Rating | Number of reviews | Link |
Hacker News | 1,337 points, 651 comments on the launch thread, read 2026-09-23 | Not a rating platform | https://news.ycombinator.com/item?id=49805509 |
Artificial Analysis | Intelligence Index 37 at maximum effort, Coding Agent Index 41, $0.07 per index task | Independent measurement, not user reviews | https://artificialanalysis.ai/models/gpt-6-luna |
OpenRouter | Weighted average price actually paid is below the list rate because of caching. A measured cache-hit rate of about 85 to 90 percent on the main provider. | Usage telemetry, not reviews | https://openrouter.ai/openai/gpt-6-luna |
G2 | No model-level rating for GPT-6 Luna. G2 rates ChatGPT as a product and its pages return HTTP 403 to automated retrieval. No figure is reproduced here. | Not applicable | https://www.g2.com |
Capterra | No model-level rating found. | Not applicable | https://www.capterra.com |
Trustpilot | No model-level rating. OpenAI is rated as a company, not per model. Page returns HTTP 403 to automated retrieval. | Not applicable | https://www.trustpilot.com |
Product Hunt | ChatGPT, the product, has a listing. GPT-6 Luna has no separate listing. | Not applicable | https://www.producthunt.com/products/chatgpt |
Apple App Store | The ChatGPT app is rated in the region of 4.7 out of 5 from a very large number of ratings. This is the consumer product across all models and is not a rating of GPT-6 Luna. | Not model-specific | https://apps.apple.com/us/app/chatgpt/id6448311069 |
Positive on price, disputed on measurement. r/singularity and r/codex discussed the release on launch day. Reddit returns HTTP 403 to automated retrieval, so threads were read through search indexing rather than fetched. | Several threads | https://www.reddit.com/r/singularity/ |
Note on method, stated plainly because it affects how much this section is worth. No review platform rates an individual language model. Every aggregate score found covers the ChatGPT product or OpenAI the company, and third-party aggregators disagree with each other. Reproducing any of those numbers as a rating for GPT-6 Luna would be fabrication. The meaningful signals for a model released the previous day are the developer discussion, the independent benchmark platforms, and the practitioners who ran it themselves. Those are what this section reports.
Three sources cited in this review refuse automated retrieval: G2, Trustpilot, Capterra, the Reddit subreddit pages, and the openai.com/index/... marketing pages all return HTTP 403 to a scripted request. Their substance was reached through search indexing and through secondary reporting that quoted them. The Reddit and G2 entries above are named and linked to the community or platform root rather than to a specific thread, because a specific thread URL could not be verified from this environment. Nothing in this review states a number that came from a page it could not read.
What Users Praise
Two themes dominate the discussion of this tier specifically, and both are cost arguments rather than capability arguments.
The first is that the price puts the model on the cost-efficiency frontier for most tasks. The developer reaction on the launch thread was that a closed model at this price makes the argument against using many other models hard to sustain on cost grounds alone, and that the previous cheap tier was already the most used model on at least one major routing platform by monthly volume. That is usage evidence rather than quality evidence, and it is the right kind of evidence for a tier whose value is the price.
The second is that it is useful as a component rather than as an assistant. The most repeated practitioner framing is that this tier is for the work that sits under something bigger: reading, triage, summarization at volume, and sub-agent reading. OpenAI's own documentation says the same thing about where to use it inside Codex, which is unusual agreement between the vendor and its users about a model's proper place.
A third theme appears in the practitioner tests rather than in the launch discussion, and it is the more useful one: the tier's ceiling is about effort, not about the model. Reports that run the tier at its maximum setting describe it holding up on tasks that would previously have gone to a bigger model, while reports that use it at a default or low setting describe unusable output. Both are describing the same model.
What Users Complain About
Three complaints recur.
The first is measurement, and it is a dispute rather than a complaint. On the launch thread a cost comparison used token prices to argue that a cheap open-weights model was cheaper than Luna, and other commenters corrected it on the grounds that the comparison ignored how many tokens each model needs to complete a task. The correction is right and the underlying argument is the one this review makes throughout: token price is not cost per completed task, and the cheaper model on the price list is not always the cheaper model on the bill. A separate commenter made the opposite point from the other direction, that no accounting of reasoning tokens makes a token-price comparison unreliable.
The second is the effort dial, and it is the complaint that has a concrete cost attached. Practitioners report that the cheap setting produces very few acceptable results on coding work and that the tier only becomes useful at higher effort, which means the price advantage is smaller in practice than the list rate suggests. The published per-effort charts support them. This is the single most important thing for a team planning a rollout to understand before it routes work by price.
The third is the same-everything problem. Practitioners describe output that is serviceable and characterless, and the vendor's own communication-style change, toward shorter and less jargon-heavy answers, is a change in register rather than in substance. For content operations this matters more than the benchmark numbers do.
A fourth objection comes from the benchmark community rather than from users: the tier's coding result is lower than its predecessor's on the independent index, and the launch coverage picked that up within hours. Users repeat it and it is correct.
Sentiment Summary
Overall sentiment: Predominantly positive on price and on the tier's place in a stack, with the effort-versus-quality trade understood by practitioners and understated by the vendor.
Key themes:
The price reduction is the substance of the release and it is confirmed independently at about 60 percent per task.
The tier did not get smarter. The independent intelligence score is level with its predecessor and the coding index fell 2 points.
The effort setting, not the model, decides whether the output is usable, and the published rows are all at the highest setting.
The hallucination rate improved substantially and the knowledge index turned positive for the first time in this tier.
The tier is best understood as a component under an orchestrating model rather than as an assistant.
Long tool loops are where it fails, which is the one thing that did not improve.
U365 Editorial Note
User sentiment and the CI-First evaluation agree closely, and the agreement is about where the tier belongs rather than how good it is.
Users say the value is the price, and the framework scores Time at 7 because the cost per completed task fell about 60 percent on independent measurement. Users say the tier belongs under a larger model rather than in front of a person, and the framework reaches the same conclusion by two routes: clause 7.5, because the vendor names this tier for subagents running by default inside a shared view, and Skill at 1, because a model used that way has no learning surface. Users complain that the cheap effort setting produces unusable output, and the framework's Time score stays at 7 rather than rising for exactly that reason: the saving is real and it is conditional on a settings decision the reader now has to make. Users correct each other on token price versus cost per task, which is the framework's own method stated in a forum thread.
Where the evaluation adds something the sentiment does not is the score itself. A 4.8 with the Skill dimension at 1 and two clause applications is the framework saying that a tool can be excellent value and still not make you more capable, and that both statements belong in the same review. The strongest thing in this tier is its price. The weakest thing is the reason the price is dangerous: the cheaper the answer, the less the act of checking it feels necessary, and checking is the only part of the process that builds the person.
Comparison and Alternatives
Alternative | Choose the alternative if... | Choose GPT-6 Luna if... |
GPT-6 Sol (https://developers.openai.com/api/docs/models/gpt-6-sol) | The task is multi-step, ambiguous, or runs a tool loop longer than a few calls. Sol's published Terminal-Bench 4.0 result is 43 percent against Luna's 13 percent, and Sol's independent intelligence score is 48 against 37. | The task is narrow, repeated at volume, and checkable by a validator. Luna at maximum effort matches Sol at `xhigh` on the published DeepSWE chart for about a fifth of the cost per task. |
GPT-6 Astra (https://openai.com/index/gpt-6-astra/) | The outcome justifies fifty to a hundred times the rate per token. Astra leads on OpenAI's own AutomationBench and OSWorld charts and on the independent Intelligence Index at 53 against Luna's 37. | The volume is the constraint rather than the difficulty, and a validator or a second model covers the accuracy gap. |
Claude Opus 5.5 (https://www.anthropic.com/claude-opus-5-5) | You want the top of the independent composite, at 58 against Luna's 37, and the work cannot be checked by code. | Cost per task is the binding constraint and the work has a programmatic check. Do not treat this as a controlled comparison: no one has run both in one evaluation setup on cost per completed task, and the price difference is large enough that the two are not really competing for the same job. |
GPT-5.6 Luna (https://developers.openai.com/api/docs/models/gpt-5.6-luna) | Nothing recommends it now for new work. Its input price is double GPT-6 Luna's and its output price is 2.4 times higher. | You are moving off it, which is the point of the release. The GPT-5.6 Luna review is already marked Changed. |
Gemini 3.8 Flash (https://ai.google.dev) | The work is native audio or video, which this tier does not accept, or you need Google's throughput. Note that the introductory input rate doubles on 2027-01-01. | The work is text and image input, and the input price is the dominant line in the bill. |
DeepSeek V4.1 Flash (https://api-docs.deepseek.com) or another cheap open-weights model | Data cannot leave your infrastructure, or you need an auditable artifact. | The comparison is a total-cost argument rather than a per-token one. Independent measurement puts GPT-6 Luna cheaper per completed task than open-weights alternatives that use more tokens to finish the same job, so compare on completed tasks and on cache behaviour rather than on the price list. |
A local model via ollama.com/search | The workload is steady enough to justify hardware and the data cannot leave. | The workload is bursty, or the volume is too low to justify hardware, or you want a 1M-token context without a deployment. |
Grok 4.7 (https://docs.x.ai) | You want a low list price under 200,000 prompt tokens and your work fits that window. | You want the lower list price outright. The published comparison puts Luna about 95 percent cheaper on input against Grok 4.7's lowest-cost tier. |
Where GPT-6 Luna is clearly better: on cost per completed task in the cheap tier, with the same-day independent measurement behind it rather than a vendor claim. Artificial Analysis measured $0.07 per Intelligence Index task against $0.18 for its predecessor, about 60 percent less, and the price is now below most hosted open-weights options on input. It also leads on hallucination rate for the first time in this tier, down from 93 percent to 77 percent, with the knowledge index moving from negative to positive. For extraction, classification, routing, summarization, and sub-agent reading at volume, this is the strongest position in OpenAI's line-up and probably in the market.
Where GPT-6 Luna is clearly worse: on the agentic ceiling, where the published Terminal-Bench 4.0 figure is around 13 percent at maximum effort and long tool loops are where the tier fails; on independent knowledge-work benchmarks, where it lost about 75 Elo on GDPval-AA v2.1 and about 45 on AA-Briefcase v1.1 against its predecessor; on coding, where the independent index fell 2 points; on the non-monotonic effort curve, where medium beats high on one published benchmark and low produces almost no accepted results on coding; on register, since it produces serviceable and characterless output; and on auditability, with no weights and no self-hosting. If a claim will be relied on without a programmatic check, this is not the tier to rely on.
Verdict and Next Steps
Who should adopt it: Teams running high-volume, well-specified text work that can be verified in code: extraction, classification, routing, summarization, first-pass triage, and the reading layer under a larger agent. Also individual users on a free ChatGPT account, because the desktop app gives them a 1M-token model at no cost, which is the most generous access change in this release.
When: Now, with three conditions. Set the effort level deliberately and start higher than the price suggests, because the published rows are all at maximum effort and the cheap setting is where the tier produces unusable output. Build the validator before you build the pipeline. And keep the tier out of long tool loops and out of anything sent in a person's own name.
For what: Bulk reading and transformation where the input price decides whether the job runs, a first pass that decides where an expensive model should look, and the reading layer under an orchestrating agent.
The honest caveat, stated once: the price reduction is real, independently confirmed, and larger than the vendor's headline once measured against the list rate rather than a promotional one. The capability is not: the independent intelligence score is level with the model it replaces and the coding index fell. Those two facts are not in tension, and the CI-First score of 4.8 with a Skill dimension of 1 says both at once. This tier is the best value in OpenAI's line-up for the jobs it fits, and it fits fewer jobs than the price makes you want to give it. Its two clause findings both point the same way: it is designed to run under another model, out of your sight, writing memory you did not author. Use it where the check is cheap. That is where value and capability agree.
UP-Context prompt pack
##
Three packs replace the URC drafts in Section 11, covering the same three jobs. Each follows the UP-Context order (context, role, task, constraints, output format) and adds a verification close.
What UDA changed, and why. URC's three drafts are good prompts and they are written for a model with no teaching behaviour and no stopping rule. UDA closed four gaps:
No Role line. The UP-Context order begins with context and role, and attributing a profile before giving a task is a stated CI-First discipline. The Role line is also what makes the boundary explicit: the Fellow holds the finish line and the verification.
No effort-level pin. On this tier the effort decision governs whether the output is usable at all, because the published rows are all at maximum effort, the default is medium, and the lowest setting produced very few accepted patches on coding work. A pack that leaves the setting unstated invites a default that produces unusable output, and the reader then concludes the tool is bad rather than the setting being wrong.
No cost record. At these rates the cost record is the evidence base for the whole workflow, and a pack that does not ask for it produces a result nobody can defend on the next review.
No verification close that puts the check in the Fellow's hands. URC's drafts end at the output format. The framework's Skill Illusion mitigation requires a reproduction step, and on a tool with no Profile 3 assignment the reproduction has to be written into the process.
#
Prompt Pack 1: Extraction at volume with the schema built first and the effort level pinned
Context: the attached files are [document type]. I need these fields for every file: [field list]. A correct row has every field present and sourced from the document. This runs at about [volume] files per week, so the cost of a wrong row is counted per accepted row rather than per response. Role: AI as Co-Worker and Assistant (Profile 2). You extract and report. I hold the schema, the acceptance test, the verification, and the decision to use the output. Task: extract the fields for every file and return them as JSON against the schema below. Constraints: if a field is not present, return null rather than inferring it. Do not normalise an ambiguous value; return it as written. Do not add fields. Do not correct a value you believe is wrong; return it and flag it. Report the effort level you ran at in one line at the top, because I set it and I need to know what it was. Output format: one JSON object per file in document order, then a "notes" array listing every field you were unsure about and why, then the usage figures you can see for this request. UP-Context verification: I built the schema and the acceptance test before this run, and I count three failures separately, missing field, wrong value, invented value, because they need three different fixes. I run the same batch at two effort levels and compare accepted counts rather than reading the responses. I compute cost per accepted row from the usage figures and put it in LIPS beside the effort level. If I cannot state the extraction rules without reopening this conversation, the process is not documented and the batch does not count.
Prompt Pack 2: A triage pass that keeps the escalation threshold mine
Context: the attached items are [item type], arriving at about [volume] per day. Anything you flag goes to a more expensive model or to a person, and I will not review the items you clear. A miss here costs [what a false negative costs], which is what set my threshold. Role: AI as Analyst and Tester (Profile 4). You classify and flag, and you mark what does not hold up. I decide what escalates and I own the threshold. Task: classify each item against the rule below and flag the ones that need escalation. Rule: [your rule]. Constraints: when the rule does not clearly apply, flag the item. One sentence of reason at most. Do not attempt a fix or a recommendation. Do not summarise beyond what the rule needs. Do not soften a flag because the item looks low risk; the threshold is mine, not yours. Output format: one row per item with id, class, one-sentence reason, and flag yes or no, then the count of flagged and cleared items, then the effort level you ran at. UP-Context verification: I sample the CLEARED items, not the flagged ones, because the flagged items get a second pass anyway and the clears do not. I check the clear sample against the underlying artefact rather than against your summary. I record the escalation rate and the cost of a miss in LIPS, because those two numbers are the decision. If I cannot defend the threshold without the model, then the threshold belongs to the model and not to me.
Prompt Pack 3: A cross-document read that surfaces the disagreement
Context: I am working on [question]. The attached documents are the only sources and they are the version I will cite. My expertise in this area is [level]. The reading list is longer than I can read closely, so this pass decides where I read in full. Role: AI as Analyst and Tester (Profile 4). You read across the set and mark what does not hold up. I decide what the material means and what I write. Task: tell me what these documents agree on, where they disagree, and what none of them answers. Constraints: no information from outside the attachments. Quote the passage behind each point. Do not smooth over a disagreement or average two positions into one. Do not summarise each document separately, because a per-document summary is what I can already produce myself. Output format: three headings, Agreement, Disagreement, Not answered, with the document and the passage under each point, then the two passages I should read in full and why, then the effort level you ran at. UP-Context verification: I read the two nominated passages in full before I write anything. I check the Disagreement heading first, because that is where a cheap tier is most likely to flatten a real difference. I write my conclusion myself and store it in LIPS with the passages I verified. If I cannot state the disagreement without reopening this conversation, I have a summary and not an understanding, and the Skill Illusion applies to me.
Instruction for UDE. Replace the three URC drafts in Section 11 with the three packs above. The Role line, the effort pin, and the verification close are the parts the drafts lacked, and they are the parts that make the packs usable in U365 coursework on a tier whose default setting is not its best setting.
Related U365 content
INSIDE Tools Review: GPT-6 Sol (the tier above this one, scored 6.0)
INSIDE Tools Review: GPT-6 Astra (the frontier tier of the same generation, scored 7.0)
INSIDE Tools Review: GPT-5.6 Luna (the model GPT-6 Luna replaces, scored 4.8)
INSIDE Tools Review: GPT-5.6 Terra (the balanced tier of the previous generation, which has no GPT-6 successor)
INSIDE Tools Review: DeepSeek V4.1 Flash (the cheap-tier cost comparison)
INSIDE Tools Review: Claude Opus 5.5 (the same-evening competitor at the other end of the range, scored 6.5)
U365 UIT programme, the first credential anchor: Data Scientist, 60 days. https://www.university-365.com/challenge-page/data-scientist-diploma
U365 UIB programme, the conditional credential anchor: AI Business Specialist, 18 days. https://www.university-365.com/challenge-page/ai-business-specialist-diploma
U365's Recommendations to Learn More
These resources were curated to help you go deeper on GPT-6 Luna. Every link and every video below was resolved on 2026-09-23. We prioritise material that teaches something this review does not cover.
Official learning resources
Introducing GPT-6 Sol and Luna: the vendor's own claims, the cost-per-task charts, the alignment results, and the footnotes that qualify the competitor comparison. https://openai.com/index/introducing-gpt-6-sol-and-luna/
GPT-6 Luna model reference: the endpoint support matrix, the reasoning-effort options, the rate limits, and the exact token and cache prices. This is the page that confirms none effort and the tool support. https://developers.openai.com/api/docs/models/gpt-6-luna
Better prompt caching for GPT-6: the caching changes that matter most for an input-heavy Luna job, including cache-safe effort and tool toggles and the diagnostics tool. https://openai.com/index/better-prompt-caching-for-gpt-6/
Codex subagents: the vendor's own guidance on which model to use for fast, narrowly scoped, high-volume agents, and the settings that control parallel agents. Read this before routing Luna into an agent stack. https://learn.chatgpt.com/docs/agent-configuration/subagents
Codex local memories: how Codex generates memory files from prior chats, where they are stored, and the vendor's own instruction to treat them as generated state. This is the basis of this review's clause 5.2.3-a finding. https://learn.chatgpt.com/docs/customization/memories
GPT-6 Astra system card: the alignment work Luna builds on, including the metagaming and alignment-generalisation sections that qualify the deception figures. https://deploymentsafety.openai.com/gpt-6-astra
API pricing: the token, cache, batch, flex, and fast-mode rates, plus the long-context multiplier. https://developers.openai.com/api/docs/pricing
Video tutorials and channels
GPT-6 Sol and Luna, Pricing and Benchmarks, by United Top Tech. A straight walk through the published rate card, including the observation that the output price fell further than the input price for Luna. https://www.youtube.com/watch?v=rZ2myXdJYdI
GPT-6 Sol and Luna - Pricing/Benchmarks | Better than GPT-6 Astra? by United Top Tech
GPT-6 Luna vs Sol, I Tested Both on Real Work, by AI Words Explained. Gives both tiers the same four workplace tasks, which is the routing question this review's Section 10 answers from published data. https://www.youtube.com/watch?v=0wyl2G1WU5Q
GPT-6 Luna vs Sol: I Tested Both on Real Work by AI Words Explained
GPT-6 Sol vs Claude Opus 5.5 LIVE, Which AI Model Is Better?, by The Neuron. A same-session comparison of the two models that launched on the same evening. https://www.youtube.com/watch?v=X0ERFFbjEug
GPT-5.6 Luna First Test, Hands-On With OpenAI's CHEAPEST Model, by Bijan Bowen. Covers the previous-generation cheap tier at maximum effort on browser workflows, C++ game creation, 3D CAD modelling, and frontend design, which shows what this tier is asked to do and where it breaks. https://www.youtube.com/watch?v=1nf7VqduM3Y
Evaluating the GPT-5.6 family, by Braintrust. An independent evaluation design across 225 tasks and six models; useful for the method, which is the point worth copying for a Luna rollout. https://www.youtube.com/watch?v=5jzUVjno-OQ
GPT-5.6, The Review, by Theo. A practitioner review of the previous generation that treats the cheap tier as a component under a larger agent, which is the framing this review recommends. https://www.youtube.com/watch?v=IyoTJHLmClo
I reviewed Opus 5.5 and GPT-6 Sol live, and the results surprised me, by How I AI. A blind-comparison format that tests how much of a benchmark difference is visible in practice. https://www.youtube.com/watch?v=LMT-bknLmNo
Claude Opus 5.5 vs GPT-6 Sol, Everything You Need to Know, by Universe of AI. A structured side-by-side of the two models that launched the same evening, useful context for where this tier sits. https://www.youtube.com/watch?v=vG2rNycYdQQ
Written tutorials and deep-dive articles
Artificial Analysis, GPT-6 Sol and Luna push the cost efficiency frontier: the same-day independent measurement, including the per-task costs, the coding index movement in both directions, and the hallucination and knowledge-work findings this review relies on. https://artificialanalysis.ai/articles/gpt-6-sol-and-luna-push-the-cost-efficiency-frontier
Artificial Analysis, GPT-6 Luna release page: the intelligence and cost figures at every effort level, which is where the low to max spread becomes visible. https://artificialanalysis.ai/models/releases/gpt-6-luna
Apidog, What is GPT-6 Luna: the pricing fine print, including that the 50 percent comparison runs against a promotional rate and the list-price reduction is 90 to 92 percent. https://apidog.com/blog/what-is-gpt-6-luna/
OmniaKey, GPT-6 Luna review: a specification-led reading with reproducible cost arithmetic, and an explicit statement that it did not run a controlled benchmark. https://omniakey.com/blog/gpt-6-luna-review
Codersera, GPT-6 Sol and Luna complete guide: per-effort transcriptions of OpenAI's charts, including the Luna coding curve from a very low accepted-patch rate at low effort to 66.6 percent at max. https://codersera.com/blog/gpt-6-sol-luna-complete-guide-2026/
The Decoder, OpenAI's GPT-6 Sol and Luna cut prices in half but barely move the needle on performance: the independent regressions and the reasoning-level sprawl. https://the-decoder.com/openais-gpt-6-sol-and-luna-cut-prices-in-half-but-barely-move-the-needle-on-performance/
The New Stack, OpenAI releases GPT-6 Sol and Luna and cuts token prices in half: a same-day read with the per-task framing and the caching changes. https://thenewstack.io/openai-gpt-6-sol-luna-release/
Coursiv, GPT-6 Sol and Luna, pricing, benchmarks and availability: a clearly labelled reading of the launch numbers that states what is not independently confirmed. https://coursiv.io/blog/gpt-6-sol-luna
Community and social
Hacker News launch thread: 1,337 points and 651 comments, including the cost-per-completed-task argument and the correction that ended it. https://news.ycombinator.com/item?id=49805509
r/singularity discussion of the independent benchmark results: the argument over same-tier performance at half the price. Read via search indexing because Reddit returns HTTP 403 to automated retrieval. https://www.reddit.com/r/singularity/
r/codex: Codex configuration, effort levels, and subagent routing, which is where this tier is actually used. Same retrieval limitation. https://www.reddit.com/r/codex/
r/OpenAI: the largest general OpenAI community. Same retrieval limitation. https://www.reddit.com/r/OpenAI/
OpenRouter model page: the weighted average price actually paid and the measured cache-hit rate across providers, which is a useful reality check on the list rate. https://openrouter.ai/openai/gpt-6-luna
OpenAI status page: check this before concluding the model is behaving badly. https://status.openai.com
Resources on X
Dedicated X channels:
@OpenAI: the official account, carrying the launch announcement. https://x.com/OpenAI
@OpenAIDevs: the developer-facing account, carrying the per-benchmark developer breakdown and the caching changes. https://x.com/OpenAIDevs
@ArtificialAnlys: the independent evaluation account, carrying the cost-efficiency frontier result and the per-task token comparison. https://x.com/ArtificialAnlys
X posts with video content:
The Artificial Analysis thread on the cost-efficiency frontier result: the $0.07 against $0.18 per-task comparison and the 51,000 against 41,000 output-token figure that shows the saving comes from price rather than efficiency. https://x.com/ArtificialAnlys/status/2102462962758033624
Artificial Analysis on X: the cost-efficiency frontier result and the per-task token comparison
The OpenAI Developers thread giving the per-benchmark developer summary, including Luna's 58 percent lower cost per task on AutomationBench. https://x.com/OpenAIDevs/status/2102461432684282061
OpenAI Developers on X: the per-benchmark summary, including 58 percent lower cost per task on AutomationBench
Tibor Blaho's summary thread covering both same-evening launches side by side, including the API prices and the caching discounts. https://x.com/btibor91/status/2102511469556609105
These channels and posts were resolved on 2026-09-23. Thumbnail images must be captured from the posts themselves at assembly time, and each image must match its own post.
Glossary
CI-First Benefit Score
The average of four dimensions, each scored 0 to 10: Time, Quantity, Quality, and Knowledge and Skill. It answers whether using the tool makes Co-Intelligence more profitable than Human Intelligence alone. Bands: 0 to 2.0 CI-First Negative, 2.1 to 4.0 CI-First Neutral, 4.1 to 6.0 CI-First Positive, 6.1 to 8.0 CI-First Strong, 8.1 to 10.0 CI-First Transformative. The score accounts for the overhead of prompting and verification, not just the benefit the tool produces. GPT-6 Luna scores 4.8, which places it in the CI-First Positive band.
CI-First Profile
The role the AI plays in your working relationship. (level 1) Co-Creator and Thought Partner, (level 2) Co-Worker and Assistant, (level 3) Coach and Tutor, (level 4) Analyst and Tester, (level 5) Challenger and Devil's Advocate. Lower level numbers indicate higher AI autonomy. Assigning a profile before giving the AI a task is a core CI-First discipline. GPT-6 Luna is primarily a Co-Worker and Assistant (level 2).
Humics Protection Badge
A rating of whether a tool protects, leaves neutral, or erodes three human capabilities: Creativity, Critical Thinking, and Social Authenticity. Each is scored +1, 0, or -1, and the sum gives the badge. +2 to +3 is Humics-Friendly, -1 to +1 is Humics-Neutral, -2 to -3 is Humics-Risky. It measures whether the tool strengthens the human or contributes to AI Obesity. GPT-6 Luna is Humics-Neutral at -1 / +3.
AI Imposture Risk
The likelihood that a tool traps you in one of three illusions. The Time Illusion is the appearance of saving time when net time is lost. The Quantity Illusion is high volume that looks good but does not survive inspection. The Skill Illusion is the appearance of competence in you while the underlying skill is absent or eroding. Each trap is rated Low, Medium, or High with cited evidence, and the overall level is Low when all three are Low, High when two or more are High. GPT-6 Luna is Medium overall, with Time Low, Quantity Medium, and Skill Illusion High.
User Sentiment
The aggregated public opinion from review platforms, community forums, and repository activity. It is reported separately from the CI-First score because crowd sentiment can contradict a rigorous evaluation. Where the two agree, the finding is stronger. Where they diverge, the divergence is worth explaining.
Review Status
Review Status records the current standing of the tool at the time of the last test. Active: the tool is current and recommended. Active (updated): recently re-checked and the content was refreshed. Changed: a re-check trigger fired and an update is pending, so read the review with that in mind. Risky: the tool has significant unresolved issues, or it has been clearly surpassed by newer alternatives. Use it with caution and read the Limits section. Retired: the tool still works but is no longer recommended. Deprecated: the tool has been shut down or fundamentally changed. Retired and Deprecated posts include a Migration Path section.
Sources
Vendor primary sources
OpenAI, Introducing GPT-6 Sol and Luna, 2026-09-22: https://openai.com/index/introducing-gpt-6-sol-and-luna/
OpenAI, Better prompt caching for GPT-6, 2026-09-22: https://openai.com/index/better-prompt-caching-for-gpt-6/
OpenAI developer documentation, GPT-6 Luna model reference: https://developers.openai.com/api/docs/models/gpt-6-luna
OpenAI developer documentation, GPT-6 Sol model reference, for the tier comparison: https://developers.openai.com/api/docs/models/gpt-6-sol
OpenAI developer documentation, API pricing: https://developers.openai.com/api/docs/pricing
ChatGPT Learn, subagents, covering parallel agents, custom agents, and the vendor's model guidance for subagents: https://learn.chatgpt.com/docs/agent-configuration/subagents
ChatGPT Learn, local Codex memories, covering generated memory files and their storage: https://learn.chatgpt.com/docs/customization/memories
ChatGPT Learn, custom instructions with AGENTS.md, covering the instruction chain: https://learn.chatgpt.com/docs/agent-configuration/agents-md
OpenAI Deployment Safety Hub, GPT-6 Astra system card: https://deploymentsafety.openai.com/gpt-6-astra
OpenAI, GPT-6 Astra launch page, for the family positioning: https://openai.com/index/gpt-6-astra/
OpenAI, GPT-5.6 launch page, for the previous-generation rate card including the July Luna price cut: https://openai.com/index/gpt-5-6
OpenAI status page: https://status.openai.com
Independent sources
Artificial Analysis, GPT-6 Sol and Luna push the cost efficiency frontier, 2026-09-22: https://artificialanalysis.ai/articles/gpt-6-sol-and-luna-push-the-cost-efficiency-frontier
Artificial Analysis, GPT-6 Luna release intelligence, performance and price: https://artificialanalysis.ai/models/releases/gpt-6-luna
Artificial Analysis, GPT-6 Sol release page, for the tier comparison: https://artificialanalysis.ai/models/releases/gpt-6-sol
The Decoder, OpenAI's GPT-6 Sol and Luna cut prices in half but barely move the needle on performance, including the independent GDPval and AA-Briefcase regressions: https://the-decoder.com/openais-gpt-6-sol-and-luna-cut-prices-in-half-but-barely-move-the-needle-on-performance/
The New Stack, OpenAI releases GPT-6 Sol and Luna and cuts token prices in half: https://thenewstack.io/openai-gpt-6-sol-luna-release/
VentureBeat, OpenAI releases GPT-6 Sol and Luna models, slashing API costs 50 percent or more, including the vendor statement that the pricing is permanent: https://venturebeat.com/technology/openai-releases-gpt-6-sol-and-luna-models-slashing-api-costs-50-or-more
MacRumors, OpenAI's new GPT-6 Sol and Luna models bring Astra improvements to cheaper tiers: https://www.macrumors.com/2026/09/22/openai-gpt-6-sol-luna/
9to5Google, Claude Opus 5.5 and OpenAI GPT-6 Sol and Luna lower costs, on the same-evening timing: https://9to5google.com/2026/09/22/claude-opus-5-5-and-openai-gpt-6-sol-luna-both-launch-today-with-lower-costs/
AWS, OpenAI GPT-6 Sol and GPT-6 Luna now generally available on Amazon Bedrock, including the Luna use-case description: https://aws.amazon.com/about-aws/whats-new/2026/09/openai-gpt-6-sol-luna-on-amazon-bedrock
Apidog, What is GPT-6 Luna, on the pricing fine print and the list-price reduction: https://apidog.com/blog/what-is-gpt-6-luna/
OmniaKey, GPT-6 Luna review, a specification-led reading with an explicit no-benchmark statement: https://omniakey.com/blog/gpt-6-luna-review
Codersera, GPT-6 Sol and Luna complete guide, with per-effort transcriptions of OpenAI's charts: https://codersera.com/blog/gpt-6-sol-luna-complete-guide-2026/
Coursiv, GPT-6 Sol and Luna, pricing, benchmarks and availability: https://coursiv.io/blog/gpt-6-sol-luna
OpenRouter, GPT-6 Luna pricing, providers, and the weighted average price actually paid: https://openrouter.ai/openai/gpt-6-luna
Benchmark sources cited by the vendor: AutomationBench (https://zapier.com/benchmarks), Agents' Last Exam (https://agents-last-exam.org/), DeepSWE (https://deepswe.datacurve.ai/), FrontierCode (https://cognition.com/frontiercode), OSWorld 2.0 (https://osworld-v2.xlang.ai/)
Community and community-reported evidence
Hacker News, GPT-6 Sol and Luna launch thread, 1,337 points and 651 comments as of 2026-09-23: https://news.ycombinator.com/item?id=49805509
Reddit r/singularity, discussion of the independent benchmark results, read via search indexing: https://www.reddit.com/r/singularity/
Reddit r/codex, Codex configuration and effort-level discussion, read via search indexing: https://www.reddit.com/r/codex/
Reddit r/OpenAI, general community discussion, read via search indexing: https://www.reddit.com/r/OpenAI/
Internal sources
Internal U365 references: CI-First Evaluation Framework v1.2, sections 3 (benefit rubric), 4 (Humics, including clause 4.2-a), 5 (Imposture risk, including clause 5.2.3-a), 6 (profiles), 7 (collaboration modes, including clause 7.5), and 9 (scoring procedure); and the INSIDE Tools Post Template including the LLM variant. Both are internal to University 365; the published Tools Reviews index is public at https://www.university-365.com/tools
Published INSIDE Tools Reviews used as internal comparisons: GPT-5.6 Luna (23953db5-9c06-4b33-bf87-b72916bba7cb, 4.8, CMS status Changed), GPT-6 Astra (2920efd3-cb02-45a2-97ce-1f25681f8d39, 7.0), GPT-5.6 Sol (d6dcd31d-b8ee-434a-89b1-82c5f9c1b9e2, 6.0), GPT-5.6 Terra (e270600a-2423-41d4-b027-246976ec1adf), DeepSeek V4.1 Flash, and Claude Opus 5.5 (68d6b045-4797-430c-b579-b3371d4d8063, 6.5). The published index of every Tools Review is at https://www.university-365.com/tools
Faculty Note on Evidence Quality
Four claims from this release did not survive checking against primary sources, and for a tier whose entire case is price, the difference matters more than it does on the flagship.
First, the headline price reduction is measured against a promotional rate. OpenAI's own sentence compares GPT-6 Luna to GPT-5.6 Luna's promotional pricing of $0.20 and $1.20. The GPT-5.6 Luna list price when it shipped in July was $1 and $6, and that rate had already been cut by 80 percent. Measured against the promotional rate the reduction is 50 percent on input and 58 percent on output. Measured against the list rate it is 90 percent on input and 92 percent on output. A reader who quotes "half price" is quoting the smaller of the two numbers, and a reader budgeting from a pre-July price sheet will find the change much larger than the headline. The stronger version of the finding is the vendor's own: a spokesperson told a reporter the pricing is permanent, which means the promotional base will not recur.
Second, the published benchmark rows are all at maximum effort, which is not the default and not the cheap setting. OpenAI's table shows Luna at max throughout, where it is genuinely cheap and genuinely good. On OpenAI's own per-effort charts the same model at low effort produced very few accepted patches on coding work, and at medium it reached 44.5 percent before climbing to 66.6 percent at max. The default is medium. A team that deploys this tier at its default and reads the launch table as a description of what it will get has been misled by omission rather than by misstatement, and the omission is the important part.
Third, the tier did not get smarter, and one independent benchmark says it got slightly worse. The independent Intelligence Index is 37 for both GPT-6 Luna and GPT-5.6 Luna. The Coding Agent Index fell 2 points, with SWE-Atlas-QnA down 5 points and DeepSWE down 2. On knowledge work, about 75 Elo was lost on GDPval-AA v2.1 and about 45 on AA-Briefcase v1.1, and the Briefcase loss is specific to this tier because GPT-6 Sol was level on that evaluation. The vendor's framing is cost efficiency, which is accurate, and the framing should not be read as a capability improvement.
Fourth, the reliability improvement is partly a change in behaviour rather than in knowledge. OpenAI reports Luna at higher effort matches GPT-5.6 Sol's factuality at roughly a hundredth of the cost, on an evaluation built from conversations where users had already flagged an error, and it states those conversations are not representative of typical use. Independent measurement found the hallucination rate falling from 93 percent to 77 percent while accuracy stayed broadly flat at 43.8 percent against 43 percent, and the knowledge index moved from -10 to +1. A model that answers fewer questions incorrectly and about the same number of questions correctly is safer and is not more knowledgeable, and for a high-volume pipeline the distinction is the difference between a declined field and a correct one.
All four cases teach the same lesson, which is the one this review is built on. When a vendor's headline sentence and the vendor's own footnotes say different things, read the footnotes, and say so when they differ. OpenAI published several of these footnotes itself, including the statement that its adversarial tests do not measure failure rates in typical use and the note that its factuality evaluation uses conversations selected because they caused errors. That makes the footnotes the useful part.
Review conducted by URC under the CI-First Evaluation Framework, version 1.2. Scoring date 2026-09-23. Tool version reviewed: GPT-6 Luna (`gpt-6-luna`, released 2026-09-22). Framework version applied: 1.2.
Comments