Persistent Recursive Worlds Enable Autonomous Software Evolution

Software Projects That Outlive Their AI Builders

Building complex software takes longer than any single AI agent can meaningfully operate. Rather than trying to keep one agent alive indefinitely through memory tricks, the authors propose flipping the problem: make the software project itself persistent while letting individual agents stay simple and short-lived.

The core insight is that continuity doesn't need to live in the agent—it lives in the code repository and the version history. This lets the system swap out agents as needed (due to token limits, model updates, or just restarts) without losing progress or requiring elaborate memory management.

How the System Works

Genesis organizes work as a "persistent recursive world." Think of it as a hierarchy of nested coding tasks. At each level, an agent sits in front of a partial code repository at a specific commit. The agent proposes local changes—edits, new files, test runs. If those changes work (tests pass, the code compiles), they get committed and accepted into the persistent version history. If not, they're discarded and the next agent starts fresh from the last known good state.

When work spans multiple paths or submodules, Genesis uses "recursive delegation"—an agent can break a large task into smaller subtasks, each handled by fresh agents operating on their own local directories. Results bubble back up and get integrated. This keeps individual agent sessions manageable in scope and length, even though the overall project grows huge.

The key is that only accepted consequences—code that passed validation—advance the official project history. Rejected work doesn't clutter the repository; it just disappears.

Concrete Results

The authors tested this on three substantial real-world problems:

C Compiler (Rust). Starting from scratch, Genesis used DeepSeek-V4 Flash to write a Rust-based C compiler with approximately 250,000 tracked lines of code. The effort took over 120 hours, involved more than 1,000 agent episodes, and cost only $44 in model tokens. The resulting compiler passed the full c-testsuite and most LLVM and Csmith validation tests (industry-standard compiler test suites).

Long-Horizon Continuation. In a parallel compiler world built with GLM-5.2, the system swapped out the agent multiple times as it continued development. Despite agent replacement, the compiler retained full test performance—proof that progress persists independent of any single agent's lifespan.

Legacy Porting (Fortran to Rust). Genesis reimplemented 13 MESA modules totaling over 100,000 Fortran lines as a Rust workspace (nearly 90,000 Rust lines). Across six numerical workloads, the Rust version achieved median speedups of 1.55× to 6.87×—not just a faithful port, but a faster one.

Why It Matters

This work reframes a fundamental challenge in agentic software development. Instead of fighting to keep one agent coherent across a multi-day project, Genesis treats agents as stateless workers that clock in, do their part, and clock out. The repository becomes the memory. This is simpler, more scalable, and—as the compiler result shows—powerful enough to tackle problems that traditionally required human engineering effort over weeks.