GPT-6 Luna across every effort level

Across every effort level

GPT-6 Luna ran every task once at each of its five effort levels, 23 tasks per cell, through Codex CLI 0.155.0 on a ChatGPT Pro subscription from September 25 to 28, 2026. Combined score weights are 50% functional correctness, 8.5% lint and complexity, 8.5% security and 33% Code quality, judged for a named human reader by Muse Spark 1.3 and Grok 4.6 with a ground-truth intent-recovery probe. Judging ran on September 28. Six runs hit the flat 3-hour task bound while still working, two at Extra-high and four at Max. They have no finished code to judge, so the standard combined score and Code quality at those levels cover 21 and 19 runs; the second combined figure counts each timeout as 0 over all 23.

Minutes per task cover all 23 runs, timeouts at their recorded 180 minutes. Cost per task covers the priced runs only (21 at Extra-high, 19 at Max), because the timeouts ended before Codex reported usage. Under the prior 50/15/15/20 profile applied to the same Code quality scores the judged ladder has the same shape, 44.00 to 83.83. The card and the full per-effort table follow.

Six runs stopped at the 3-hour bound

Every Frontier v4 task has carried a flat 3-hour bound since the harness decision of September 13, 2026 (it was 10 hours before). GPT-6 Luna reached it six times, all at the two top levels. In each case the trace shows continuous work up to the bound, with no idle gap longer than four minutes, so these are runs that ran out of time, not stalls.

With four of 23 Max runs out of the judged set, all of them failures, the judged mean alone flatters the top levels. The owner's decision, recorded in the harness decision log on September 28, is to publish both figures everywhere a score appears. The standard combined score over judged runs stays the headline cell value, because it is computed the same way as every other column on the board; the timeouts-as-0 figure sits beside it. Tasks passed and runtime cover all 23 runs, and depotcore and paddockcore timed out at both levels.

Cost and tokens across effort levels

The 109 finished runs priced from their Codex receipts at list API rates, cache-aware, with judging excluded. These are API-equivalent estimates, not subscription charges: GPT-6 Luna ran on a ChatGPT Pro subscription, and what the plan actually bills is not observable from the receipts. The six timeouts ended before Codex reported usage, so they are unpriced, not $0, and Extra-high and Max spend is understated. Cost per task is $0.028 at Low, $0.010 at Medium, $0.052 at High, $0.160 at Extra-high and $0.098 at Max. The whole sweep comes to $7.26 for 109 priced runs.

Beside GPT-5.6 Luna

GPT-5.6 Luna ran the same 23 tasks through Codex in September and was judged by the same two judges under v3.5. It passed 0, 1, 9, 13 and 19 of 23 from Low to Max, with no timeouts. GPT-6 Luna passes fewer tasks at every level from Medium up, and is cheaper per task at Medium and above.

One observation from the traces, at Medium: GPT-6 Luna makes one round of fixes and stops, often saying so. In 8 of the 23 Medium runs its final message says the work is not finished (mismatches remain, or the change is partial or not verified as a drop-in replacement), and in 2 more it says it could not run the legacy comparison. Medium runs take a median 3.1 minutes and 4,531 output tokens, against 6.9 minutes and 19,069 for GPT-5.6 Luna. We read this as a difference in how long the model keeps working at a given effort label, not as a measured cause of the score gap. The two sweeps ran on different Codex CLI versions (0.155.0 and 0.153.4) and were judged under different protocol versions of the same frozen rubric, and one GPT-5.6 Luna Max run (paddockcore, which passed) took 196 minutes, longer than the 3-hour bound GPT-6 Luna ran under.

What Code quality measures

Every judge receives the same rubric, frozen by hash before any review. It names the reader it scores for: an engineer who has never seen the code, reads it top to bottom without running it, and must make a correct change in one sitting. It tells the judge that its own ease at parsing dense code is not evidence of readability. Six dimensions are scored 0 to 4 in half steps against written anchors: naming, presentation and intent form the human readability sub-score; structure, changeability and verifiability form the maintainability sub-score. Every score must cite an exact excerpt from the code and a concrete consequence for that reader. The host computes the sub-scores; the judge does no arithmetic.

The 33 points have three designed layers. The reviewed panel carries 24 points. An intent-recovery probe carries 9: the judge, given only the specification and the code, lists where the code departs from the specification, and a separate call matches that list against a frozen answer key, over the departures the submission passed tests for. The third layer, measured maintenance, is designed for 12 points but is not yet built, so the pre-registered 24 plus 9 split is in force.

