Persistent Recursive Worlds Enable Autonomous Software Evolution
Proposes EvoX Genesis, a persistent recursive world model enabling autonomous software evolution, successfully building a Rust C compiler and migrating MESA modules.
Key Findings
Methodology
This paper introduces a persistent recursive world architecture where the software project’s state and history are treated as durable objects, while local agents are finite-lived. The system defines a local software world as a pair (𝑣, 𝑝), where 𝑣 is an accepted version and 𝑝 is a repository-relative path. Agents operate within this scope, proposing changes (Δ𝑖) during episodes, which are validated and only accepted if they pass tests and constraints. Recursive delegation allows work to be transferred across paths without immediately changing the accepted version, maintaining a clear version history. The system leverages DeepSeek V4 Flash for large-scale automated construction, integrating Git for version control and validation mechanisms for change acceptance. Experiments demonstrate the system’s ability to build a complete Rust-based C compiler from scratch in 120 hours, archiving over 1000 agent episodes at a cost of only $44, passing all tests including c-testsuite, LLVM, and Csmith. Further, the system supports continued development after foundation model replacement (GLM 5.2), maintaining full test coverage and performance. It also successfully migrates 13 MESA modules (over 100k Fortran lines) to Rust, completing in 33 hours and achieving median speedups of 1.55–6.87× across six numerical workloads. These results establish the feasibility of long-horizon software development organized around persistent projects rather than persistent agents.
Key Results
- Successfully built a comprehensive Rust C compiler with Clang compatibility, LLVM IR export, C11 support, and x86/x86-64 backends, in 120 hours, with over 1000 agent episodes, costing only $44, passing all tests including c-testsuite, LLVM, and Csmith.
- Demonstrated that the same project can be continuously developed across foundation model replacements (GLM 5.2 and DeepSeek V4 Flash), with both branches passing their respective retained test sets and reaching comparable depths of development.
- Migrated 13 MESA modules (over 100k Fortran lines) to Rust in 33 hours, producing nearly 90k Rust lines, and achieving median speedups of 1.55–6.87× across six numerical workloads, validating the migration’s correctness and efficiency.
Significance
This work fundamentally redefines software development organization by shifting focus from persistent agents to persistent projects. It demonstrates that long-term software evolution can be achieved through a structured, versioned, recursive framework that supports automated construction, migration, and continuous development. This approach addresses longstanding challenges in software continuity, reproducibility, and scalability, especially in scientific computing and large-scale systems. It paves the way for AI-driven autonomous software engineering, reducing manual effort, improving reliability, and enabling rapid adaptation across diverse domains.
Technical Contribution
The core technical innovation lies in the formulation of a persistent recursive world model that couples version history with path-specific agent instantiation. This model uses a minimal version-path pair to localize work, recursive delegation for multi-layer task decomposition, and validation gates to ensure correctness. Integration with DeepSeek V4 Flash enables large-scale, automated, recursive system construction. The use of Git for version management ensures traceability and continuity. The architecture allows for seamless replacement of foundation models without disrupting ongoing development, demonstrating robustness and scalability. These contributions significantly advance the state-of-the-art in autonomous software engineering and long-term system management.
Novelty
This work is the first to conceptualize software as a persistent recursive world, decoupling project persistence from agent persistence. Unlike prior approaches that rely on continuous agents, this architecture employs a version-path framework with recursive delegation and validation, enabling long-term, autonomous evolution. The integration of deep learning-based construction tools (DeepSeek V4 Flash) with version control and validation mechanisms offers a novel, scalable paradigm for long-horizon software development and migration, filling a critical gap in existing research.
Limitations
- The validation process primarily depends on test suites, which may not cover all edge cases, especially in safety-critical or highly complex systems. Formal verification remains an open challenge.
- The current implementation relies heavily on deep learning models, which incur significant computational costs and model token expenses, limiting scalability in resource-constrained environments.
- Handling multi-language, multi-platform environments and managing complex dependency graphs require further development to ensure robustness and broad applicability.
Future Work
Future research will focus on integrating formal verification and static analysis to strengthen correctness guarantees. Enhancing multi-language support and improving dependency management will increase system robustness. Additionally, exploring more intelligent agent orchestration strategies, including adaptive delegation and resource allocation, could further improve efficiency. Extending validation mechanisms beyond test suites, such as symbolic reasoning or proof-based verification, will be crucial for industrial adoption. Ultimately, the goal is to develop a fully autonomous, scalable, and secure software engineering ecosystem capable of long-term, large-scale system evolution.
AI Executive Summary
The landscape of software engineering is undergoing a transformative shift driven by advances in artificial intelligence and automation. Traditional development relies heavily on human expertise and persistent agents, which, while effective for short-term tasks, struggle to sustain long-term, large-scale software evolution. As software systems grow in complexity and longevity, maintaining continuity, correctness, and adaptability becomes increasingly challenging. Existing approaches, such as continuous integration pipelines and persistent memory mechanisms, often depend on extending agent processes or maintaining shared states, which can be fragile and difficult to scale.
This paper introduces EvoX Genesis, a novel framework that reconceptualizes software development as a persistent recursive world. Instead of focusing on persistent agents, the system treats the entire software project as a durable entity, with its state and history stored as a core object. Local agents, which are finite-lived, operate within specific paths and versions, proposing changes, which are then validated and integrated into the project history only upon acceptance. This separation of agent lifetime from project longevity allows for continuous development despite agent turnover, enabling long-horizon software evolution.
The architecture leverages a minimal version-path model, recursive delegation, and validation gates, combined with deep learning-powered automation via DeepSeek V4 Flash. This integration allows the system to perform large-scale, recursive construction tasks, such as building a Rust-based C compiler from scratch in just 120 hours, archiving over 1000 agent episodes at a cost of only $44. The resulting compiler passed all relevant tests, including c-testsuite, LLVM, and Csmith, demonstrating the system’s robustness and correctness.
Further experiments showed that the same project could be continuously developed across foundation model replacements, such as switching from GLM 5.2 to DeepSeek V4 Flash, without losing test coverage or performance. The system also successfully migrated 13 MESA modules (over 100k lines of Fortran) into Rust, completing the migration in 33 hours and achieving significant speedups in numerical workloads. These results affirm that long-term software development can be organized around persistent projects rather than persistent agents, opening new avenues for autonomous, scalable, and reliable software engineering.
This work has profound implications for scientific computing, infrastructure software, and industrial applications, where long-term maintenance and evolution are critical. By decoupling project persistence from agent persistence, it offers a scalable, flexible, and resilient framework that can adapt to changing models, languages, and requirements. Future directions include integrating formal verification, expanding multi-language support, and enhancing dependency management, aiming to realize fully autonomous software ecosystems capable of continuous, long-term evolution with minimal human intervention.
Deep Dive
Abstract
Complex software systems develop over timescales that exceed the lifespan of any individual coding agent. Most agentic software systems preserve continuity through persistent sessions, memories, managers or shared context. We introduce EvoX Genesis (hereafter, Genesis), which instead makes the software project persistent while allowing local agents to remain finite-lived. Genesis represents software as a persistent recursive world: each local world is situated by an accepted version and a repository path, finite-lived agents propose local changes, recursive delegation moves work across paths, and only accepted consequences advance the persistent version history. We evaluate this organization across formation, continuation and redevelopment. Starting from a repository with no compiler implementation, Genesis used DeepSeek V4 Flash to build a Rust-based C compiler with about 250k tracked lines; the run lasted over 120 hours, archived over 1,000 agent episodes and incurred only US$44 in model-token charges. The compiler passed the complete c-testsuite and most LLVM and Csmith tests. In a separate compiler world generated with GLM 5.2, development continued after repeated agent replacement while retaining full test performance. Genesis also reimplemented 13 MESA modules with over 100k Fortran lines as a Rust workspace with nearly 90k Rust lines; across six numerical workloads, it achieved median speedups of 1.55--6.87x. These results show that long-horizon software development can be organized around a persistent project rather than a persistent agent.
References (20)
MODULES FOR EXPERIMENTS IN STELLAR ASTROPHYSICS (MESA)
B. Paxton, L. Bildsten, A. Dotter et al.
On the criteria to be used in decomposing systems into modules
D. Parnas
Programs, life cycles, and laws of software evolution
M. Lehman
Voyager: An Open-Ended Embodied Agent with Large Language Models
Guanzhi Wang, Yuqi Xie, Yunfan Jiang et al.
AlphaEvolve: A coding agent for scientific and algorithmic discovery
Alexander Novikov, Ngân V˜u, Marvin Eisenberger et al.
Evaluating AGENTS.md: Are Repository-Level Context Files Helpful for Coding Agents?
Thibaud Gloaguen, Niels Mündler, M. Muller et al.
Mathematical discoveries from program search with large language models
B. Romera-Paredes, M. Barekatain, Alexander Novikov et al.
Containers for computational reproducibility
Turning Interaction History into Execution State: A Runtime Layer for Long-Horizon Coding Agents
Zehao Wang, Yisen Xu, Chenglin Li et al.
Introducing the FAIR Principles for research software
M. Barker, N. C. Chue Hong, D. Katz et al.
SWE-bench: Can Language Models Resolve Real-World GitHub Issues?
Carlos E. Jimenez, John Yang, Alexander Wettig et al.
An AI system to help scientists write expert-level empirical software
Eser Aygün, Anastasiya Belyaeva, Gheorghe Comanici et al.
SlopCodeBench: Benchmarking How Coding Agents Degrade Over Long-Horizon Iterative Tasks
Gabriel Orlanski, Devjeet Roy, Alexander Yun et al.
SWE-EVO: Benchmarking Coding Agents in Long-Horizon Software Evolution Scenarios
Minh-Tin Thai, Tue Le, Dũng Nguyễn Mạnh et al.
NL2Repo-Bench: Towards Long-Horizon Repository Generation Evaluation of Coding Agents
Jingzhe Ding, Shengda Long, Changxin Pu et al.
MetaGPT: Meta Programming for Multi-Agent Collaborative Framework
Sirui Hong, Xiawu Zheng, Jonathan P. Chen et al.
SWE-MeM: Learning Adaptive Memory Management for Long-Horizon Coding Agents
Shuzheng Gao, Wenhao Zeng, Zhaojian Yu et al.
Beyond Isolated Tasks: A Framework for Evaluating Coding Agents on Sequential Software Evolution
K. Shastry, Ganesh Senrayan, Shrey Satapara et al.
When the Specification Emerges: Benchmarking Faithfulness Loss in Long-Horizon Coding Agents
Lu Yan, Xuan Chen, Xiangyu Zhang
EvoGit: Decentralized Code Evolution via Git-Based Multi-Agent Collaboration
Beichen Huang, Ran Cheng, Kay Chen Tan