Recursive self-improvement (RSI) through cultural transmission
Arina Kharlamova · Jikun Kang · Bowei He · Steve Liu
CPIL Research Group
MBZUAI
We would love to talk about this direction, work through your problems with you and hear where you think it should go. Write to any of us directly.
Hover a program to follow its lineage in both views.
Individuals learn; culture travels. One run on the third autocorrelation constant. On the disk, each sector is a deme, a subpopulation of programs with its own lineages, and each ring a generation; a crimson chord is a finding one deme passed to another. On the map, the same programs placed by their code.
Abstract
We use recursive self-improvement (RSI) for a process in which acquired improvements strengthen a system’s capacity for further improvement: the system gets better at getting better†. Here the system includes its procedures and inherited methods; its base model may or may not stay fixed.
We approach this through cumulative culture. Experience persists in learned practices, routines and artifacts (Henrich, 2016; Levitt and March, 1988); earlier instrument designs inform later ones (Nersessian, 2009); existing technologies and the knowledge of how to combine them support further invention (Arthur, 2007); and culturally acquired content may strengthen the very capacity to build on what is inherited (Mesoudi and Thornton, 2018). SCiEL turns this feedback between inheritance and innovation into a mechanism for search.
Its individuals are demes, subpopulations of programs with their own lineages, and research cells, standing questions that write and test their own tools. What they learn becomes culture: hypotheses tested as experiments, claims with measured effects in a shared knowledge base, tools, and the policy and world model that steer the search. Culture passes to others only after a trial at the recipient, and it shapes how the population grows: which lineages merge, where stalled demes respawn, which seeds and portfolios start new ones. Every decision is randomized and logged with its probability, so every run is a randomized experiment on itself. We study SCiEL in the Empira arena with local inference on an open 27B model, both with the weights frozen and with LoRA adapters trained during the run.
The research is ongoing. This page shows the mechanism on real runs and some results so far.
† A concise formulation of recursive self-improvement: a system “gets better at getting better” (Yampolskiy, 2015).
What this is about
Some results so far
Details in the preprint; runs in the Empira arena.
Hover a line for its final score and spend. Every gridline up is ten times closer to the best known value. Most of the climb happens in the first few cents; the rest of the budget buys the last digits, where improvements are rare and what the system has learned matters most.
Why not one model, or a swarm of agents. A hard problem is a long climb through a landscape the model sees only one edit at a time: most edits go down, some go off the feasible set, and local bumps stop a greedy climber. A single model sampled many times never chains steps. An agent loop chains them but stops on the first bump. A swarm splits the budget and its members never learn from each other. SCiEL is built for the climb: demes explore in parallel, a policy learns which way pays, a world model screens edits before they cost an evaluation, and culture moves what one deme learned to the others.
One call samples edits of the seed independently. Agent loop keeps one line and accepts improvements. Swarm runs five such lines that share nothing. SCiEL runs five demes with a learned proposal policy (the halo around each head, stretched along recent progress), a world model that fits the local slope and screens proposals before they are evaluated (hollow rings), culture that moves a lagging deme to the leader after a trial (crimson arcs), and research cells that probe far when a line stalls (violet arcs). The bars below average 30 runs of each mode; switch components off to see what each one is worth. In this landscape research cells add little: the slope always leads somewhere.
Does your task fit? Three rules, checked before any compute is spent: the check is exact or survives leak probes; the headroom above the best reference exceeds 4ε; and the upper bound of π at the frontier is at least 5/B. sciel task and the sciel-task skill measure them from your materials.
A task is ⟨X, F, h, h*, M, B⟩: candidates the model writes, a feasible set, the objective the run sees and the true one, the model's edit operator, and the budget. It is read on five axes: solution space, feasible set, noise (the radius ε below which a difference is not real), the landscape for the model (πε at the frontier) and verifiability. Because the landscape is defined by the model's operator, it moves as culture changes what the model sees.
What fits, in plain words
Poor fits: puzzles solved in one shot, tasks already at their ceiling, and anything without a score you would bet on.
sciel-task skill in Claude Code or Codex. It checks all three before any compute is spent, fixes what it can, runs SCiEL and verifies the result.Who writes what
What to improve and how it is judged: a description, a paper, a notebook, data. Then approves the audit.
An exact or held-out checker, helper modules candidates may import, and a seed that runs; then the audit for leaks, noise, headroom and frontier, with fixes for what it finds.
Every program, proposal, tool, finding and decision, each logged with its probability. Nobody edits prompts or restarts demes by hand once it starts.
In the runs on this page the task packages, checker, seed and helper modules, were built before the run; the skill builds the same parts from your materials and shows its audit before any compute is spent.
Culture is a tree with chords.
Findings, by how far they travelled
Sector = deme. Distance from the centre = generation. Lines join a parent to its child. Filled dot = still in the population, hollow = dropped, bigger = higher score. Crimson chord = a finding from one deme delivered to a child on another: solid if the child improved on its parent, dashed if not. The run replays on a loop; hover a program for its score and lineage.
Does culture raise the odds? A randomized test.
First chart: probability that a step succeeds, with and without a finding from another deme in the prompt, weighted by the inverse of the logged probability of each choice. Second chart: the difference by phase of the run with 95% intervals from a bootstrap over runs, and each run's own difference as a dot, sized by its number of steps.
From a question to a transmitted method.
From question to chord, this run
Hover a stage name for what it counts. Each research cell is a standing question. A step asks the model to plan an experiment, write a tool, run it in a sandbox and conclude. A conclusion becomes a finding; a finding is shared, adopted for trials by other demes, and drawn as a chord when it reaches a child there.
A world model of the search. Before the language model is called, SCiEL forecasts whether a proposed step will raise its lineage’s best. It does not model the task; it models the search itself, from the parent, the deme, the kind of edit, an embedding of the code and the run’s history so far. It starts from a pretrained tabular model, so it is useful after a few dozen steps, and refines itself with a residual network on the run’s own rows; rows inherited from earlier runs give it a head start. Like every learned part of SCiEL, it acts only while it earns it: at each refit it must beat the base rate and the per-cell means out of fold, or it is held back.
The world model in the loop
Its record in this run, refit by refit, is in the ladder of controllers below.
Where the long shots live. A guess that lands somewhere new is usually worse than the current best at first. If the population kept only the best, it would be evicted before anyone could build on it. So each deme is a map of niches, one elite per cell of behaviour, and a newcomer competes only with its own cell.
The niches themselves
Boards: each board is one deme. Across, the run's twelve learned niches; back to front, score bins; a bar is the best program in its cell, taller when closer to the best known value. Map: the same twelve niches as points: centroids of a vector-quantised codebook over a 32-dimensional embedding of the programs' code, projected onto their two main directions. A bubble's size is how many demes hold an elite there; its dots are those demes. The codebook grows and is re-fitted as the population moves, so a new kind of program opens a new niche instead of being thrown out. Three demes were spawned during the run, aimed at regions the others had not reached. Hover a bar or a bubble for details.
The machinery around the population, in this run
Relief in behaviour axes is smooth; in code axes it is not. Place every program by the two behaviour metrics that track the score most closely and lift it by its distance to the best known value: the programs lie on one tilted sheet, and edits climb it in steps. Place the same programs by their code and the relief breaks into clusters of good code with valleys between them. Code similarity weakly predicts quality, which agrees with the literature.
Culture disk: the disk above, lifted by score, so lineages become ridges. Code: the first two components of the programs' identifier counts; good code forms clusters with valleys between them. Behaviour: the two metrics the task reports that track the score most closely; the relief is one tilted sheet and edits climb it in steps. Time × deme: when each program was written and on which deme. Contours or the top view turn any map into a contour plot. Drag to rotate, scroll to zoom, hover a program for its score.
The landscape along edits. Plot each child against its parent. Points above the diagonal are steps up; their share is π, the task's gradient as the model sees it.
π across runs
Upper bar: share of all edits that beat their parent. Lower bar: the same share at the frontier, for edits whose parent is within 0.01 of the run's best. Axes on the left are distance to the best known value, so the top right is the frontier; hover a point for its scores.
Cold, warm, hot: who steers the search, and when. A run starts knowing nothing about which moves pay, and some of what it could learn takes hundreds of steps to see. So control passes through three stages, each taking over only once it has the data to do better than the stage before. SCiEL plays the long game, but it optimises the small decisions from the first step.
Top: who planned each step of this run. Bottom: how well the world model forecasts at each refit, against the best simple estimate; lower is better. A filled marker means it passed the check and steers; a hollow one means it was held back.
Records come in steps.
Best score by deme, on the same log scale as the relief. Each line is the best program a deme holds; the white line is the population.
Attempts that moved the record · click a row for its diff
| Attempt | Score | Move | The bet |
|---|
Generations and second order. First order: a generation that inherits the vetted repertoire of the last one should improve faster than one that starts from scratch. Second order: the procedures that create culture, when to open research, how to share, what to keep, should themselves improve across generations. Below, six first-generation runs from scratch.
Culture into weights: SCiEL with DeltaServe. Everything above leaves the model untouched; culture lives in the prompts, tools and policies around it. The deepest tier of consolidation is the model itself: episode, claim, method, procedure, and finally weights. DeltaServe [13] trains and serves LoRA adapters inside the same inference engine on one GPU, hot-swapping them by name, so a run can learn while it searches.
Training a model on its own search usually goes wrong in two ways: it learns from its own samples and collapses onto a few programs, or it learns from noisy wins. SCiEL is built to supply better data. Every step comes with a logged probability, so the training set can be reweighted for the policy that produced it, as in off-policy RL. The world model marks which transitions were genuinely informative. Niches and demes keep many kinds of program alive over long runs, so the adapter sees many routes to the frontier instead of one. And the data is transitions from a weaker parent to a stronger child that held up under re-measurement, not the best programs themselves.
An adapter does not replace the generator. It is one more randomized arm, adopted only through the same trial at the recipient as any other piece of culture, so the base model keeps proposing and its diversity is not traded away.
This line is under way and reported separately.
Tiers of consolidation
The loop with DeltaServe
↺ an adopted adapter serves the next proposals
Culture consolidates in tiers, each slower and more durable than the last. The first four live around the model and are inherited by the next run; the fifth changes the model itself. DeltaServe trains a LoRA adapter on transitions from weaker to stronger programs while the same engine keeps serving, and the adapter joins the search as one more randomized arm, adopted only if it passes the trial at the recipient.
| System | What improves | How a change is accepted | How SCiEL relates |
|---|---|---|---|
| MASS [5] | model weights, from its own team's best trajectories | a training round | complementary: SCiEL improves between training rounds, and consolidates into weights only through the same trial as any other culture |
| AIDE² [6] | the agent | greedy | a change is kept after a trial at the recipient, with its effect estimated from randomized logs |
| DGM · SICA · HGM [7, 8, 9] | agent code | benchmark score | changes the repertoire around the model rather than the agent’s code, and is judged on new problems in the Empira arena |
| Hyperagents [10] | meta-agent | fixed-k | compounding is measured as an effect: culture is delivered at random, so its contribution can be estimated |
| MetaRSI [11] | the improver of the improver | meta-level search | every self-change is paid from the run’s own budget and logged with it |
| TTT-Discover · ThetaEvolve [4, 12] | model weights during the run | RL reward | uses an open model as it is; weights change only as one optional, randomized arm |
| SCiEL | methods, claims, world model, policy, procedures | trial at the recipient, on randomized logs | this page |
Open questions.
References
Cite
@misc{cpil2026sciel,
title = {Let Them Get Better at Getting Better:
Recursive Self-Improvement through Cultural Transmission},
author = {Arina Kharlamova and Jikun Kang and Bowei He and Steve Liu},
year = {2026},
url = {https://github.com/Doldrums/sciel}
}