Can GPT-6 Luna High in Codex Handle Coding? Official Results and How to Try It

If you set GPT-6 Luna to “High” in Codex, can a smaller, efficient model handle more coding work than you might expect? It is easy to assume that serious development always requires a top-tier model. The evidence suggests GPT-6 Luna is worth trying: OpenAI reports results on a difficult software-engineering benchmark. But the headline result was measured at “max effort,” not Codex’s “High” setting. The sensible approach is to read the benchmark carefully and compare the settings on a small task in your own repository.

GPT-6 Luna is not limited to trivial coding tasks

OpenAI describes GPT-6 Luna as an efficient model for focused, high-volume tasks. At the same time, the company includes coding among the areas improved across the GPT-6 family and lists GPT-6 Luna as available in Codex. OpenAI’s GPT-6 Sol and Luna announcement OpenAI’s September 22 release notes also list GPT-6 Sol and Luna for Work and Codex, while noting that available models and reasoning options can depend on plan and workspace settings. OpenAI release notes

One notable result comes from DeepSWE v1.1, an evaluation of long-horizon software-engineering tasks in real codebases. OpenAI reports that GPT-6 Luna scored 66.6% at “max effort.” The same announcement also reports lower per-task costs than some comparison models. OpenAI’s coding results

That result is evidence that Luna can be considered for more than autocomplete or one-shot code snippets. It may be worth trying on a scoped bug fix, repository investigation, or a change that requires several steps. A lower-cost model does not automatically mean that it can only handle lightweight work.

However, 66.6% is not a promise that Luna will complete 66.6% of every developer’s tasks. It is a result reported by OpenAI under a particular evaluation setup. Results can change with the repository, instructions, available tools, and tests. Treat the benchmark as a reason to run your own comparison, not as a guarantee about your project.

“Max effort” and Codex “High” are different labels

This distinction matters. The 66.6% DeepSWE result was achieved at “max effort.” It was not a score for the “High” option in the Codex interface. OpenAI’s API model page lists none, low, medium, high, xhigh, and max as reasoning-effort values for GPT-6 Luna; the default is medium. GPT-6 Luna model specifications

OpenAI’s reasoning guide explains that higher effort means the model can reason more thoroughly, with tradeoffs in latency and token use. It lists high for complex debugging and agentic coding among other demanding tasks. OpenAI’s reasoning guide

Do not assume that API documentation maps every detail of the Codex application interface or benchmark setup. Codex combines a model with a project brief, tools, and an execution environment. The official materials cited here do not establish that “max” in the benchmark is equivalent to “High” in the app, or that both labels represent identical test conditions.

Check which GPT-6 Luna version Codex is using

Even when a model keeps the same name, release timing can differ by product. An OpenAI System Card dated October 7, 2026 says the GPT-6 Sol and Luna versions launched in ChatGPT in October were newer than the versions still being used in Codex and ChatGPT Work at that time. GPT-6 October 2026 System Card

So do not assume that changes announced for ChatGPT have already reached Codex. When comparing results, record the date, the model label shown in Codex, the reasoning setting, and the tools available. Product availability can change, so check the choices shown in your own environment before testing.

When might “High” help with coding?

“High” is not a universal quality switch. Based on the use cases in OpenAI’s guide, it is worth testing on tasks that involve several decisions: tracing a bug across dependencies, changing multiple related files, or isolating why a test fails.

For a small, clearly scoped change—renaming a variable or adjusting a few CSS rules, for example—start by checking whether “Medium” is sufficient. Higher effort does not remove misunderstandings or unwanted edits, and it may increase response time or usage.

Choose based on both difficulty and the impact of a mistake. A small prototype can be delegated in a reversible way, with the diff reviewed afterward. For production data or changes involving authentication and payments, a person still needs to review the design and tests, whatever the model setting.

Compare Medium and High in your own repository

Choose a small task that is safe to undo: fix one reproducible bug, add a boundary-value test to one function, or refine one specific screen. These are suggested test cases, not results measured for this article.

Keep the conditions consistent so that the setting is the main variable:

1. Use the same repository, branch state, prompt, and available tools.
2. Run “Medium” and “High” separately. Start from a branch or commit that lets you revert the change.
3. Define success first. For example: the bug is fixed, existing tests pass, and the change stays within the requested files.
4. Read the diff after each run. Confirm that tests actually ran and that existing behavior was not unintentionally changed.
5. Record elapsed time, retries, tests added, and how much manual correction remained.

Do not count generated code as success by itself. Check whether the model called a task complete while tests were failing, whether it touched unrelated files, and whether its explanation matches the diff. High may reduce editing on some tasks; Medium may be enough for others. Repeating a task a few times also helps reveal how consistent each result is.

Summary

GPT-6 Luna scored 66.6% on OpenAI’s DeepSWE v1.1 evaluation at “max effort,” making it a reasonable coding option to test. That score is not a result for Codex’s “High” setting, and the version available in Codex may differ from a later ChatGPT release. Use the benchmark as context, then compare Medium and High on the same small task and inspect the tests, diff, and amount of cleanup required.

The best reason to use High is not that a task looks complicated, but that your own code shows a clear improvement over Medium.