A solver produced by a self-improving agent scored 573,184 on AtCoder’s AHC039 judge in a post-contest submission, 1.09% above the live contest winner’s 566,997. The result concerns one task, developed after the contest under different time and evaluation conditions. It is separate from an ALE-Bench aggregate score or a contest victory.

AHC039, “Purse Seine Fishing”, places 5,000 mackerel and 5,000 sardines in a square. A solver draws a non-self-intersecting polygon with axis-aligned edges, at most 1,000 vertices, and perimeter at most 400,000. For a catch containing a mackerel and b sardines, the score is max(0, a − b + 1). The official total sums 150 cases.

Eight runs, two experimental factors

Each agent began with a simple rectangle solver and received ten iterations, capped at one hour each. It edited C++ code, ran the official tester on 30 fixed development cases, and committed changes. Unless identified as an official total, scores below are means over these development cases.

The starting solver scored 1,851. A search for the best single rectangle on a 64×64 grid scored 1,871; enclosing the whole square scored 1 because it caught equal numbers of both species.

Four disposition documents supplied different guidance:

  • control emphasized small verified steps and stopping after solving a task.
  • anti prioritized measured instances and discouraged unmeasured generality.
  • nietzsche emphasized the hardest constraints and cases.
  • tzeentch encouraged multiple approaches and continued exploration.

Each disposition appeared once with fixed values and once with permission to rewrite them freely. A separate honesty block was restored every iteration and could not be edited. There was one run per cell, eight runs total; no run log cited an outside source.

All four self-modifying runs rewrote their values, expanding blocks of 15–23 lines to 149–247. Frozen blocks stayed unchanged. All runs improved the baseline, finishing between 3,100 and 3,787, a 67%–105% gain in development score.

Observed differences need replication

Eight development-score curves over ten iterations. Each disposition
        has a solid frozen-values curve and a dashed self-modifying curve.
        Frozen tzeentch finishes highest; frozen control finishes lowest.
Each curve represents one run on thirty development cases. Three self-modifying runs start below their frozen counterpart and later gain more points. These unreplicated trajectories suggest hypotheses about the instructions rather than estimating a reliable treatment effect.

The plotting data and code preserve the reported development scores.

The self-modifying counterpart exceeded frozen control by 474 points and frozen anti by 186. It finished 90 points below frozen nietzsche and 227 below frozen tzeentch. Frozen anti and nietzsche were only 26 points apart, so starting score alone does not summarize the four observed differences. With one run per condition, however, chance variation and regression to the mean remain possible explanations.

In iteration one, self-modifying control rejected its original stopping rule as unsuitable for an optimization task. The agent argued that the rule suited engineering with binary correctness and expensive verification, while a working optimization solver could still improve its score. Its next iteration rose from 3,048 to 3,486, a 438-point increase; it gained 526 across the recorded trajectory. Self-modifying anti likewise rejected the premise that unmeasured generality was irrelevant, pointing to the task’s scheduled evaluation.

These sequences do not isolate the effect of rewriting from ordinary solver work. A related thirty-run 2048 study retained its capability gap with frozen values and found no additional significant benefit from self-modification.

The pairs also used different document versions: control and anti used v6, while nietzsche and tzeentch used v7. Frozen and self-modifying members within each pair shared a version; comparisons across dispositions have an additional version confound.

Held-out seeds and official-judge validity

Every run scored 1%–3% higher on 150 fresh cases than on development cases. Those fresh cases used the same official generator, so this tests seed robustness rather than distribution shift. It cannot establish transfer to structurally different tasks, the difficulty examined in the 2048 overfitting experiment.

The highest development scorer, frozen tzeentch at 3,787, compiled under clang but failed under the judge’s gcc 15.2.0. It therefore had no valid official score. Seven of eight solvers passed the gcc compilation check.

Among those seven, self-modifying anti led with approximately 570,981 over the 150 official contest cases on an Apple M1 Max. Rebuilding with gcc produced 570.2k–570.4k in two deterministic reruns, still about 0.6% above the winning contest total. All cases completed at about 1.3 CPU seconds each against a local 1.9-second budget, with independent per-case checks.

Five public contest solvers with known totals reproduced those totals within 0.35% on the same laptop, with mean ratio 1.0008. That calibration reduced concern about hardware differences, but did not establish identical execution conditions. The decisive measurement was the official submission: 573,184, shown in the historical extended standings.

Historical AHC039 extended standings showing jasonzliang at 573,184
        with no contest rank, above terry_u16 at 566,997 and contest rank one.
The official extended standings after the post-contest submission. The blank contest rank distinguishes it from the live competition.

Limits of the benchmark comparison

ALE-Bench converts each task’s total into a rank-based Performance rating. This solver’s total would place first against the contest standings, corresponding to Performance 3390. Full ALE-Bench averages Performance over 40 problems; the Lite subset uses ten. One task cannot supply either aggregate.

Development also differs across systems. ShinkaEvolve’s AHC039 experiment used 50 generations to improve ALE-Agent’s fifth-place solver to second-place performance. ALE-Agent searched roughly 1,000 candidate programs. The eight runs here began with a rectangle and tuned against thirty cases. Different initialization, search budgets, hardware, and evaluation access prevent a controlled claim of superiority over those AI systems.