Self-Developing: Inventing the Algorithm That Improves You

Nearly every RSI method improves the model. This one improves the improvement algorithm. The Self-Developing framework, from NEC Corporation, starts from a deliberately extreme question: could an LLM autonomously discover and develop the algorithms that improve itself — not just better weights, but better methods? The paper's answer is a system where a "algorithm factory" LLM writes model-improvement algorithms as executable Python code, tests them, and gets trained via preference optimization to write better ones. The factory and the models it improves get better together. And the discovered algorithms beat the human-designed ones.

The factory loop

The setup has two moving parts. The seed model M_0 is the thing being improved. The algorithm factory π_t^g, initialized as a clone of the seed model, is the thing doing the improving — a language model whose job is to output code.

Each iteration runs four steps:

1. Generate. The factory samples candidate model-improvement algorithms — arbitrary Python functions that take models (or their weight deltas) and return an improved model.
2. Evaluate. Each candidate is actually executed: applied to the seed model to produce a merged model, which is then scored on a development set for the target task. Non-executable code and timeouts are filtered out; everything else gets a real number.
3. Refine. The top-scoring algorithms become "chosen," the bottom-scoring "rejected," and the factory is trained with DPO on those preference pairs — learning the characteristics of effective improvement code.
4. Iterate. The improved factory generates the next round of candidates, while the improved models raise the bar for what counts as good.

The concrete testbed is model merging: combining several models fine-tuned on different datasets into one stronger model. Each merge candidate contributes a task vector τ = C_j − M_0 (weights minus seed weights), and the factory's job is to write the function that combines task vectors into a merged update M_t = M_0 + a_t(τ_1, …, τ_K). Human-designed baselines here are real, respected methods — Task Arithmetic, TIES-Merging, Model Stock — so "beats the humans" is a meaningful claim, not a strawman.

Invented algorithms that win

On mathematical reasoning (GSM8K), the factory's discovered merging algorithms improved the seed model by 6% and beat Task Arithmetic by 4.3%. Then the striking part: transfer. The discovered algorithms were applied to out-of-domain models never seen during the invention process — no re-optimization — and still beat Task Arithmetic (itself tuned for those models) by 7.4%. The factory didn't just overfit a recipe to one model; it found merging principles general enough to travel. The ablations confirm the recursion matters: iteratively refining both the factory and the seed model was crucial — a static factory plateaus, a co-evolving one keeps finding better algorithms.

The preference construction is worth noting for its pragmatism: rather than hand-labeling which algorithms are good, the factory's entire training signal comes from executing candidates and measuring downstream task scores — percentile thresholds on those scores define chosen versus rejected. The factory never sees a human example of a "good" merging algorithm; it infers what good looks like from the score distribution alone. That the inferred principles then transferred to unseen models suggests it found something real about merging geometry, not just tricks for one seed.

The paper explicitly invokes AlphaGo's Move 37 — the move no human would play — as the precedent for machine-discovered strategies that transcend human imagination. The claim here is the same shape one level up: not a better move, but a better way of improving. If the factory loop generalizes beyond merging, it would mean the methods of AI progress themselves become subject to automated discovery — the most aggressive version of the RSI thesis.

Self-Developing moves the recursion up one level: the object of optimization isn't the model, it's the optimizer. When the factory that writes improvement algorithms is itself improved by preference learning on their results, you get compounding at the meta level — better methods producing better models producing better methods.

Limitations worth naming

The demonstration is narrow by design: one family of improvement algorithms (merging), one task family (math reasoning). Whether the factory loop works for inventing, say, better optimizers, better curricula, or better architectures is untested — and each new family needs an executable evaluation harness, which is itself human-designed scaffolding the paper doesn't count. The credit assignment is also murky: DPO trains the factory on whole algorithms as chosen/rejected, but which lines of the winning code mattered is never identified, so the factory may be cargo-culting surface patterns of successful code. And the dev-set loop is a classic overfitting risk — algorithms selected for GSM8K-flavored performance may not generalize to capabilities the dev set doesn't measure, a concern the transfer results mitigate but don't eliminate.

Where it sits in the RSI arc

This is the most literal realization of the "intelligence explosion" intuition in the recent literature: improvement applied to the means of improvement. It pairs naturally with AIDE^2's outer loop — both optimize the optimizer, one via an agentic rewrite loop graded on held-out benchmarks, the other via DPO on executed algorithm code. And it reframes the Gödel machine's dream in practical terms: Schmidhuber wanted provably-optimal self-rewrites of the learning algorithm; Self-Developing settles for empirically-better ones, discovered by the system itself. The gap between those two — proof versus benchmark — is still the field's central unsolved tension, but this paper shows the benchmark-driven version can already beat human experts at their own game.

Paper: Can Large Language Models Invent Algorithms to Improve Themselves?: Algorithm Discovery for Recursive Self-Improvement through Reinforcement Learning — Yoichi Ishibashi, Taro Yano, Masafumi Oyamada, 2025.