Native Self-Evolution Dynamics

• Native Self-Evolution is a process in which systems internally generate mechanisms to modify their own fitness landscapes and adapt over time.
• It spans disciplines from eco-evolutionary dynamics to AI, where techniques like self-generated feedback and closed-loop model versioning drive system evolution.
• These self-evolving systems offer practical benefits such as enhanced adaptability, robustness, and efficiency in both biological models and AI-native infrastructures.

Searching arXiv for the cited works and closely related papers on native/self-evolution. arXiv search query: "native self-evolution world knowledge exploration SELF self-evolution language feedback self-propelled evolution regenerating landscapes" In the cited literature, Native Self-Evolution denotes a family of processes in which an evolving system generates part of the mechanism of its own further change. The term is used across several domains: eco-evolutionary dynamics where populations deform the landscapes they traverse; LLMs that critique, refine, and retrain on their own outputs; agents that explore unseen environments and distill reusable world knowledge before task execution; AI-native infrastructures that autonomously version and promote models; GenAI-native software that internalizes repeated cognitive work into stable core behavior; and formal or cultural theories in which evolution proceeds through self-editing or communal reorganization rather than only through externally imposed selection. Taken together, these works suggest a common structure: the system does not merely react to a fixed objective, static environment, or manual update pipeline, but alters the effective search space, training distribution, or operational substrate through its own activity (Heyde et al., 14 Jun 2026, Lu et al., 2023, Zhang et al., 20 Apr 2026, Bensalem et al., 24 Jan 2026, Vandeputte, 21 Aug 2025).

1. Conceptual core and defining distinctions

A recurring distinction in this literature is between passive adaptation and internally generated adaptation. In the eco-evolutionary model of "Self-propelled evolution on regenerating landscapes" (Heyde et al., 14 Jun 2026), a population does not merely respond to a fitness landscape; it remodels and regenerates the landscape it moves on. In "SELF: Self-Evolution with Language Feedback" (Lu et al., 2023), a LLM does not remain a passive consumer of human-labeled data or external reward signals; after a small meta-skill supervision stage, it generates candidate responses, critiques them in natural language, refines them, filters them, and fine-tunes on the resulting synthetic corpus. In "Training LLM Agents for Spontaneous, Reward-Free Self-Evolution via World Knowledge Exploration" (Zhang et al., 20 Apr 2026), an agent is trained so that, at inference time, it explores an unseen environment, constructs World Knowledge $\mathcal{K}$, and uses that knowledge later, without external rewards or human instructions.

The same distinction appears at the systems level. "Efficient Self-Learning and Model Versioning for AI-native O-RAN Edge" (Bensalem et al., 24 Jan 2026) treats model evolution not as a manual deployment practice but as a closed-loop version-management problem spanning Cell-Site, Edge-Cloud, Regional-Cloud, and Central-Cloud. "Foundational Design Principles and Patterns for Building Robust and Adaptive GenAI-Native Systems" (Vandeputte, 21 Aug 2025) defines self-evolution more narrowly as a disciplined transition from temporary cognitive processing to stable, reproducible, and efficient software behavior. In that account, native self-evolution is not unrestricted self-modification; it is coupled to reliability, excellence, evolvability, self-reliance, and assurance, and constrained by rollback, logging, versioned checkpoints, policy languages, visibility into autonomous operations, and infallible fail-safe mechanisms.

A further distinction concerns the meaning of native. In some papers, native denotes an intrinsic behavioral competence internalized in model parameters, as in reward-free environment exploration or parallel reasoning (Zhang et al., 20 Apr 2026, Wu et al., 8 Dec 2025). In others, it denotes execution in the real substrate rather than a simulator, as in native x86 Windows artificial evolution (Sperl, 2011). In yet others, it denotes a process that is internally generated by the evolving population, worldview, or code itself, rather than externally prescribed (Heyde et al., 14 Jun 2026, Arvanitakis, 2020, Gabora, 2012, Gabora et al., 2024).

2. Self-propelled evolution on regenerating landscapes