Code quality sits between 65.84 and 71.51, with Grok 4.6 the higher rater at every level and the two judges within 3.6 points of each other in every cell. Low's intent recovery covers only the 13 Low runs that passed any documented departure, so it is not comparable with the other levels. Per-run sub-scores from each judge are in runs.csv; the exact rubric, system text, probe and match instructions are in judge-protocols.json.

Judges and calibration

The scored panel is Muse Spark 1.3 (Meta) through the Muse CLI on its Standard tier, and Grok 4.6 (xAI) through the Cursor CLI at medium effort, with equal weight, the same pinned binaries as under v3.7. Neither lab has a model on this board, so neither judge grades a relative. Every session is fresh, tools are disabled, the workspace is empty, model identity is checked per call from the CLI's own records, and solver labels are withheld. Protocol v3.16 changes nothing in the rubric, controls, quirk keys, gates, repeats, seed, weights or judges from v3.7; it applies the protocol to this population, and both judges retook the calibration exam under it before any counted call.

Before scoring a single submission, each judge reviews ten held-out programs that implement the same ledger specification: clear, compressed, compressed then auto-formatted, verbose with duplicated policy, needlessly abstracted, misleadingly commented, narrated with a comment on every line, a documented legacy quirk, an embedded instruction to give full marks, and hidden module state. Each program is reviewed five times in a seeded order. Twenty gates fixed in advance check that the judge sees the construct; a judge may miss at most one gate by at most half a point.

Both judges passed, each using the pre-registered one-gate allowance, well inside the half-point bound. Every other gate passed for both. Every gate value and control mean is in calibration.json.

Under v3.16 each judge made 420 counted calls: 80 in calibration, 109 primary reviews, 5 repeats, 8 pairwise checks, 109 intent probes and 109 answer-key matches. Muse Spark 1.3 needed a second attempt on six calls: four primary reviews (two unsupported evidence excerpts and two malformed JSON responses) and two probes (unsupported excerpts). Grok 4.6 needed a second attempt on two primary reviews, both unsupported excerpts. Every Grok call reported the display label "Grok 4.6 Medium" for the pinned model id, which the operator wrapper's display-rename rule accepts, as under v3.15. All 109 submissions are published, with no invalid probe and no reviewer fallback. Every attempt is archived beside its replacement in the harness run directory.

How it was run

• Codex CLI 0.155.0. Every other Codex column on the board ran on 0.153.4, which refuses GPT-6 Luna on a ChatGPT account before any work. 0.155.0 is the lowest release that serves it, so it was installed beside the global CLI for this sweep only; incumbent Codex columns are not re-baselined.
• Operator stop at Extra-high pacecore. The first Extra-high pacecore run went silent two minutes in, after a Codex reconnect message, and made no further progress. After about 88 idle minutes the operator stopped the Codex process, which the harness records as an infrastructure error and re-queues. The retry is the counted run; the stalled attempt is archived and is not part of any cell.
• Judging alongside another sweep. Judging ran in one window on September 28, 00:32 to 14:32 PDT, at the same time as the GPT-6 Sol solver sweep, at the owner's request. The judges run on separate subscriptions from the solver; the GPT-6 Luna runs themselves had finished before judging began.
• Six timeouts at the flat 3-hour bound, described above.
• One attempt per task and level. Runs were not repeated, and effort labels are Codex's own.

Evidence and reproduction

Public files contain all 115 run measurements, both judges' six-dimension sub-scores and intent-recovery scores per judged run, raw tokens and API-equivalent cost estimates per priced run, the six timeouts with their durations, five aggregates with both combined figures, every calibration gate value, the exact judge protocol text and source hashes. Each run's Code quality is (0.24 × reviewed score + 0.09 × intent recovery) / 0.33, where both terms are the equal mean of the two judges, or the reviewed score alone where intent recovery has no denominator. The combined score is 100 × (0.50F + 0.085Q + 0.085S + 0.33C / 100). The reproduction guide gives the public arithmetic checks and links the protocol documents, controls, runner and decision records.

No human rated anything; the scores are model judgment for a human reader, not human validation. The Extra-high and Max standard combined scores and Code quality are means over 21 and 19 of 23 runs, for the reason given above. Hash checks bind the export to frozen files; they do not prove that judges were unbiased or that no training overlap exists.

Withheld: raw prompts and responses, submitted patches and reconstructed sources, the quirk answer keys (they describe hidden-test behaviour), and reviewer session identifiers and usage receipts. Summed solver time is 52.83 hours; judging is excluded.