Fitness Monotonic Execution (FME)

• FME is a self-referential meta learning approach that autonomously generates and schedules self-modified candidate solutions based on performance metrics.
• It uses a scheduler to allocate computational resources monotonically according to observed fitness, replacing traditional explicit meta optimization with selection pressure.
• FME has demonstrated adaptive behavior in tasks like bandits and Cartpole, balancing exploration and exploitation through internal self-modification despite sensitivity to hyperparameters.

Fitness Monotonic Execution (FME) is a self-referential meta learning scheme introduced as a minimalistic mechanism for meta learning without any explicit meta optimization. In its original formulation, a self-referential system generates its own candidate modifications and a scheduler allocates computation monotonically with respect to observed performance, so that better-performing self-modified solutions are executed more often or for longer (Kirsch et al., 2022). The term has subsequently been used more loosely in adjacent literatures to denote fitness-monotonic trajectories, accessible paths, or non-decreasing fitness along an execution or scaling path, but these later usages are reinterpretations rather than the original definition (Hegarty et al., 2012, Baciak et al., 14 Mar 2026).

1. Original formulation and objective

In the original paper, the objective of FME is to avoid explicit meta optimization of free variables such as initial parameters or memory by letting the self-referential system generate new candidate solutions through its own self-modifications, and schedule their execution time monotonically in terms of their observed performance (Kirsch et al., 2022). The system maintains a set of solutions

$\Phi=\{\phi_i\},$

where each solution is a complete instantiation of all variables

$\phi=\{\theta,h,y\}.$

The self-referential architecture updates these variables internally, and as it interacts with an environment it continually adds new solutions to $\Phi$ by self-modifying $\phi$ during execution.

The scheduling signal is average reward per unit lifetime. For a solution $\phi$, with cumulative reward $R(\phi)$ and lifetime $\Delta t$, performance is measured by

$F(\phi)=\frac{R(\phi)}{\Delta t}.$

A probability mass function $p(\phi)$ selects which solution to execute next, and the defining monotonicity criterion is

$$F(\phi_i)\geq F(\phi_j)\;\Rightarrow\; p(\phi_i)\geq p(\phi_j).$$

The paper also notes that $\phi=\{\theta,h,y\}.$0 can be normalized by solution frequency to avoid dominance by many similar low-fitness solutions (Kirsch et al., 2022).

A central clarification is that “fitness monotonic execution” refers to monotonicity of resource allocation with respect to fitness, not a formal guarantee of monotonic non-decrease in fitness across time. The special case in which $\phi=\{\theta,h,y\}.$1 places all mass on the current best solution is described as “greedily selecting for improvement,” but the paper does not prove that this yields $\phi=\{\theta,h,y\}.$2 for the sequence of executed solutions, especially because solutions can self-modify during execution and thereby change their fitness (Kirsch et al., 2022). This distinction is the main point at which later reinterpretations of the term diverge from the original usage.

2. Execution cycle and self-referential update mechanism

The execution cycle is population-based but does not use an external meta optimizer. A buffer stores solutions; the scheduler repeatedly samples $\phi=\{\theta,h,y\}.$3, runs the self-referential network $\phi=\{\theta,h,y\}.$4 in an RL environment for $\phi=\{\theta,h,y\}.$5 steps, and then adds the modified $\phi=\{\theta,h,y\}.$6 back to the buffer (Kirsch et al., 2022). In compact notation, the architecture is written as

$\phi=\{\theta,h,y\}.$7

with all variables $\phi=\{\theta,h,y\}.$8 controlled and updated by the architecture itself.

The concrete implementation uses outer-product-based self-modification. For input $\phi=\{\theta,h,y\}.$9 and parameters $\Phi$0, the layer computes

$\Phi$1

$\Phi$2

$\Phi$3

$\Phi$4

where $\Phi$5 is tanh, $\Phi$6 is sigmoid, and $\Phi$7 sets the learning rate for the four output partitions producing $\Phi$8 (Kirsch et al., 2022). Multiple such self-referential layers are stacked.

The role of the scheduler is purely selective. All changes to the model, including learning rules, policy parameters, and mechanisms producing future changes, are realized via self-modification during execution. This suggests a division of labor in which the architecture generates descendants and the scheduler imposes selection pressure by assigning more computational resources to better-performing descendants. The paper characterizes this as replacing explicit meta optimization with selection pressure exerted by the scheduler (Kirsch et al., 2022).

3. Relation to self-referential systems, memory-based meta learning, and parameter sharing

The original analysis places FME within a broader taxonomy of meta learning architectures. The paper states that self-referential architectures

$\Phi$9

and memory-based architectures

$\phi$0