In eco-evolutionary theory, native self-evolution is formalized as a minimal eco-evolutionary feedback model coupling population density $n(\mathbf{x},t)$ and environmental or resource landscape $u(\mathbf{x},t)$ over trait space $X$ (Heyde et al., 14 Jun 2026). Both are normalized: $$\int_X n({\bf x},t)\,d{\bf x} = \int_X u({\bf x},t)\,d{\bf x} = 1.$$ The coupled dynamics are

$$\dot n = n(u-\phi), \qquad \dot u = -\varepsilon u(n-\phi),$$

with mean fitness

$$\phi(t)=\langle n,u\rangle=\int_X n({\bf x},t) u({\bf x},t)\,\textup d\mathbf x.$$

The single control parameter is $\varepsilon$, the relative sensitivity of the environment or landscape to the population. The paper states that $\varepsilon>1$ means the environment is more sensitive than the population, $\varepsilon<1$ means the population is more sensitive than the environment, and $n(\mathbf{x},t)$0 yields a static landscape.

The first equation is the usual replicator equation: types with $n(\mathbf{x},t)$1 increase, and those with $n(\mathbf{x},t)$2 decrease. The second models resource depletion and regeneration analogously: occupied regions of trait space are made less fit, while under-occupied regions become relatively fitter. This generates the paper’s central mechanism. The population consumes resources where it is abundant, depletion changes $n(\mathbf{x},t)$3 locally, that change creates a new selection gradient, and the population then moves up the gradient it has just induced. Even on an initially flat landscape, once $n(\mathbf{x},t)$4, flatness is only instantaneous.

The paper extends Fisher’s fundamental theorem to deformable landscapes. For $n(\mathbf{x},t)$5,

$n(\mathbf{x},t)$6

so that $n(\mathbf{x},t)$7. Under regenerative feedback,

$n(\mathbf{x},t)$8

Fitness gain from selection, $n(\mathbf{x},t)$9, is offset by landscape feedback, $u(\mathbf{x},t)$0. Mean fitness can therefore fluctuate or decrease, and fitness ascent is no longer monotone.

A reduced moment description assumes a locally Gaussian population and a locally quadratic landscape. With mean trait $u(\mathbf{x},t)$1, covariance $u(\mathbf{x},t)$2, local fitness $u(\mathbf{x},t)$3, selection gradient $u(\mathbf{x},t)$4, and Hessian $u(\mathbf{x},t)$5, the leading-order equations are

$u(\mathbf{x},t)$6

and for landscape moments,

$u(\mathbf{x},t)$7

with

$u(\mathbf{x},t)$8

The paper interprets this as a coevolution of mean motion, variance regulation by curvature, and curvature regulation by ecological feedback.

The resulting dynamics are not limited to smooth hill-climbing. The analysis reports sustained oscillations, chaotic dynamics, direction reversals, repeated loops in trait space, and evolutionary branching (Heyde et al., 14 Jun 2026). In one-dimensional continuous trait space, self-propelled motion on an initially flat landscape yields an evolutionary speed scaling

$u(\mathbf{x},t)$9

over a wide parameter range, before saturation or slowdown at large $X$0. The same feedback can also drive branching, with the number of modes growing exponentially and a speciation rate scaling as $X$1. A plausible implication is that native self-evolution, in this setting, is not merely directed adaptation but a regime in which the evolving system manufactures the gradients, curvature, and disruptive structure that determine its own trajectory.

3. Self-generated training signals in LLMs and parallel reasoners

In LLM research, native self-evolution is often instantiated as self-generated supervision. "SELF: Self-Evolution with Language Feedback" (Lu et al., 2023) has two stages. The first, meta-skill learning, teaches self-feedback and self-refinement using a small annotated corpus. For each prompt $X$2, an initial response $X$3 is generated, a language annotator $X$4 produces feedback $X$5 and a revised answer $X$6, and each training example is a tuple $X$7. The training objective is a maximum-likelihood or cross-entropy objective: $X$8 The induced latent process is

$X$9

