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

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.

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.