have equivalent representational capacity under meta optimization (Kirsch et al., 2022). A memory architecture can emulate a self-referential system by storing $\phi$1 in $\phi$2 and updating $\phi$3 within $\phi$4 via $\phi$5; conversely, self-referential systems can represent memory architectures by updating a subset of variables with the identity.

FME specifically addresses the case without explicit meta optimization. In that setting, the paper argues that memory architectures become inadequate because their non-modifiable parameters and initial memory need external meta optimization. Self-referential architectures are therefore required to make all variables time-varying and internally updated (Kirsch et al., 2022). The conventional distinction between parameters and activations is correspondingly blurred, because both are treated as components of $\phi$6 that can be written by the network.

A further observation concerns parameter sharing, generalized as “variable sharing.” The paper states:

Assuming a connected computational graph, an architecture that updates all its variables $\phi$7 in iteration $\phi$8 needs to reuse elements of $\phi$9 multiple times in the computational graph to generate $\phi$0 from $\phi$1.

The proof sketch is combinatorial: because the number of generated variables $\phi$2 equals the number of available variables $\phi$3, operations creating outputs that depend on multiple inputs must reuse some inputs across operations (Kirsch et al., 2022). In the implemented architecture, the outer-product mechanism realizes this reuse through multiplicative interactions that derive an $\phi$4 fast-weight update from small vectors $\phi$5.

The paper also draws conceptual links to in-context learning and fast weight programmers. FME leverages parameter sharing and multiplicative interactions to encode learning and meta learning in forward dynamics, but unlike typical in-context meta learners it does not rely on a meta-optimized initialization (Kirsch et al., 2022).

4. Formal properties, experimental regimen, and empirical results

The assumptions stated for FME are limited. The architecture must be self-referential and able to update all variables $\phi$6; a performance measure must be available from environment interaction, typically

$\phi$7

and scheduling $\phi$8 must be monotonic in $\phi$9 (Kirsch et al., 2022). The paper does not provide formal convergence or stability guarantees. It contrasts FME with the success story algorithm (SSA), which reverts to checkpoints when performance decreases, whereas FME’s selection is not sequential and maintains parallel exploration without rollback rules (Kirsch et al., 2022).

The empirical evaluation is minimalistic. Tasks are a 2-armed bandit, Cartpole, and a non-stationary 2-armed bandit in which good and bad arms swap at random intervals and reward is fed as input to enable adaptation (Kirsch et al., 2022). The architecture consists of three self-referential outer-product layers with 32 hidden units. The implementation uses an LRU buffer with $R(\phi)$0 buckets covering the current performance range evenly; each bucket holds the 100 most recent solutions. Sampling is exponentially biased toward higher-performance buckets with exponential base $R(\phi)$1, initialization uses a truncated normal with standard deviation $R(\phi)$2, and each selected solution is executed for $R(\phi)$3 steps (Kirsch et al., 2022).

A baseline based on hill climbing perturbs parameters with Gaussian noise of tuned variance and selects the best solution, so its proposals are externally engineered rather than self-generated (Kirsch et al., 2022). On the stationary bandit, the paper reports that from a random initialization, after approximately 40 self-modifications and selections, FME finds a solution that always selects the arm with higher payoff, and that FME is as effective as hill climbing in this simple environment (Kirsch et al., 2022). On Cartpole, achieving a good policy requires significantly more self-modifications and selections; FME outperforms hill climbing in learning speed, and learned policies can balance the pole for about 100 steps. The paper interprets this as selecting not only better policies but also self-modification strategies that improve future improvements, that is, “learns how to learn” (Kirsch et al., 2022).

In the non-stationary bandit, reward input is decisive. With reward provided as input, FME leads to self-modifying policies that change action in response to previously received reward; without reward input, policies fail to adapt (Kirsch et al., 2022). This suggests that the mechanism can express meta-adaptive behavior when informative feedback is available in the forward dynamics.

5. Limitations, misconceptions, and open questions

The most common misconception is to read “fitness monotonic execution” as a theorem of monotonic improvement. The paper explicitly does not introduce mathematical constraints guaranteeing monotonic improvement of fitness across time, and states that the system-level fitness trajectory need not be monotonic over time because solutions can self-modify during execution and performance can decrease (Kirsch et al., 2022). The guaranteed monotonicity is only in resource allocation with respect to measured fitness.

Several failure modes are identified. Greedy selection, in which $R(\phi)$4 concentrates all mass on the current best solution, risks premature convergence and locking into local optima, especially if self-modifications are myopic. The LRU and bucketed sampling mitigate but do not eliminate this risk (Kirsch et al., 2022). Performance is also sensitive to hyperparameters such as the exponential sampling base $R(\phi)$5, bucket count and size, execution length $R(\phi)$6, and initialization variance. Because FME maintains and evaluates many self-modified solutions and runs long episodes, it can be compute intensive and requires storage and scheduling overhead (Kirsch et al., 2022).