The second stage is iterative self-evolution. At iteration $$\int_X n({\bf x},t)\,d{\bf x} = \int_X u({\bf x},t)\,d{\bf x} = 1.$$0, the previous model generates an initial response, produces self-feedback, generates a self-refined response, filters the refined output, and fine-tunes on the synthetic set $$\int_X n({\bf x},t)\,d{\bf x} = \int_X u({\bf x},t)\,d{\bf x} = 1.$$1. The training loss is

$$\int_X n({\bf x},t)\,d{\bf x} = \int_X u({\bf x},t)\,d{\bf x} = 1.$$2

The paper interprets this as minimizing the KL divergence between the previous round’s self-refined distribution and the current model’s direct generation distribution. The model is therefore trained to directly emit what its own prior self-refinement process judged to be better output.

The empirical results are substantial. On GSM8K and SVAMP, baseline Vicuna obtains $$\int_X n({\bf x},t)\,d{\bf x} = \int_X u({\bf x},t)\,d{\bf x} = 1.$$3 and $$\int_X n({\bf x},t)\,d{\bf x} = \int_X u({\bf x},t)\,d{\bf x} = 1.$$4; pseudo-labeled QA tuning raises this to $$\int_X n({\bf x},t)\,d{\bf x} = \int_X u({\bf x},t)\,d{\bf x} = 1.$$5 and $$\int_X n({\bf x},t)\,d{\bf x} = \int_X u({\bf x},t)\,d{\bf x} = 1.$$6; adding SELF yields $$\int_X n({\bf x},t)\,d{\bf x} = \int_X u({\bf x},t)\,d{\bf x} = 1.$$7 and $$\int_X n({\bf x},t)\,d{\bf x} = \int_X u({\bf x},t)\,d{\bf x} = 1.$$8 under direct response; and SELF with self-refinement at inference yields $$\int_X n({\bf x},t)\,d{\bf x} = \int_X u({\bf x},t)\,d{\bf x} = 1.$$9 and $$\dot n = n(u-\phi), \qquad \dot u = -\varepsilon u(n-\phi),$$0, while self-consistency plus self-refinement reaches $$\dot n = n(u-\phi), \qquad \dot u = -\varepsilon u(n-\phi),$$1 and $$\dot n = n(u-\phi), \qquad \dot u = -\varepsilon u(n-\phi),$$2 (Lu et al., 2023). The feedback mechanism also differs from scalar-reward RLHF: on GSM8K, RLHF reaches $$\dot n = n(u-\phi), \qquad \dot u = -\varepsilon u(n-\phi),$$3, while SELF reaches $$\dot n = n(u-\phi), \qquad \dot u = -\varepsilon u(n-\phi),$$4 in the comparable setting, and SELF correctly identifies $$\dot n = n(u-\phi), \qquad \dot u = -\varepsilon u(n-\phi),$$5 of incorrect answers whereas the RLHF reward model identifies $$\dot n = n(u-\phi), \qquad \dot u = -\varepsilon u(n-\phi),$$6.

A distinct but related line makes parallel reasoning itself native. "Native Parallel Reasoner: Reasoning in Parallelism via Self-Distilled Reinforcement Learning" (Wu et al., 8 Dec 2025) defines reasoning over a dependency graph: $$\dot n = n(u-\phi), \qquad \dot u = -\varepsilon u(n-\phi),$$7 so that steps without mutual dependency can execute concurrently. Its three-stage progression comprises cold-start format discovery, rejection sampling plus parallel warmup under strict topology, and native-parallel RL. The accepted self-distilled corpus is defined by a correctness-and-format gate, and Stage 2 introduces a parallel attention mask and parallel positional encoding so that branches can attend to shared context but not to one another across branch boundaries. Stage 3 optimizes the branching policy directly in the execution graph through Parallel-Aware Policy Optimization (PAPO), using a strict on-policy objective and preserving gradient flow on special structure tokens (Wu et al., 8 Dec 2025).

