Last week I sat in the LLM Paper Club (hosted by the latent.space podcast). We shared a paper from DeepMind on "Discovering Multiagent Learning Algorithms with Large Language Models". Linked in the github repo.

This was my first time sitting in one of these and reading an LLM paper. I thought it was interesting that the AlphaEvolve agent in the paper essentially writes code, runs it, scores the output, and then writes better code, over and over. It's not discovering strategies through play. It's discovering algorithms through code mutation. The LLM proposes changes to how regret is accumulated or how policies are derived, a fitness function scores the result, and the best variants survive to the next generation.

The two algorithms it found (VAD-CFR and SHOR-PSRO) use mechanisms the authors describe as "non-intuitive," things like volatility-sensitive discounting and hard warm-start schedules that a human designer probably wouldn't have tried. That's the interesting part: the LLM isn't constrained by the same design intuitions we are.

To make it concrete for myself, I built a small version of this loop for a Pokemon game agent. The setup is simple: define a fitness function (turns survived, maps visited, stuck events), parameterize the strategy space (door cooldown, stuck threshold, skip distance), and let an LLM propose variants that get evaluated in parallel. Ten agents race through the game, the best parameters survive. I used tapes.dev to collect session telemetry and feed observational memory back into the fitness scoring.

The first run already surfaced something useful: shorter door cooldowns (4 vs 8) reduce stuck events from 16 to 9. Not a breakthrough, but the point is the system found it without me guessing. That's the same dynamic as the paper, just at toy scale.

What I took away from the paper club: the bottleneck in algorithm design isn't computation, it's the search process itself. If you can express your problem as "parameterized code + fitness function," an LLM evolution loop can explore the space faster than manual iteration. The paper proves it works for game theory. The link is in my startup's repo, I want to explore applying this technique for improving future general purpose and coding agent sessions.

Just pointing out Pokemon aren't the only thing evolving in that repo.