IEEE JOURNAL DRAFT, VOL. XX, NO. X, 2026
1
From 0-to-1 to 1-to-N: Reproducible Engineering Evidence for MetaAI Recursive Self-Design
arXiv:2606.09663v1 [cs.AI] 8 Jun 2026
Dun Li ID , Jiatao Li, Hongzhi Li
Abstract—Recursive self-design refers to AI-assisted modification of the mechanisms by which an AI system is built, evaluated, and improved. This paper treats MetaAI not as a mature paradigm, but as a working term for a human-seeded, AI-expanded development pattern in which the design space itself becomes a target of modification. We propose an operational evidence framework with four criteria: inspectable target system, meta-level modifier, feedback-directed selection, and recursive continuation. We then map public systems, including Darwin Gödel Machine (DGM), STOP, Gödel Agent, and ShinkaEvolve, against these criteria. DGM provides the most direct currently reported evidence: its published results show improvement from 20% to 50% on SWE-bench Verified and from 14.2% to 30.7% on full Polyglot after 80 iterations, with ablations suggesting that both open-ended exploration and self-improvement contribute. Finally, we provide MetaAI-Mini, a reproducible HumanEvalbased protocol and codebase. Because no completed model run is included in this build, MetaAI-Mini is reported as a protocol rather than as an experimental result. Index Terms—MetaAI, recursive self-design, recursive selfimprovement, self-improving agents, Darwin Gödel Machine, ShinkaEvolve, AI agents, SWE-bench, Polyglot
I. I NTRODUCTION
W
E use the term MetaAI to denote a human-seeded, AI-expanded development pattern in which human researchers specify an initial system, constraints, and evaluation protocol, while AI-driven processes propose and test successor designs. The term is used here as an analytical label rather than as a claim that a settled field or complete architecture already exists. The empirical question is therefore narrow: do public systems provide bounded evidence that AI can modify parts of the design space that determine later AI performance? This idea has a long intellectual history. Good’s “ultraintelligent machine” argument proposed that a sufficiently capable machine could design still better machines, producing a recursive amplification of intelligence [1]. Schmidhuber’s Gödel machine formalized self-modification as a proof-governed process in which a system rewrites itself only when it can prove the rewrite increases expected utility [2]. Later work discussed bounded recursive self-improvement and software-based seed AI, emphasizing both promise and risk [3], [4]. Although Gödel’s incompleteness theorem should not be interpreted as a direct limitation on AI architectures, the Gödel-machine Dun Li is with the Department of Computing, The Hong Kong Polytechnic University, Hong Kong SAR, China. E-mail: [email protected] Jiatao Li is with the Merchant Marine College, Shanghai Maritime University, Shanghai 201306, China. E-mail: [email protected] Hongzhi Li is with the College of Big Data and Artificial Intelligence, Chizhou University, Chizhou 247100, China. E-mail: [email protected] Corresponding Author: Jiatao Li
literature motivates the broader question of whether systems can modify their own improvement procedures under explicit criteria [5]. Contemporary AI research has automated many design steps. AutoML, neural architecture search, and meta-learning can optimize model choices, architectures, and adaptation procedures inside human-specified spaces [6]–[8]. Large language model (LLM) agents extend fixed models with planning, memory, tools, and code execution [9]. Recent public systems also suggest that recursive self-improvement is becoming an organized research direction rather than a single isolated project: Sakana AI’s RSI Lab explicitly frames DGM, ShinkaEvolve, and related systems as steps toward autonomous evolutionary optimization loops [10]. Current methods predominantly perform optimization within a fixed, human-specified design space, whereas the pattern studied in this paper explicitly treats parts of that space as mutable and improvable objects. The weakness of many discussions of recursive selfimprovement is empirical. They either remain philosophical or jump directly to speculative superintelligence. This paper asks a narrower question: can we identify a real, public, reproducible experiment in which an AI system improves another AI system’s code-level architecture or algorithmic scaffold, uses performance feedback to select improvements, and iterates this process across multiple generations? If so, such an experiment would not prove full AGI, but it would provide engineering evidence that recursive self-design can be operationalized in present-day systems. We answer this question through a secondary empirical analysis of the Darwin Gödel Machine (DGM) [11]. DGM is especially suitable because it uses a coding agent that modifies its own code repository, evaluates descendants on SWE-bench Verified and Polyglot, and maintains an archive of agents that can become parents for later self-modification. We also discuss STOP, Gödel Agent, ADAS, SWE-agent, and ShinkaEvolve as related evidence, with citations given in the corresponding analysis below. The contribution is not a new DGM benchmark run; it is an evidence mapping over reported public systems plus a reproducible mini-protocol for future independent runs. This paper makes three contributions: It defines four operational criteria for recursive selfdesign. • It maps DGM, STOP, Gödel Agent, and ShinkaEvolve against those criteria, with ADAS and SWE-agent as adjacent public evidence. • It releases MetaAI-Mini, a reproducible HumanEvalbased protocol and public GitHub codebase; because no •
IEEE JOURNAL DRAFT, VOL. XX, NO. X, 2026
API-backed run is included, only protocol configuration is reported. The remainder of the paper is organized as follows. Section II defines operational criteria for recursive self-design. Section III describes the experimental design and the human 0-to-1 versus AI 1-to-N mapping. Section IV presents DGM results and visualizations. Section V introduces the MetaAI-Mini supplementary experiment. Section VI analyzes the strength and limits of the evidence, and Section VII concludes. II. O PERATIONAL C RITERIA FOR R ECURSIVE S ELF -D ESIGN We first separate several terms that are often used interchangeably. Recursive self-design denotes modification of the agent, scaffold, toolchain, prompt policy, evaluation workflow, or code-level mechanisms that shape future agent behavior. Recursive self-improvement is broader and may include any iterative process in which a system improves its own future performance, including but not limited to design changes. Self-evolving agents emphasizes lifelong adaptation across tasks and environments, but does not necessarily require the agent’s own improvement procedure to be editable. LLMdriven program evolution uses LLMs as mutation or search operators over programs and may evolve task solutions without making the agent scaffold itself the primary target. We define recursive self-design as an iterative process satisfying four operational conditions: 1) Inspectable target system: there is a target AI system whose architecture, tools, workflow, prompts, memory, or code-level policy can be inspected and modified. 2) Meta-level modifier: an AI-driven process proposes changes to that target system, not merely random perturbations or human-authored patches. 3) Feedback-directed selection: proposed changes are evaluated on an external task or utility function, and the feedback influences which descendants are retained. 4) Recursive continuation: retained descendants can serve as the starting point for later rounds of improvement. Under this definition, full neural-weight self-rewriting is not required. A coding-agent scaffold can be a legitimate target if the scaffold materially changes how the underlying foundation model is used. This is important because present-day foundation models are often frozen, while much of agent performance depends on code-level tool use, context management, search, verification, and workflow design. Table I summarizes how the main systems discussed in this paper align with the four operational conditions. DGM is the closest match because its descendants modify the code-level agent scaffold and can become later parents. STOP satisfies the conditions for the narrower object of an improver scaffold, Gödel Agent satisfies them through runtime self-reference and task-driven policy modification, and ShinkaEvolve provides a useful program-evolution baseline where LLMs mutate scientific or algorithmic code under explicit evaluators. A. Distinction from Ordinary Optimization Recursive self-design is stricter than hyperparameter tuning. In ordinary optimization, a fixed search process adjusts
2
parameters within a predefined space. In recursive self-design, the system may change the representation and procedure by which later tasks are solved. A temperature schedule or retry count alone would be weak evidence. A new editing primitive, a context summarization mechanism, or a patchranking workflow is stronger evidence because it changes the structure of the agent’s interaction with tasks. The distinction can be stated as follows. Boundary-internal optimization keeps the design space fixed: Dt+1 = Dt ,
xt+1 = Ω(xt ; Dt ).
(1)
Recursive self-design changes the system that searches and acts: St+1 = Ψ(St , Rt , Ct ), (2) where St is the current agent design, Rt is empirical feedback, and Ct is a constraint set such as sandboxing, benchmark protocols, and human oversight. III. E XPERIMENTAL D ESIGN A. Experiment Selection The main experimental substrate is DGM because it most closely matches the four operational conditions above. It begins with one coding agent, lets archived agents self-modify their own codebases, evaluates the resulting agents on coding benchmarks, and uses an archive to preserve diverse stepping stones. The authors released code and experiment artifacts through a public repository [12]. STOP and Gödel Agent are included as secondary evidence because they report related forms of recursive scaffold improvement and self-referential agent update, but DGM is the primary experiment because it reports multi-iteration code-level agent evolution on standardized coding benchmarks. ShinkaEvolve is included as an external baseline and resource for sample-efficient program evolution rather than as the primary recursive self-design experiment: it evolves target programs using LLM mutation, novelty filtering, adaptive parent sampling, and bandit-based model selection, but the reported framework does not primarily make the full improvement engine itself the target of recursive modification. B. Benchmarks and Data DGM evaluates coding agents on two benchmarks. SWEbench asks agents to resolve real-world GitHub issues by editing repositories and passing hidden tests [13]. DGM uses SWE-bench Verified, a human-filtered subset intended to remove unsolvable tasks [14]. Polyglot evaluates coding ability across multiple programming languages and is associated with the Aider leaderboard [15]. The DGM report uses pass rates as the primary metric, i.e., the percentage of tasks solved by the agent. The two benchmarks are useful for recursive self-design analysis because they test more than single-answer prediction. A coding agent must inspect files, edit code, manage context, run tests, and produce patches. Therefore, improvements to tools and workflow can change the agent’s effective architecture even if the foundation model is frozen.
IEEE JOURNAL DRAFT, VOL. XX, NO. X, 2026
3
TABLE I: Operational criteria for recursive self-design across related systems System
Inspectable target system
DGM
Full: repository, tools, prompts, and Full: archived agents propose and Full: children are evaluated on workflow are editable. implement self-modifications. SWE-bench or Polyglot before retention. Partial: the improver scaffold is ed- Full: the seed improver is applied Full: meta-utility estimates downitable, but base LM weights are to its own code. stream improvement quality. fixed. Partial: runtime and policy-level Partial: self-reference updates Partial: task feedback guides polagent logic are editable. agent behavior, but not an archive icy changes across benchmarks. of codebases. Limited: target programs are ed- Partial: LLMs act as mutation op- Full: fitness, novelty filtering, and itable, not the full agent scaffold. erators over program candidates. adaptive sampling guide retention.
STOP
Gödel Agent
ShinkaEvolve
Meta-level modifier
Feedback-directed selection
Recursive continuation Full: retained descendants can become parents for later selfmodification. Partial: continuation is bounded to scaffold-improvement rounds. Partial: recursive cycles are reported, without DGM-style lineage archives. Not primary target: program populations evolve, while the improvement engine is not the main evolving object.
Note: Full, Partial, Limited, and Not primary target are qualitative mappings based on the four operational criteria above. They summarize reported system designs and should not be read as independent benchmark replications. The labels indicate the degree to which each system satisfies the criterion for the specific target analyzed here, rather than an absolute ranking of system capability.
Protocol analyzed in this paper 1. Human zero-to-one: define seed coding agent, tools, benchmarks, archive rule, sandbox, and evaluation protocol. 2. Initialize archive A0 = {S0 }. 3. For each iteration t = 1, . . . , 80: sample parent(s) from archive; let parent inspect logs; let parent propose and implement a code-level self-modification; evaluate the child on staged benchmark tasks; retain child if it compiles and preserves codeediting functionality. 4. AI one-to-N: retained descendants become possible parents for future self-modification; the best archived agent is reported.
TABLE II: Recursive self-design protocol instantiated by DGM. The outer archive and evaluation envelope are humandesigned, while concrete agent modifications are generated by the AI-driven parent agents.
C. Initial Target AI and Meta-AI Setting In DGM, the initial target AI is a coding agent built around a frozen foundation model with access to a Bash tool and an edit tool. For self-modification, the coding agents use Claude 3.5 Sonnet (New) in both the SWE-bench and Polyglot experiments. During benchmark evaluation, the SWE-bench agents use Claude 3.5 Sonnet (New), while Polyglot evaluation uses o3-mini [16], [17]. The meta-level improvement process is implemented as follows. The DGM archive stores generated agents. At each iteration, one or more parent agents are sampled from the archive. A parent analyzes its own benchmark logs, proposes a feature or workflow change, edits its own codebase to implement the proposal, and produces a child agent. The child is evaluated. If it compiles and retains basic code-editing functionality, it is added to the archive. The DGM experiments run for 80 iterations, generating one new agent per iteration, with parallelism in parent selection.
D. Human Zero-to-One Versus AI One-to-N Table III maps the experiment to a human-seeded and AIexpanded division of labor. The human contribution is the seed and constraint envelope. The AI contribution is the repeated generation of concrete successor designs.
TABLE III: Mapping DGM to a human-seeded and AIexpanded division of labor Role Human one
Concrete instantiation in DGM zero-to-
AI one-to-N
Fixed boundary Modified boundary
Seed coding agent; initial Bash and edit tools; DGM archive procedure; parent-selection rule; staged evaluation protocol; benchmark choice; sandboxing and oversight. Parent agents inspect evaluation logs, propose selfmodifications, edit their own codebase, create child agents, and allow successful descendants to become future parents. The open-ended exploration loop itself is not modified by DGM in the reported experiments. The agent’s internal tools and workflows are modified, including editing primitives, context handling, and patch-generation procedures.
TABLE IV: Published DGM endpoint and transfer results used in this secondary analysis; not newly rerun in this work Benchmark
Initial agent
Best DGM agent
SWE-bench Verified endpoint 20% 50% Polyglot, 50-task staged endpoint 14% 38% Polyglot, full-benchmark endpoint 14.2% 30.7% SWE-bench → Polyglot transfer 14.2% 28.9% Polyglot → SWE-bench transfer 20% 24.5% Note: The values are pass rates reported by the DGM authors. When the source reports a zero decimal digit, this table suppresses that trailing decimal for readability; nonzero decimals are preserved. The staged Polyglot setting uses 50 tasks, so each solved task changes the pass rate by 2 percentage points. The transfer rows evaluate the best agent evolved on one benchmark against the other benchmark.
IV. E VIDENCE M APPING AND R EPORTED R ESULTS A. Reported DGM Performance The primary external evidence is the endpoint improvement after 80 DGM iterations. We did not rerun DGM; Table IV reports only values explicitly published in the DGM paper and repository. The first three rows are endpoint evaluations, while the last two rows add held-out cross-benchmark transfer checks reported by the DGM authors. These numbers support a bounded feasibility claim. A seed coding agent, without changing the underlying foundation model weights, generated descendants that solved substantially more tasks. The gain on SWE-bench Verified is 30 percentage points, and the full-Polyglot gain is 16.5 percentage points.
IEEE JOURNAL DRAFT, VOL. XX, NO. X, 2026
4
TABLE V: Published DGM ablation results used in this secondary analysis Method
SWE-bench
Polyglot
50% 23% 39% 39.7%
38% 14% 28% 30%
DGM DGM w/o open-ended exploration DGM w/o self-improve DGM greedy
TABLE VI: Structural changes summarized from the DGM paper and repository; not newly discovered in this work Change type
Reported effect on agent design
Granular file viewing
View relevant line ranges rather than entire files, reducing context burden. Replace whole-file edits with precise substring replacement requiring unique matches. Detect empty or test-only patches and retry with source-file changes. Summarize conversation history when the model context limit is reached. Generate several candidate patches and use another model or ranking procedure to select a stronger solution. Use previous attempts to condition later patch proposals.
String-replacement editing Patch validation and retry
Published DGM endpoint/ablation values; not a new run
Context-window management Multiple patch generation and ranking
20%
Initial
14% 23%
No archive
History-aware patch generation
14% 39%
No self-improve
28%
Inside one recursive self-design cycle 39.7%
DGM greedy
30%
Seed agent
Selfmodify
Evaluate
Archive / retain
Descendant agent
50% SWE-bench Verified 38% staged Polyglot
DGM
0
10
20
30 Pass rate (%)
40
50
next generation
Fig. 1: Performance comparison using published DGM endpoint and ablation data. The Polyglot bars use the 50-task staged evaluation reported with the ablations; the full Polyglot endpoint is separately reported in Table IV.
Fig. 2: MetaAI-Mini protocol overview. The diagram describes the experimental procedure—seed agent, self-modification, evaluation, archive/retention, and descendant agent—and is not an experimental performance measurement.
The result is not a proof of unbounded self-improvement, but it is a concrete case in which recursive code-level self-design is associated with stronger agent performance.
capacity for further modification would not meet the recursive continuation criterion. C. Reported Structural Improvements
B. Reported DGM Ablation Evidence A stronger source of evidence is whether the recursive components matter in the published ablations. Table V reports DGM’s published comparison against ablations. Removing open-ended exploration sharply reduces performance. Removing self-improvement also reduces performance. A greedy parent-selection variant also underperforms the full archivebased DGM. Figure 1 makes the ablation pattern visually explicit. If the full result came only from a fixed meta-agent repeatedly designing target agents, the “DGM w/o self-improve” baseline should be competitive. It is not. If the result came only from hill-climbing along the latest best lineage, the greedy or noarchive variants should be competitive. They are not. The reported evidence is therefore more consistent with a recursive, population-like process in which improved descendants and non-greedy stepping stones both contribute. DGM also reports the percentage of generated SWE-bench agents that retain basic code-editing functionality: 51.3% for full DGM, compared with 32.5% for both the no-archive and no-self-improvement ablations. This matters because selfimprovement requires preserving the ability to modify code. A system that improves task scores while destroying its
Table VI summarizes structural modifications reported in the DGM paper and repository. These are not merely scalar tuning operations. They change how the agent reads, edits, evaluates, and retries code. The DGM report further notes that similar high-level feature goals can lead to very different implementations and performance. For example, two SWE-bench nodes targeted finergrained editing, but one implementation achieved 23.3% while another achieved 40.5%. This suggests an important point: recursive self-design is not only about choosing features; it is also about discovering implementation details that preserve agent functionality while improving downstream performance. D. Protocol Overview Without Synthetic Curves Figure 2 replaces a performance-trend schematic with a procedural overview. It shows the recursive loop used by MetaAIMini and related evidence mappings: a human-provided seed agent is modified, evaluated, either archived or rejected by a retention rule, and then used as the parent of a descendant generation. The figure is not a measurement and does not imply any unreported intermediate DGM or MetaAI-Mini performance values.
IEEE JOURNAL DRAFT, VOL. XX, NO. X, 2026
5
TABLE VII: MetaAI-Mini protocol configuration
E. Supporting Evidence from Related Systems STOP shows recursive scaffold improvement by applying a seed improver to its own code and selecting successors through a meta-utility [18]. ADAS directly studies automated design of agentic systems, where a meta-agent searches over code-level agent designs [19]. Both motivate DGM’s stronger requirement that generated agents themselves remain capable of later selfmodification. Gödel Agent reports self-referential policy updates across DROP, MGSM, MMLU, and GPQA, plus a 30-step MGSM improvement analysis [20]. SWE-agent is not a self-design system, but its agent-computer interface shows why codingagent scaffolds and tool interfaces are performance-critical design objects [21]. Together they support the narrower claim that editable agent policies and interfaces can improve under feedback. ShinkaEvolve is a complementary baseline for LLM-driven program evolution: LLM mutations, explicit evaluators, novelty filtering, adaptive parent sampling, and bandit model selection evolve target programs [22], [23]. It is not direct evidence of agent self-modification, but it is a useful comparison point for future MetaAI-Mini variants with deterministic evaluators.
Field
Configuration
Dataset
Official OpenAI HumanEval downloaded from HumanEval.jsonl.gz. First 10 official HumanEval records; not 50 tasks and not the full 164-task benchmark. seed_agent.py, exposing solve_task(task). Configurable through OPENAI_MODEL; default script value is gpt-4.1-mini. Default 5 candidate-improvement generations. Local subprocess execution with per-task timeout; measured pass@1 on the 10-task subset. Retain a candidate only if its pass@1 strictly improves over the active agent. Public GitHub package released; protocol checked on real downloaded data; no MetaAIMini performance values are reported without run_type=api rows.
Task count Seed agent Model Generations Evaluation Retention rule Current status
The analysis script generates a formal improvement curve only from API-backed rows by default; --allow-mock is reserved for smoke-test plotting. This keeps the manuscript aligned with completed runs rather than intended or mock runs. VI. A NALYSIS
V. M ETA AI-M INI : A M INIMAL R EPRODUCIBLE E XPERIMENT Full DGM reproduction is expensive because SWE-benchstyle evaluation requires repository checkout, patch generation, hidden tests, and sandboxing. MetaAI-Mini is therefore included as a lightweight supplementary protocol, not as a benchmark result: a seed agent is evaluated, an LLM proposes a successor implementation, the candidate is tested, and the script retains it only if pass@1 improves. The package is publicly available at https://github.com/ DunLi-Tsinghua/MetaAI-Mini and uses the first 10 official OpenAI HumanEval records [24], [25]. It includes the official HumanEval.jsonl.gz file and a mechanically extracted data/tasks.json; it does not use 50 tasks or the full 164-task benchmark. The seed file seed_agent.py exposes solve_task(task), while self_improve.py logs generation, run_type, active agent path, pass@1, and acceptance status. The same repository regenerates the PDF graphics inserted in this manuscript through python analyze.py --paper-figures --skip-curve. Generated Python code is executed locally with timeouts, so this is not a secure sandbox. The mini-protocol is intentionally narrow but useful: it fixes the data split, records provenance checksums, and forces a distinction between smoke-test plumbing and API-backed improvement. This makes it suitable for classroom reproduction and for later replacement of the single-lineage rewrite loop with stronger search procedures. No API-backed MetaAI-Mini run is reported in this manuscript. Mock smoke-test rows are marked run_type=mock and must not be reported as results; real OpenAI-backed rows are marked run_type=api. Table VII is therefore a protocol-configuration table.
The evidence is consistent with a limited MetaAI-style pattern. In DGM, humans define the seed, benchmark, safety boundary, and archive process; the AI modifies code-level agent design, and successful descendants become future parents. Figure 1 shows that the full DGM loop outperforms ablations, while Figure 2 separates protocol structure from measurement. STOP and Gödel Agent provide adjacent support through recursive improver updates and self-referential policy modification; ShinkaEvolve clarifies what evaluatordriven program evolution can achieve when the evolving object is a target program rather than the agent scaffold. The most important inference is structural rather than merely quantitative. DGM’s gains arise from changes to the agent’s editing tools, retry logic, context handling, and candidate-ranking workflow. These are not final AGI mechanisms, but they are concrete examples of an AI system modifying the operational substrate through which future task attempts are made. The archive appears central. A greedy process may discard low-scoring variants that later become useful stepping stones, whereas DGM’s archive-based process preserves multiple lineages. This suggests that future MetaAI-style systems should compare single-chain self-edits with evolutionary archives, lineage audits, rollback mechanisms, and diversity-preserving parent selection. The evidence is bounded. It does not establish full RSI or AGI: the foundation models remain fixed, the benchmark suite and retention rules are human-authored, and DGM does not modify its outer open-ended exploration loop. The experiments are also expensive, stochastic, and coding-centric. The results should therefore be read as feasibility evidence for recursive self-design, not as evidence for an imminent intelligence explosion. A stronger next step would report machine-readable
IEEE JOURNAL DRAFT, VOL. XX, NO. X, 2026
lineage data, per-generation diffs, evaluation traces, and failed modifications so that self-design dynamics can be audited rather than inferred from endpoint scores alone. Safety is integral rather than secondary. A self-modifying system can alter tools, evaluators, logging, context handling, and execution pathways. The cited STOP and DGM artifacts both indicate that future systems need sandboxing, tripwires, independent evaluation, immutable audit logs, and humangoverned deployment gates. VII. C ONCLUSION This paper proposed an operational evidence framework for recursive self-design and applied it to public systems. DGM is the clearest reported example we identify: after 80 iterations, a seed coding agent improves from 20% to 50% on SWE-bench Verified and from 14.2% to 30.7% on full Polyglot, with ablations indicating that self-improvement and open-ended exploration both matter. Together with STOP, Gödel Agent, ShinkaEvolve, and MetaAI-Mini, these systems provide bounded evidence that recursive self-design and adjacent LLM-driven program evolution are plausible engineering patterns. The contribution is deliberately limited: the paper does not claim autonomous design of arbitrary future intelligence and reports no MetaAI-Mini performance without an APIbacked run. Future work should publish per-iteration logs, test beyond coding, make outer improvement loops modifiable under safeguards, and evaluate safety as a first-class outcome. R EFERENCES [1] I. J. Good, “Speculations concerning the first ultraintelligent machine,” in Advances in Computers, F. L. Alt and M. Rubinoff, Eds. New York, NY, USA: Academic Press, 1965, vol. 6, pp. 31–88. [2] J. Schmidhuber, “Gödel machines: Self-referential universal problem solvers making provably optimal self-improvements,” 2003. [3] E. Nivel, K. R. Thórisson, B. R. Steunebrink, H. Dindo, G. Pezzulo et al., “Bounded recursive self-improvement,” 2013. [4] R. V. Yampolskiy, “From seed ai to technological singularity via recursively self-improving software,” 2015. [5] K. Gödel, “Über formal unentscheidbare sätze der Principia Mathematica und verwandter systeme i,” Monatshefte für Mathematik und Physik, vol. 38, no. 1, pp. 173–198, 1931. [6] F. Hutter, L. Kotthoff, and J. Vanschoren, Eds., Automated Machine Learning: Methods, Systems, Challenges. Cham, Switzerland: Springer, 2019. [7] B. Zoph and Q. V. Le, “Neural architecture search with reinforcement learning,” in Proc. International Conference on Learning Representations, 2017. [8] C. Finn, P. Abbeel, and S. Levine, “Model-agnostic meta-learning for fast adaptation of deep networks,” in Proc. International Conference on Machine Learning, 2017, pp. 1126–1135. [9] L. Wang, C. Ma, X. Feng, Z. Zhang, H. Yang et al., “A survey on large language model based autonomous agents,” Frontiers of Computer Science, vol. 18, no. 6, p. 186345, 2024. [10] Sakana AI, “Introducing sakana ai’s recursive self-improvement (RSI) lab,” https://sakana.ai/rsi-lab/, 2026, accessed: 2026-06-07. [11] J. Zhang, S. Hu, C. Lu, R. Lange, and J. Clune, “Darwin gödel machine: Open-ended evolution of self-improving agents,” 2025. [12] ——, “Darwin gödel machine code repository,” https://github.com/ jennyzzt/dgm, 2025, accessed: 2026-06-05. [13] C. E. Jimenez, J. Yang, A. Wettig, S. Yao, K. Pei et al., “SWEbench: Can language models resolve real-world GitHub issues?” in Proc. International Conference on Learning Representations, 2024. [14] OpenAI, “SWE-bench Verified,” https://openai.com/index/ introducing-swe-bench-verified/, 2024, accessed: 2026-06-05.
6
[15] P. Gauthier, “Polyglot benchmark,” https://aider.chat/docs/leaderboards/, 2024, accessed: 2026-06-05. [16] Anthropic, “Claude 3.5 sonnet,” https://www.anthropic.com/news/ claude-3-5-sonnet, 2024, accessed: 2026-06-05. [17] OpenAI, “Openai o3-mini,” https://openai.com/index/openai-o3-mini/, 2025, accessed: 2026-06-05. [18] E. Zelikman, E. Lorch, L. Mackey, and A. T. Kalai, “Self-taught optimizer (STOP): Recursively self-improving code generation,” in Proc. Conference on Language Modeling, 2024. [19] S. Hu, C. Lu, and J. Clune, “Automated design of agentic systems,” 2024, arXiv:2408.08435; code: https://github.com/ShengranHu/ADAS. [20] X. Yin, X. Wang, L. Pan, L. Lin, X. Wan, and W. Y. Wang, “Gödel agent: A self-referential agent framework for recursively self-improvement,” in Proc. 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). Vienna, Austria: Association for Computational Linguistics, 2025, pp. 27 890–27 913. [21] J. Yang, C. E. Jimenez, A. Wettig, K. Lieret, S. Yao, K. Narasimhan, and O. Press, “SWE-agent: Agent-computer interfaces enable automated software engineering,” in Advances in Neural Information Processing Systems, 2024, arXiv:2405.15793; code: https://github.com/SWE-agent/ SWE-agent. [22] R. T. Lange, Y. Imajuku, and E. Cetin, “Shinkaevolve: Towards openended and sample-efficient program evolution,” 2025. [23] Sakana AI, “Shinkaevolve code repository,” https://github.com/ SakanaAI/ShinkaEvolve, 2025, accessed: 2026-06-07. [24] M. Chen, J. Tworek, H. Jun, Q. Yuan, H. P. de Oliveira Pinto et al., “Evaluating large language models trained on code,” 2021. [25] OpenAI, “Humaneval dataset,” https://github.com/openai/human-eval/ blob/master/data/HumanEval.jsonl.gz, 2021, accessed: 2026-06-05.