The empirical claim is that the model self-evolves from sequential emulation to genuine native parallelism. Across eight reasoning benchmarks, NPR trained on Qwen3-4B reports gains of up to $$\dot n = n(u-\phi), \qquad \dot u = -\varepsilon u(n-\phi),$$8 and inference speedups up to $$\dot n = n(u-\phi), \qquad \dot u = -\varepsilon u(n-\phi),$$9, while showing a uniform $$\phi(t)=\langle n,u\rangle=\int_X n({\bf x},t) u({\bf x},t)\,\textup d\mathbf x.$$0 parallel rate on all eight benchmarks and no hidden autoregressive fallback (Wu et al., 8 Dec 2025). In this literature, native self-evolution therefore refers not only to self-generated data, but also to self-distilled structural policies that become part of the model’s native execution regime.

4. Reward-free self-evolution in agents through world knowledge

"Training LLM Agents for Spontaneous, Reward-Free Self-Evolution via World Knowledge Exploration" (Zhang et al., 20 Apr 2026) defines native self-evolution as an intrinsic meta-evolution capability: before task execution, an agent explores an unseen environment $$\phi(t)=\langle n,u\rangle=\int_X n({\bf x},t) u({\bf x},t)\,\textup d\mathbf x.$$1, extracts structural information, compresses it into World Knowledge $$\phi(t)=\langle n,u\rangle=\int_X n({\bf x},t) u({\bf x},t)\,\textup d\mathbf x.$$2, and later uses $$\phi(t)=\langle n,u\rangle=\int_X n({\bf x},t) u({\bf x},t)\,\textup d\mathbf x.$$3 for downstream tasks. The paper contrasts a reactive policy

$$\phi(t)=\langle n,u\rangle=\int_X n({\bf x},t) u({\bf x},t)\,\textup d\mathbf x.$$4

with a two-phase lifecycle: $$\phi(t)=\langle n,u\rangle=\int_X n({\bf x},t) u({\bf x},t)\,\textup d\mathbf x.$$5 It explicitly characterizes inference-time behavior as workflow-free, task-free, and reward-free.

Training proceeds in two stages. Stage 1 is supervised fine-tuning using trajectories produced by Gemini-2.5-Pro. For each environment instance, the teacher generates three candidate knowledge documents $$\phi(t)=\langle n,u\rangle=\int_X n({\bf x},t) u({\bf x},t)\,\textup d\mathbf x.$$6, the system evaluates their downstream utility, and retains the best one $$\phi(t)=\langle n,u\rangle=\int_X n({\bf x},t) u({\bf x},t)\,\textup d\mathbf x.$$7 together with its exploration trajectory

$$\phi(t)=\langle n,u\rangle=\int_X n({\bf x},t) u({\bf x},t)\,\textup d\mathbf x.$$8

Stage 2 uses reinforcement-based rejection sampling rather than online RL over hundreds of exploration steps. Candidate explorations are scored by an outcome-based reward

$$\phi(t)=\langle n,u\rangle=\int_X n({\bf x},t) u({\bf x},t)\,\textup d\mathbf x.$$9

where, for a website with $\varepsilon$0 labeled tasks,

$\varepsilon$1

The paper emphasizes that this reward evaluates end utility rather than exploration quality or intermediate steps, and is used only during training.

For websites, the environment is converted into a clustered URL graph. Webpages are nodes, links are edges, and page importance is ranked by

$\varepsilon$2

The resulting world knowledge document is a compact Markdown “Guidebook” with an overview, category-level summaries, per-page summaries with URLs, and important factual details. At inference time, the agent loads this document into context as an external memory module. The paper distinguishes this from test-time training: adaptation occurs by generating and consuming world knowledge in prompt context, not by updating parameters at test time.

Empirically, the method reports roughly 20\% absolute improvements over baseline “Without” models on WebWalker and WebVoyager for Qwen3-30B-A3B and Seed-OSS-36B, and an efficiency gain of about 17\% fewer execution steps across domains (Zhang et al., 20 Apr 2026). Examples include WebWalker average improving from 22.04 to 40.91 and WebVoyager average from 41.08 to 57.44 for Qwen3-30B-A3B. The paper also states that generated world knowledge enables a Qwen3-14B model to outperform unassisted Gemini-2.5-Flash. The central claim is therefore not merely that knowledge helps tasks, but that the capacity to create reusable environment knowledge becomes an intrinsic competence of the agent.

