DARWIN: Dynamic Agentically Rewriting Self-Improving Network

DARWIN is an evolutionary GPT model, utilizing a genetic-algorithm like optimization structure with several independent GPT agents being trained individually using unique training code. Each iteration, the GPT models are prompted to modify the training code of one another in an attempt to improve their performance in a mutation-like manner, and the best GPT agents are then benchmarked and selected for the next iteration by genetic algorithm. For demonstration purposes and due to budget and time constraints, OpenAI API is used to prompt training code improvements and the nanoGPT framework is used as the training code. DARWIN also utilizes persistent JSON-based memory files to track previous reasoning and changes to code to correlate with improvement to model performance. and a bidirectional interface for HITL intervention allowing the model to request upgrades such as additional datasets, training scripts, and restructuring of file hierarchies. In experiments, DARWIN achieved a 1.26 percent improvement in model FLOPS utilization (MFU) and a 2.07 percent improvement to perplexity in 5 iterations of training over baseline configurations, demonstrating promising capabilities as a foundation for scaling evolutionary GPT training.

💡 Research Summary

The paper introduces DARWIN (Dynamic Agentically Rewriting Self‑Improving Network), a proof‑of‑concept framework that combines evolutionary algorithms with large language models (LLMs) to iteratively improve the training code of GPT‑style models. The core idea is to treat LLMs as mutation operators: a population of independent GPT agents is instantiated, each training a separate copy of a base model (nanoGPT in the experiments). In each generation, agents are paired, and one agent is prompted—via the OpenAI API—to modify the partner’s Python training script. The modified script is then used to train a new model instance. After training, models are benchmarked on two simple metrics—perplexity and model FLOPS utilization (MFU)—using a Shakespeare corpus. The top‑performing models are selected as parents for the next generation, mimicking natural selection.

Key architectural components include: (1) a central controller that orchestrates the genetic‑algorithm loop, (2) a mutation script that constructs prompts and handles code chunking, (3) a fitness evaluation module that runs standardized benchmarks, and (4) a utilities module that maintains a persistent JSON‑based memory of every mutation event, its context, and resulting performance. The memory enables the agents to reference prior changes, while a bidirectional human‑in‑the‑loop (HITL) interface allows agents to request resources such as larger datasets, additional libraries, or file‑system reorganizations. Containerization is employed: each agent runs in an isolated Docker folder, and prompts explicitly forbid root access to the central controller’s code, with manual checks currently used to guard against malicious behavior.

The experimental setup uses GPT‑4o‑mini as the mutation engine, a population size of ten, and retains four elites per generation. Training hyper‑parameters are modest (6‑layer, 6‑head, 384‑dim transformer, 100 training steps, batch size 64, block size 256, learning rate 1e‑3). Over five generations, the best perplexity improves from 38.498 to 37.697 (≈2.07 % reduction) and MFU from 0.397 to 0.392 (≈1.26 % reduction). Average generation time is 223 seconds, but the error rate is high: 18 out of 50 training runs fail, and only three are rescued after a single human‑guided correction, yielding a 16.7 % error‑resolution rate. An ablation that removes the persistent memory degrades performance by about 3 %, suggesting the memory contributes modestly.

The authors acknowledge several limitations. The mutation prompts are constrained by token limits, requiring code to be split into chunks; this can break cross‑chunk dependencies and leads to syntax errors. The evaluation is limited to a tiny model on a single language‑generation task, making it difficult to assess generalizability. Safety mechanisms rely on manual inspection, which would not scale to larger models or more aggressive self‑modifications. Moreover, the performance gains are modest and within the noise of training variance.

Future work outlined includes scaling to larger transformer architectures (e.g., GPT‑2‑scale), incorporating richer benchmarks (math, coding, reasoning), automating security checks, and deploying a distributed GPU‑cluster architecture to parallelize the many concurrent agents. The authors also propose refining the HITL interface and prompt engineering to improve mutation quality and reduce error rates.

In summary, DARWIN demonstrates a novel integration of evolutionary search and LLM‑driven code mutation, providing an open‑source scaffold for self‑improving AI systems. While the current results are modest and the system requires substantial engineering to become robust and scalable, the paper offers valuable insights into how LLMs can act as programmable mutation operators and how persistent memory and human oversight can be woven into an iterative self‑optimization loop.