November 21, 2026 · Morgan Linton · 92 runs · Code quality protocol v3.32
Gemini 4 Neon across every effort level
92 runs of Google’s Gemini 4 Neon (gemini-4-neon) through the Antigravity CLI on a Google AI Pro subscription, 23 tasks at each of the four effort levels Antigravity offers for it, Low to Extra-high. Gemini 4 Neon is the first Google model on the board. Code quality carries 33% of the combined score and is judged for a human reader by Muse Spark 1.3 and Grok 4.6, the panel that judged Claude Opus 5.5, GPT-6.1 Sol and GPT-6.2 Sol, so Gemini 4 Neon takes its place on the Frontier v4 leaderboard beside them. Every run finished inside the 3-hour task bound. Low and Extra-high are judged on 22 of 23 runs, for the reason given under the results table.
How the test works
A retired program to rebuild
Each of the 23 tasks is a legacy binary with a written specification and an issue. Its real behaviour departs from the specification in documented ways, and hidden tests check the rewrite against the binary.
One attempt per task and level
Gemini 4 Neon works in Antigravity with the binary, the specification and the code, once per task at each effort level, inside a flat 3-hour bound, one task at a time.
Tests and two judges score it
Hidden tests give functional correctness. Two calibrated judges from labs other than Google rate the code for a human reader and try to recover the documented departures.
Scores, time and cost per level
Each level gets a combined score, tasks passed, minutes and API-equivalent cost at Google’s list price.
Combined score = 50% functional correctness + 8.5% lint and complexity + 8.5% security + 33% Code quality, averaged over the judged runs in each level, as on every other board column. Frontier Code quality is the reviewed layer plus intent recovery; it is never compared with Routine v1 Code quality.
Across every effort level
Gemini 4 Neon ran every task once at each of the four effort levels Antigravity offers for it (Extra-high is Antigravity’s xhigh; there is no Max), 23 tasks per cell, through Antigravity CLI 1.5.12 on a Google AI Pro subscription from November 20, 2026, 13:50 UTC, to November 21, 09:58 UTC, on the owner’s Mac, one task at a time. About nine of those hours were waits on the plan’s usage quota. 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. No run reached the flat 3-hour task bound; the longest, Medium granarycore, took 19.0 minutes.
Combined score
84.32 at Low to 87.87 at High
Low is the outlier: 84.32, then 87.48 at Medium, 87.87 at High and 87.70 at Extra-high. Above Low the three levels sit within 0.4 points of each other, less than one standard error.
Tasks passed
17 of 23 at Low, 23 of 23 above
At Low, six tasks pass only part of their hidden tests (220 of the 231 hidden behaviours fixed). From Medium up Gemini 4 Neon fully solves every task and fixes all 231, so the differences between those levels come from Code quality, lint and security.
Code quality
66.15 to 69.07
The judges rate the code 66.15 at Low, 67.87 at Medium, 69.07 at High and 68.69 at Extra-high, with standard errors of 1.21 to 1.45: a slow rise of about three points, flat from High.
Runtime and cost
5.1 to 10.1 min · $0.73 to $1.80 per task
Extra-high takes twice as long as Low and costs two and a half times as much, for no score over High. The whole sweep took 10.6 hours of solver time and prices at $106.84 for 92 runs, $1.16 per task, at Gemini 4 Neon’s list rates.
| Metric | Low | Medium | High | Extra-high |
|---|---|---|---|---|
| Combined score | 84.32 | 87.48 | 87.87 | 87.70 |
| Standard error | 1.09 | 0.49 | 0.46 | 0.51 |
| Judged runs | 22 | 23 | 23 | 22 |
| Tasks passed | 17/23 | 23/23 | 23/23 | 23/23 |
| Hidden behaviours fixed | 220/231 | 231/231 | 231/231 | 231/231 |
| Code quality | 66.15 | 67.87 | 69.07 | 68.69 |
| Human readability | 55.8 | 57.6 | 59.1 | 60.0 |
| Minutes per task | 5.1 | 5.9 | 6.4 | 10.1 |
| API-equivalent $ per task | $0.73 | $0.92 | $1.19 | $1.80 |
Under the prior 50/15/15/20 profile applied to the same Code quality scores the ladder has the same shape, 87.27 at Low and 90.20 to 90.42 above. The card and the full per-effort table follow.
Gemini 4 Neon is a model to run at Medium. Low misses six tasks; Medium solves all 23 and scores 87.48, within 0.4 points of the best (87.87 at High) for $0.92 a task and 5.9 minutes, against $1.19 and 6.4 minutes at High. Extra-high adds time and cost and no score. From Medium up it sits 1.0 to 1.5 points behind GPT-6.2 Sol and about 3 points behind Claude Opus 5.5, and it costs three to four times as much per task as GPT-6.2 Sol. These runs compare a model-and-harness combination, not an isolated base model; the Frontier v4 leaderboard places every Gemini 4 Neon level beside the other models.
Combined score and Code quality by effort
n=23 runs at every level; Low and Extra-high are judged on 22. Combined (33%) is the published score. Combined (20% profile) applies the prior 50/15/15/20 weights to the same Code quality scores for comparison. Code quality, human readability, maintainability and intent recovery are out of 100 and equal means of the two judges over the judged runs. Passed counts all 23 runs. Runtime is solver wall-clock per task over every run in the cell.
| Model / harness | Effort | Combined (33%) | SE | Combined (20% profile) | Code quality | Human readability | Maintainability | Intent recovery | Judged | Passed | Min/task |
|---|---|---|---|---|---|---|---|---|---|---|---|
| Gemini 4 Neon / Antigravity | Low | 84.32 | 1.09 | 87.27 | 66.15 | 55.8 | 66.2 | 79.9 | 22/23 | 17/23 | 5.1 |
| Gemini 4 Neon / Antigravity | Medium | 87.48 | 0.49 | 90.20 | 67.87 | 57.6 | 68.6 | 80.6 | 23/23 | 23/23 | 5.9 |
| Gemini 4 Neon / Antigravity | High | 87.87 | 0.46 | 90.42 | 69.07 | 59.1 | 71.3 | 79.3 | 23/23 | 23/23 | 6.4 |
| Gemini 4 Neon / Antigravity | Extra-high | 87.70 | 0.51 | 90.27 | 68.69 | 60.0 | 70.2 | 78.2 | 22/23 | 23/23 | 10.1 |
Low and Extra-high codeccore have no Code quality score. Grok 4.6’s intent probe of codeccore returned replies that were not valid JSON on both of its two attempts, at Low and again at Extra-high: it quoted the codeccore memo line with its double quotes unescaped, the same line it broke on when judging GPT-5.6 Sol (v3.7) and GPT-6 Sol (v3.17). The operator rule invalidate_unrecoverable_probe marks such a probe invalid, and the frozen summary then publishes no Code quality score for that submission, as it did in those two rounds; the owner chose to keep that rule rather than score the runs from Muse alone. Both runs passed every hidden test, are timed and priced, and count in Tasks passed. Judging stopped at the first of the two, and the rule was extended to cover two malformed replies (decision record) before the remaining probes resumed.
Four factors by effort. Over every run, functional correctness is 95.01 at Low and 100.00 above; lint and complexity average 77.99, 77.70, 77.37 and 77.47 from Low to Extra-high; security 99.78, 99.78, 100.00 and 99.57.
Intent recovery is scored over the specification departures a submission actually passed tests for. Every judged run passed at least one quirk family, so no run needed its intent points moved to the reviewed score. SE is one sample standard error of the combined score across the cell’s judged tasks. It describes task sampling, not judge uncertainty, repeated runs or a significance test. No solver fallback occurred, and neither judge produced a reviewer fallback on any of the 92 submissions.
Beside Claude Opus 5.5 and GPT-6.2 Sol
Claude Opus 5.5 is ahead from Medium up, 90.68 to 91.11 against Gemini 4 Neon’s 87.48 to 87.87, a gap of 3.0 to 3.4 points; at Low both models pass 17 tasks and Opus 5.5 leads by 2.0. GPT-6.2 Sol is ahead at every level, by 1.0 to 1.5 points from Medium up and by 4.1 at Low, where it passes all 23 tasks. Gemini 4 Neon’s Code quality, 66.15 to 69.07, is the lowest of the three: GPT-6.2 Sol’s is 70.31 to 71.91 and Opus 5.5’s 72.53 to 79.98.
On cost Gemini 4 Neon sits between them: $0.73 to $1.80 a task, against $0.23 to $0.46 for GPT-6.2 Sol and $1.70 to $4.11 for Opus 5.5 over the same four levels. It is quicker than Opus 5.5 at every level (5.1 to 10.1 minutes against 13.7 to 21.4) and slower than GPT-6.2 Sol at every level (2.8 to 8.2 minutes over the same four).
| Model / harness | Effort | Combined | SE | Judged | Passed | Min/task | Tokens/task | $/task | Code quality |
|---|---|---|---|---|---|---|---|---|---|
| Gemini 4 Neon / Antigravity | Low | 84.32 | 1.09 | 22 | 17/23 | 5.1 | 0.91M | $0.73 | 66.15 |
| Claude Opus 5.5 / Claude Code | Low | 86.36 | 1.30 | 23 | 17/23 | 13.7 | 2.77M | $1.70 | 72.53 |
| GPT-6.2 Sol / Codex | Low | 88.44 | 0.35 | 23 | 23/23 | 2.8 | 0.77M | $0.23 | 70.31 |
| Gemini 4 Neon / Antigravity | Medium | 87.48 | 0.49 | 23 | 23/23 | 5.9 | 1.10M | $0.92 | 67.87 |
| Claude Opus 5.5 / Claude Code | Medium | 90.86 | 0.64 | 23 | 23/23 | 18.6 | 5.01M | $2.84 | 77.32 |
| GPT-6.2 Sol / Codex | Medium | 88.94 | 0.47 | 23 | 23/23 | 4.4 | 1.05M | $0.33 | 71.78 |
| Gemini 4 Neon / Antigravity | High | 87.87 | 0.46 | 23 | 23/23 | 6.4 | 1.44M | $1.19 | 69.07 |
| Claude Opus 5.5 / Claude Code | High | 91.11 | 0.57 | 22* | 22/23 | 21.4 | 4.11M | $3.27 | 77.99 |
| GPT-6.2 Sol / Codex | High | 88.86 | 0.33 | 23 | 23/23 | 5.1 | 1.30M | $0.41 | 71.43 |
| Gemini 4 Neon / Antigravity | Extra-high | 87.70 | 0.51 | 22 | 23/23 | 10.1 | 2.45M | $1.80 | 68.69 |
| Claude Opus 5.5 / Claude Code | Extra-high | 90.68 | 1.10 | 23 | 22/23 | 20.7 | 3.90M | $4.11 | 79.98 |
| GPT-6.2 Sol / Codex | Extra-high | 89.01 | 0.43 | 23 | 23/23 | 8.2 | 1.31M | $0.46 | 71.91 |
| Claude Opus 5.5 / Claude Code | Max | 90.22 | 1.02 | 23 | 21/23 | 37.5 | 8.72M | $8.75 | 79.77 |
| GPT-6.2 Sol / Codex | Max | 88.74 | 0.40 | 23 | 23/23 | 11.3 | 1.31M | $0.55 | 71.06 |
Read the comparison with its limits. All three models are judged by Muse Spark 1.3 and Grok 4.6 under the same rubric, each in its own protocol run (v3.32, v3.15 and v3.31). Gemini 4 Neon has no Max level. * Opus 5.5 at High is judged on 22 runs, where a safeguard stop left one run with no code to review; that run scored 0 and is priced. Harnesses differ: Antigravity for Gemini 4 Neon, Claude Code for Opus 5.5, Codex for GPT-6.2 Sol. $/task is API-equivalent at list price from each run’s receipts; for Opus 5.5 it is Claude Code’s own list-price total.
Where Low falls short
Six of the 23 tasks pass only part of their hidden tests at Low: cellarcore (12 of 14 hidden behaviours), hedgecore (6 of 8), lodgecore (11 of 12), matchcore (7 of 9), quotacore (8 of 10) and tallycore (6 of 8). Each misses one to three of the documented departures from the specification, and each passes in full at Medium. Those six runs score 73.62 to 80.75 combined, which is what pulls Low down to 84.32 and widens its standard error to 1.09, against about 0.5 at the other levels.
| Task | Hidden behaviours fixed | Functional | Combined |
|---|---|---|---|
| cellarcore | 12/14 | 85.7 | 77.45 |
| hedgecore | 6/8 | 75.0 | 74.99 |
| lodgecore | 11/12 | 91.7 | 80.75 |
| matchcore | 7/9 | 77.8 | 78.84 |
| quotacore | 8/10 | 80.0 | 78.25 |
| tallycore | 6/8 | 75.0 | 73.62 |
Cost and tokens across effort levels
All 92 runs priced from their Antigravity receipts at list API rates, cache-aware, with judging excluded. These are API-equivalent estimates, not subscription charges: Gemini 4 Neon ran on a Google AI Pro subscription, and what the plan bills is not observable from the receipts. Cost per task is $0.73 at Low, $0.92 at Medium, $1.19 at High and $1.80 at Extra-high; the whole sweep comes to $106.84. Effort shows up in thinking: the median run spends 7.2K output tokens thinking at Low and 40.8K at Extra-high, and mean output rises from 20.1K to 56.9K tokens a task. Total tokens nearly triple, from 0.91M to 2.45M a task, as longer runs re-read more context.
| Effort | Runs | $/task | Level total | Tokens/task | Output/task | Median thinking | Cached share of input | Min/task | Median min |
|---|---|---|---|---|---|---|---|---|---|
| Low | 23 | $0.73 | $16.84 | 0.91M | 20.1K | 7.2K | 83.7% | 5.1 | 3.8 |
| Medium | 23 | $0.92 | $21.12 | 1.10M | 28.4K | 14.6K | 84.1% | 5.9 | 4.9 |
| High | 23 | $1.19 | $27.40 | 1.44M | 38.2K | 24.3K | 88.3% | 6.4 | 6.1 |
| Extra-high | 23 | $1.80 | $41.48 | 2.45M | 56.9K | 40.8K | 91.3% | 10.1 | 10.1 |
| Full sweep | 92 | $1.16 | $106.84 | 136M | 10.6 h |
Pricing. Rates checked 2026-11-19 from Google: Gemini 4 Neon at $3.00 input, $0.15 cached input and $15.00 output per million tokens. Antigravity receipts report input, cached input, output and thinking tokens per run, so cached input is billed at the cache-read rate and the rest at the standard rate; thinking tokens are part of output and are not billed twice. The sweep stamped each run at these rates at run time; the export recomputed every run from its receipt and matched every stamp. The 40 attempts the plan’s quota refused are not priced: none is a population row.
Tokens are Antigravity’s raw totals, input (cached included) plus output; the full sweep row sums them over all 92 runs (Tokens/task in that row is the sweep total). Tool calls average 27.5, 23.8, 24.5 and 31.0 a task from Low to Extra-high, 2,455 in all: 1,497 shell commands, 776 file reads, 171 edits and 11 file writes. Per-run estimates, token usage breakdowns, tool-call counts and the rate table are in economics.json and runs.csv.
On the Frontier v4 board
Gemini 4 Neon’s best level, High at 87.87 ± 0.46 (n=23), ranks 43rd of the board’s 95 model and effort columns, just below Claude Haiku 5.5 at High (88.02) and just above GPT-6 Astra at Medium (87.73). By level it ranks Low 60th, Medium 46th, High 43rd and Extra-high 45th: the three upper levels sit within 0.4 points of each other. High carries the best tag; the board’s critical and routine effort suggestions pick Medium, within 0.4 points of the best for about three quarters of the cost, and the rough suggestion picks Low. The leaderboard carries every column; Gemini 4 Neon’s cells carry the ††† footnote with the disclosures on this page.
Read these placements with the panel in mind. Gemini 4 Neon, Claude Opus 5.5, GPT-6.2 Sol and most other columns are judged by Muse Spark 1.3 and Grok 4.6; Claude Fable 5.2’s, Grok 4.7’s, DeepSeek V4.1 Flash’s and Reflection Beam’s by Muse Spark 1.3 and GPT-6.1 Sol; Muse Wonder Full’s by Claude Opus 5.5 and GPT-6.1 Sol. Scores from different panels are not calibrated against each other, so gaps of a point or two between columns judged by different panels are not a reliable order.
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. Frontier Code quality is therefore the reviewed layer plus intent recovery, and it is never compared with Routine v1 Code quality, which is scored on a different suite and population.
| Component | Low | Medium | High | Extra-high |
|---|---|---|---|---|
| Code quality | 66.15 | 67.87 | 69.07 | 68.69 |
| Human readability | 55.8 | 57.6 | 59.1 | 60.0 |
| Maintainability | 66.2 | 68.6 | 71.3 | 70.2 |
| Intent recovery | 79.9 | 80.6 | 79.3 | 78.2 |
| Runs with no intent denominator | 0 | 0 | 0 | 0 |
| Rated by Muse Spark 1.3 | 57.6 | 60.8 | 63.7 | 63.1 |
| Rated by Grok 4.6 | 64.4 | 65.4 | 66.8 | 67.1 |
| Standard error of Code quality | 1.45 | 1.26 | 1.21 | 1.36 |
Code quality rises about three points from Low to High and then holds. Human readability is the weaker sub-score at every level, 55.8 to 60.0 against 66.2 to 71.3 for maintainability. Grok 4.6 is the higher rater at every level, by 3.1 to 6.8 points on the reviewed score. 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 settings and pinned Muse binary as under v3.24. Grok 4.6 ran through the Cursor CLI pinned to version 2026.10.01-e373342, the build v3.23 to v3.31 used, with a digest of its version directory checked before every stage. Neither lab is Google. 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.32 changes nothing in the rubric, controls, quirk keys, gates, repeats, seed, weights or judges from v3.24; it applies the protocol to this population. The owner chose this panel on November 21.
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 retook the exam under v3.32 before any counted call.
| Judge | Protocol | Calls | Result | Allowance used | Failing gates |
|---|---|---|---|---|---|
| Muse Spark 1.3 | code-quality-maintenance-v3.32 | 80 | passed | yes | g11 repeatability |
| Grok 4.6 | code-quality-maintenance-v3.32 | 80 | passed | no | none |
Muse Spark 1.3 passed with the one-gate allowance: its repeatability gate (g11) fell 0.02 short, within the half point the protocol allows for one gate, as under v3.23, v3.29 and v3.31. Grok 4.6 passed every gate. Every gate value and control mean is in calibration.json.
The judges agree on the shape. Scored by one judge alone, the combined score would be (Muse or Grok) 83.44 or 85.20 at Low; 86.88 or 88.08 at Medium; 87.43 or 88.31 at High; 87.13 or 88.28 at Extra-high. Either way Low is the outlier and the upper three levels are level. Each run’s single-judge figures are in runs.csv.
Under v3.32 each judge was planned for 368 counted calls: 80 in calibration, 92 primary reviews, 4 repeats, 8 pairwise checks, 92 intent probes and 92 answer-key matches. Grok’s two invalid probes have no answer-key match, so it made 366 counted calls and has 364 selected. Muse needed a second attempt on 2 calls (both unsupported excerpts) and Grok on 7 (four unsupported excerpts and three JSON syntax errors, two of them the codeccore probes, which failed again), under the protocol’s single-retry rule. Every Grok call reported the display label “Grok 4.6 Medium” for the pinned model id, where the frozen settings say “Cursor Grok 4.6 Medium”; the operator wrapper accepts the rename and records it on all 364 selected Grok calls. Neither judge produced a reviewer fallback, and no call waited on a usage limit. Judging ran on November 21, 2026, from 14:58 to 21:19 UTC, when it stopped at the Low codeccore probe, and resumed from November 22, 02:19 UTC, to 03:31 UTC with the extended rule; no benchmark run overlapped either window. Every operator record is in judge-protocols.json.
How it was run
- The model. Gemini 4 Neon through the Antigravity CLI, which takes the effort level as part of the model name (
gemini-4-neon-lowtogemini-4-neon-xhigh). Antigravity reports the model it served,gemini-4-neon, on every run. - Antigravity CLI 1.5.12. Pinned by file hash, signed in with the owner’s Google AI Pro subscription, in headless mode with a private home folder per run inside the harness’s macOS sandbox. Antigravity offers no Max level for Neon, so the sweep has four levels.
- A custom agent with no web tools. Antigravity’s default agent carries a web search tool that its permission settings cannot switch off. Every run instead used a custom main agent limited to the default file and shell tools (read file, write file, edit file and run command), whose prompt body is Antigravity’s own identity text, verbatim; URL, browser and MCP tools were also denied. Every archived tool call is one of those four tools, and every integrity audit is clean: no web search or fetch, and no benchmark data or answer-key paths.
- The plan’s usage quota. The AI Pro plan refused 40 attempts on its usage quota (10 at Medium, 8 at High, 22 at Extra-high), four of them at Extra-high cut off mid-task. Each was classified as infrastructure and rerun from scratch after the quota reset, so the sweep waited about nine hours in all; no refused attempt is in the population or the cost.
- From a tagged run worktree. Every run ran from
bench/2026-11-20-gemini4-neon-frontier-v4, so every run summary carries a clean source block and records the frozen suite lock’s task hash. A first launch the evening before was stopped after one Low run: shell heredocs failed inside the sandbox, a fault no earlier harness had met. The fix went in through its own pull request, the voided run was set aside, and the sweep restarted from Low on the new tag. - The pinned binary. During setup, before any run, Antigravity updated itself to 1.6.1 in place; the pinned 1.5.12 binary was restored by hash and its folder made read-only, which the updater skips, and the launcher checks the hash before every run. The run receipts written from the sweep tag still describe the update control as an environment variable, which turned out not to stop the updater.
- No timeouts. Every run finished inside the flat 3-hour bound; the longest, Medium granarycore, took 19.0 minutes.
- Where and how. The owner’s Mac, one task at a time, from November 20, 2026, 13:50 UTC, to November 21, 09:58 UTC.
- One attempt per task and level. Runs were not repeated, and effort labels are Antigravity’s own.
Evidence and reproduction
Public files contain all 92 run measurements, both judges’ six-dimension sub-scores and intent-recovery scores for the 90 published runs, the combined score from each judge alone, hidden behaviours fixed, integrity-audit verdicts, tool-call counts, each run’s task hash, raw tokens and API-equivalent cost estimates per run, four aggregates, every calibration gate value, the exact judge protocol text, the operator records for the two unpublished rows, 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. 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 document, the operations log, the decision record, the Antigravity adapter and the code in the harness repository.
No human rated anything; the scores are model judgment for a human reader, not human validation. Hash checks bind the export to frozen files, including the operator’s two invalidation markers; they do not prove that judges were unbiased or that no training overlap exists.
Withheld: raw prompts and responses, the model’s thinking text, submitted patches and reconstructed sources, the quirk answer keys (they describe hidden-test behaviour), reviewer session identifiers and usage receipts, solver event streams and tool-call inputs, and host binary paths. Summed solver time is 10.56 hours; judging is excluded.