5. Native self-evolution in AI-native infrastructures and GenAI-native software

In AI-native networking, native self-evolution is framed as closed-loop model life-cycle management. "Efficient Self-Learning and Model Versioning for AI-native O-RAN Edge" (Bensalem et al., 24 Jan 2026) addresses the fact that O-RAN specifies control interfaces and layered intelligence, but does not specify a native mechanism for model versioning, retraining, promotion, rollback, and coordinated rollout across the hierarchy. The proposed architecture spans Cell-Site, Edge-Cloud, Regional-Cloud, and Central-Cloud. Training pipelines in Central/Regional Cloud continuously produce candidate versions, which are cataloged in a shared version repository together with resource footprints and quality metadata, including CPU, RAM, and disk requirements, plus accuracy, stability, reliability, and security scores. The Update Manager consults telemetry and repository metadata to decide whether a running replica should keep its current model or switch to a newer one, and the container orchestrator deploys those decisions across heterogeneous worker nodes.

The optimization problem is explicitly multi-objective: maximize accuracy and stability while minimizing average delay under node resource constraints. The paper gives the per-node limits

$\varepsilon$3

and decomposes request delay as

$\varepsilon$4

The RL-based Update Manager uses Q-learning with an $\varepsilon$5-greedy exploration schedule and reward

$\varepsilon$6

where $\varepsilon$7 is delay, $\varepsilon$8 is instability, and $\varepsilon$9 is accuracy. The reported parameters are $\varepsilon>1$0, $\varepsilon>1$1, $\varepsilon>1$2, with $\varepsilon>1$3, $\varepsilon>1$4, initial exploration $\varepsilon>1$5, and decay to $\varepsilon>1$6.

The results show differentiated behavior across control loops and service classes. For dApps, delays are in the 10–12 ms range and the RL agent sacrifices some accuracy to preserve latency and stability; for xApps, the median delay is around 490 ms; for rApps, around 4.11 s. Always-update gives highest accuracy and lowest stability, never-update fixes stability at 1, and the RL agent achieves very high stability for dApps and competitive stability for xApps and rApps (Bensalem et al., 24 Jan 2026). Each major release improves accuracy by about 2\%, reduces stability by about 2\%, and reduces service time by about 7\%; each minor version improves accuracy by about 0.1\% while reducing stability by about 0.1\%. In this setting, native self-evolution refers to autonomous, telemetry-driven model promotion decisions distributed across the O-RAN hierarchy.

At a broader software-architecture level, "Foundational Design Principles and Patterns for Building Robust and Adaptive GenAI-Native Systems" (Vandeputte, 21 Aug 2025) treats native self-evolution as the capacity of a service to observe recurring friction or inadequacy, temporarily adapt through cognitive processing, and progressively internalize those adaptations into more reliable, efficient, and reusable core behavior. The five pillars are reliability, excellence, evolvability, self-reliance, and assurance. A central technical principle is to minimize dependency on cognitive processing: routine and common cases should move toward deterministic logic, while ambiguous and exceptional cases remain on cognitive or agentic paths. The programmable router is the main control point, deciding whether requests go to core deterministic logic, a GenAI path, a fallback path, or a rerouting step. The GenAI-native cell provides a self-contained unit with a static core, dynamic components, cognitive assets, an adaptive router, and optional DevOps or management components; the organic substrate provides the environment in which many such cells interact, evolve, and reorganize.

The paper is explicit that self-evolution here is not synonymous with unbounded creativity. The system should “evolve towards reliable and efficient systems” and “promote consistency over creativity” unless creativity is required (Vandeputte, 21 Aug 2025). It is also explicit that the framework is conceptual and lacks large-scale empirical validation. A plausible implication is that, in this systems literature, native self-evolution is defined less by self-modifying models than by governed transitions from adaptive cognition to hardened infrastructure.

6. Formal, cultural, and security-theoretic interpretations

A formal computational interpretation appears in "Recursion, evolution and conscious self" (Arvanitakis, 2020). There, self-evolution is grounded in self-editing, where the current state-code is both the data being processed and the program that processes it. If $\varepsilon>1$7, then $\varepsilon>1$8 is the activated instruction of $\varepsilon>1$9, and a self-editing computation satisfies