The paper further notes task dependence. In sparse-reward or highly non-stationary environments, self-modification without engineered meta rules may be inefficient; success may depend on informative feedback signals, as illustrated by the non-stationary bandit in which reward input was crucial for adaptation (Kirsch et al., 2022). Solutions are executed in isolation and do not communicate, which the paper identifies as a limitation and a possible direction for future work. Other open directions include architecture self-modification of the form

$R(\phi)$7

communication and multi-agent interactions, and larger-scale experiments beyond bandits and Cartpole (Kirsch et al., 2022).

A semantic question is also left open: whether FME should itself be called a minimalistic meta optimizer, given that modifications are self-generated rather than prescribed by engineered rules (Kirsch et al., 2022). This question became more salient as later papers reused the acronym in other senses.

6. Later reinterpretations in fitness landscapes and scaling theory

Outside the original self-referential meta learning context, later work uses FME to denote fitness-monotonic trajectories on landscapes or along scaling paths. In random fitness-landscape theory, the closest technical object is the accessible path: a path

$R(\phi)$8

along which fitness strictly increases at every step (Hegarty et al., 2012). On the $R(\phi)$9-dimensional binary hypercube, “On the existence of accessible paths in various models of fitness landscapes” analyzes House of Cards (HoC), constrained House of Cards (CHoC), and rough Mount Fuji (RMF) models, showing that the probability of at least one accessible path from $\Delta t$0 to $\Delta t$1 tends respectively to $\Delta t$2, $\Delta t$3, and $\Delta t$4 as $\Delta t$5 (Hegarty et al., 2012). In the generalized $\Delta t$6-HoC model, the critical threshold is

$\Delta t$7

and below threshold the number of accessible paths concentrates around its mean (Hegarty et al., 2012). In this literature, FME is therefore interpreted as feasible when the landscape admits accessible paths, and infeasible when reciprocal sign epistasis or random ruggedness blocks strictly increasing trajectories (Krug, 2019, Hwang et al., 2017).

Review literature on accessibility percolation and landscape navigation makes the same mapping more explicitly. “Accessibility percolation in random fitness landscapes” treats fitness-monotonic paths as the core object and studies the probability $\Delta t$8 that at least one such path exists as graph structure, initial fitness, slope, and correlations vary (Krug, 2019). “Evolution as fitness landscape navigation” identifies accessible paths, adaptive walks under SSWM, and greedy walks as the nearest established terms for what a monotone-execution interpretation of FME would mean (Srivastava et al., 18 Apr 2026). These papers are not redefining the self-referential algorithm of (Kirsch et al., 2022); they are using the phrase to name a monotonic navigation constraint.

A different reinterpretation appears in “Monotonicity of Fitness Landscapes and Mutation Rate Control,” where FME is presented as an execution strategy that adapts mutation rate to maintain monotonic fitness progress or monotonic expected progress in discrete sequence spaces (Belavkin et al., 2012). In the geometric case

$\Delta t$9

the paper derives exact or approximate mutation-rate control rules, including the one-step optimal rule

$F(\phi)=\frac{R(\phi)}{\Delta t}.$0

It then proves weak monotonicity near an optimum under continuity and openness conditions, motivating the hypothesis that optimal mutation rate increases when fitness decreases in some neighborhood of an optimum (Belavkin et al., 2012). This is a control-theoretic use of monotonic execution, not the self-modification scheduler of (Kirsch et al., 2022).

At a still broader level, “The Institutional Scaling Law” defines FME as the assumption or operational method that ensures fitness does not decrease along execution or scaling steps, for example

$F(\phi)=\frac{R(\phi)}{\Delta t}.$1

along the chosen scaling trajectory (Baciak et al., 14 Mar 2026). That paper then argues that institutional fitness

$F(\phi)=\frac{R(\phi)}{\Delta t}.$2

is generally non-monotonic in model scale because capability, trust, affordability, and sovereignty can diverge, yielding an environment-dependent optimum $F(\phi)=\frac{R(\phi)}{\Delta t}.$3 beyond which “bigger is worse” for institutional fitness (Baciak et al., 14 Mar 2026). This usage directly challenges a blanket monotonicity assumption, but it is conceptually separate from the scheduler-based FME of (Kirsch et al., 2022).

Taken together, the later literature shows that the acronym has become polysemous. In its original sense, FME is a self-referential meta learning method whose monotonicity lies in compute allocation. In later fitness-landscape and scaling discussions, FME denotes strict fitness-increasing paths, monotonic expected improvement, or non-decreasing deployment fitness. A plausible implication is that discussions of FME now require explicit disambiguation between the original scheduler-based algorithm and these broader monotonicity-based reinterpretations.