Give an AI the rules of a game and ask it to build a smaller AI to play. In a preprint submitted on November 12, 2026, Jens Lehmann reports that language models did just that—but ordinary Python players written by the same models played better. For game developers, it is a concrete reason to compare what the AI builds, not just admire that it works.
The writer models were already trained and received the game’s source code. The experiment concerns constructing a new neural player without training that player, not creating intelligence without prior learning.
In the reported comparison, the best fixed-network result was 56% success on withheld levels, while Python players from the four main writer models reached 97–100%. But allowing those writers to design their own networks raised neural-player results to 68–90%. That improvement is central to the story: the network’s design matters, not merely whether it is neural.
What did the AI actually build?
Lehmann used 20 privately authored game families. The writers could read code describing the mechanics, but the evaluation levels and ready-made solvers were removed. They had to produce a player that could handle new levels, appearances and starting positions within those known rules. These were controlled puzzle-game experiments, not arbitrary commercial games.
This approach is called weight-space programming. A network’s weights are its numerical settings; its architecture is how its parts connect. In the fixed-design condition, the writer supplied a program that filled in all the settings of a 57,289-parameter network. It did not simply type out a long list of numbers. The construction rules prohibited training, searching for weights and simulating the game inside that program.
There could still be feedback. Writers were allowed up to three revisions after receiving outcomes and limited failure reports from example levels. The withheld evaluation levels did not supply that feedback. Once built, the resulting player read the game screen and selected actions without consulting its large writer again.
This is different from SeeEEG’s reuse of an existing image model, which adapts brainwave data into pictures for a frozen model. Here, the output is a newly constructed player. The learning already invested in the writer remains part of the explanation.
Was ordinary code given an easier job?
In important ways, yes. The strongest Python players could simulate future states and search for actions, while the fixed networks had a prescribed structure. The headline percentages are success rates on withheld levels, averaged equally across game families—not the percentage of whole games solved. They are not an equal-resource contest.
The custom-network experiment relaxes one constraint: writers can choose how the network is connected. It also allows a larger parameter ceiling, though the paper’s additional comparisons suggest that changing the connections explains most of the improvement. This condition was developed after the fixed-network results, so it is exploratory evidence, not a preplanned confirmation.
Lehmann then tried a closer comparison using programs built with NumPy, a numerical Python library. With comparable computation caps and the same rules for fixed-count loops, these programs scored 91%, against 79% for custom networks, pooled across the four main writers. Programs still had extra operations, some different structural limits and different prompts. The comparison narrows the question without isolating output format perfectly.
Another restriction changes the picture again. A one-attempt Python condition barred simulation and search and imposed a short per-move time limit; it scored 40%, close to the fixed networks’ pooled 42% with feedback. Those conditions also differed in computation and revision opportunities. The useful reading is not that code always wins, but that the freedom to express a solution strongly affects the result.
The neural players looked surprisingly like programs
The structure of the generated networks helps explain why this is more than a contest between file formats. Across 451 delivered custom networks from the main writers, Lehmann reports that 93% of parameters were zero. Of the remainder, 90% were small integers or powers of two. The networks implemented logic-like operations and fixed loops.
That supports a program-like interpretation: the writer can express a rule-based solution through neural machinery. It does not reveal every step of the writer’s hidden reasoning, or establish how all AI-generated networks work.
For deployment, one apparent advantage belongs to both sides. A neural network or an ordinary program can keep playing without calling the large writer model. Avoiding those repeated calls therefore does not, by itself, justify choosing the neural version.
Nor did later training supply the hoped-for advantage here. In a small follow-up across six game families, a standard reinforcement-learning method called PPO reduced the fixed written networks’ pooled success from about 50% to about 1%. Much of their initial success came from only three or four families. This shows brittleness under the tested training procedure, not that every way of training such networks must fail.
What can other researchers check?
This is a single-author preprint; independent replication of the central experiment remains unestablished. The paper discloses that language models helped create the private games and that prompts were piloted with models later evaluated. Its findings concern new instances of known mechanics, not discovering unfamiliar game rules.
The companion repository releases code, compact result summaries and player artifacts for a separate public-game experiment. It withholds the 20 private game families and most raw run outputs to help keep those games unseen by future models. Recalculating the released summaries is therefore not the same as independently rerunning the main experiment.
Readers assessing research software can make the same distinction illustrated by BootLoops’ numerical checks and verification limits: checking that reported numbers match supplied records answers a narrower question than independently validating the experiment behind them.
When is a neural player worth choosing?
For a rule-based prototype, the practical implication is to ask for both outputs: a neural network and an ordinary program. Compare them on levels withheld from construction, with explicit rules about source access, revisions, computation and scoring. If a fixed network performs poorly, test whether its architecture is the restriction before dismissing the approach.
Then identify the benefit that would justify the neural format—perhaps a measured deployment advantage or successful later training—and test that benefit separately. Neither follows from producing valid weights. The study shows something genuinely intriguing: AI can turn known game rules into a working neural player. It also gives that achievement a useful rival: the program the same AI could have written instead.