$\varepsilon<1$0

The Basic Self-Editing Principle states that for every algorithm $\varepsilon<1$1, there is a code $\varepsilon<1$2 such that for every code $\varepsilon<1$3,

$\varepsilon<1$4

The proliferating extension allows branching descendants,

$\varepsilon<1$5

and complete-memory self-editing lets the current self act on its full history. The paper’s sequential diagonalization principle makes learning explicit: the system can inspect its own successful history, infer a pattern, encode that pattern as a differentiating code, and thereby learn “how to learn.” In this formulation, native self-evolution is internal recursive self-reference coupled to selection over descendants.

A different, explicitly substrate-level interpretation appears in "Imitation of Life: Advanced system for native Artificial Evolution" (Sperl, 2011). This work attempts artificial evolution directly inside native x86 Windows systems. The organism satisfies the three criteria for evolution—replication, mutation, and selection—and does so through a biosynthesis-like two-layer representation in which bytes act as codons, instructions as amino acids, functions as proteins, and a tiny translator plays the role of tRNA. Redundancy in the 256-codon alphabet is used to improve mutational robustness, API calls are made mutable through hashed API names rather than brittle fixed addresses, and mutation operators include point mutation, chromosomal inversion, insertion, deletion, translocation, and neutral codon variation. The paper reports that after about 7.5 hours, a mutation allowed some organisms to bypass a no-cloning guard, and that an organism with about 90\% introns showed a much higher mutation rate and continuous spread in Hamming distance. Lower-energy alphabets showed better fitness than random alphabets, and a large intron of 100,000 random codons sometimes yielded converted functional blocks as long as 33 codons, with one performing an API call without crashing. The work raises explicit security concerns: native self-evolving organisms may adapt in ways that make signature-based detection and containment difficult.

In cultural and pre-Darwinian evolutionary theory, native self-evolution is detached from strict selectionist replication. Gabora argues that Dawkins-style selectionism requires a self-assembly code, a genotype/phenotype distinction, and non-transmission of acquired characteristics, conditions that culture lacks (Gabora, 2012). The proposed alternative is communal exchange, in which novelty is generated and retained through interactions among self-organizing networks rather than differential replication of discrete replicators. This account draws on von Neumann’s self-replicating automaton and on origin-of-life work associated with Vetsigian, Woese, and Goldenfeld. It is supported by the EVOC model and by conceptual network approaches to artifact history.

"An evolutionary process without variation and selection" (Gabora et al., 2024) formalizes a related idea as Self–Other Reorganisation (SOR) using Reflexively Autocatalytic and Foodset-generated (RAF) networks. A catalytic reaction system is

$\varepsilon<1$6

and a non-empty subset $\varepsilon<1$7 is a RAF if it is reflexively autocatalytic and F-generated. The process combines internal reorganization of RAF networks with percolation of products across a connected group of entities. With percolation rate $\varepsilon<1$8, generation rate $\varepsilon<1$9, and group size $n(\mathbf{x},t)$00, the event that each of the first $n(\mathbf{x},t)$01 products percolates to everyone before the next one is generated satisfies

$n(\mathbf{x},t)$02

and with $n(\mathbf{x},t)$03,

$n(\mathbf{x},t)$04

In the community-based limit, products spread so quickly that variation is only transient; the group behaves almost as a single evolving system. The authors show that complexity in this communal regime grows at order at least $n(\mathbf{x},t)$05, whereas in the individual-based regime it grows about like $n(\mathbf{x},t)$06. This is a direct challenge to the common assumption that cumulative adaptive evolution must be explained by variation plus selection.

Across these formal, cultural, and security-oriented accounts, a central controversy concerns whether evolution must be selectionist. The cited papers answer differently depending on substrate, but they converge on a narrower point: native self-evolution names processes in which future adaptive change is generated within the evolving system—through self-editing code, communal exchange, RAF-mediated reorganization, or executable mutation in a real operating system—rather than being exhausted by externally fixed inheritance, externally supplied reward, or passive response to a static landscape.