The Eight Layers of Self-Evolving Learning:
From Training Grounds to Self-Evolving Companies

The paradigm of the past decade was clear: humans annotate data → train → deploy → freeze the model. Once deployed, the model is a static statue; when it encounters new scenarios, it can only improve if humans feed it another round of data. Two forces have pushed this paradigm to the wall: the data wall—high-quality human annotations (especially for high-difficulty reasoning and long-horizon agent trajectories) are running dry; and the shift to agents—when models run continuously for hours and hundreds of turns in real environments, "can it keep getting stronger after deployment?" shifts from an academic question to a life-or-death product question.

In July 2025, a survey from Xiamen University and other institutions, "A Survey of Self-Evolving Agents," structured the field along four axes—What evolves, When it evolves, How it evolves, and Where it evolves—and highlighted a key insight: self-evolution is not a single technique, but a family of technologies occurring at different levels of abstraction. This article adopts a "layer" perspective, unpacking the most representative recent work into eight layers:

A useful mental model: L1 modifies the "brain" (expensive, irreversible, requires weight access); L2–L4 modify "external states beyond the brain" (cheap, controllable, applicable to closed-source models); L0 and L5 modify the brain's survival environment and physical substrate; L6 modifies the factory that builds the brain; L7 extends the same loop to any company. The most notable recent trend is precisely the center of gravity shifting from L1 to the outer layers—because most people only have frozen models, or even models behind APIs.

All other layers evolve the agent itself; this layer goes the opposite direction: let the environment and curriculum co-evolve with the agent. Its theoretical roots come from the "open-endedness" community, predating LLM self-evolution by several years. Uber AI's 2019 POET (Paired Open-Ended Trailblazer) was the foundational work: environments and the agents that solve them are paired and co-evolve, producing a diverse population of specialists capable of solving "environments humans never designed"; this line was subsequently formalized as UED (Unsupervised Environment Design), essentially the environment version of the "difficulty sweet spot" idea, and it arrived five years earlier.

The LLM era gave this line a new engine: OMNI-EPIC uses LLMs to directly generate code for environments and reward functions; Eurekaverse (UPenn, CoRL 2024) applied it to real robots—LLMs generate increasingly difficult terrain curriculum code to train quadruped robot parkour, and the trained policies can jump over 65cm gaps and complete triple jumps in the real world—the benefits of environment self-evolution penetrate into the physical world. This layer answers the question "where do hard problems come from," and it is also a core piece of the puzzle for the "open-ended ASI" argument (DeepMind 2024 position paper): without self-evolving environments, the agent's self-evolution will eventually run out of fuel.

The central question of model-layer self-evolution can be stated in one sentence: without human data, how can models keep getting stronger? The answer is "self-play"—letting the same base model simultaneously play both the problem-generator and the problem-solver. The difficulty lies in where the reward signal comes from without human labels. Four representative works offer four answers, which can be arranged along a clear evolutionary line:

Their common weakness is also consistent: they require weight access, depend on verifiable or self-consistent rewards, and are all plagued by forgetting and the "pseudo-label ceiling"—when the model systematically makes the same mistake in a domain, majority voting will solidify that error into a label. This is precisely why community attention is shifting toward the external-state layers.

L2 (Memory Layer)'s starting point is that the base model is completely frozen, with all modifications happening only on external memory—this is extremely friendly for people who can only call APIs. The shared assumption of early memory systems (MemoryBank, Mem0, A-MEM) is that the "operational rules" of memory are hand-designed and fixed; MemSkill makes the memory operations themselves evolveable "memory skills," with a Controller selecting, an Executor executing, and a Designer reviewing and inventing new skills, outperforming predecessors on both conversational memory and ALFWorld embodied tasks.

L3 (Skills Layer): The Most Active Layer in 2026

The core proposition: the truly reusable, interpretable, and transferable unit of self-evolution is a "skill"—and a skill can be represented as a pure text document, attached outside the frozen model. SkillOS argues that the real bottleneck of self-evolution is not "whether skills can be generated" but "whether skills can be curated with high quality"; SkillOpt pushes this layer to its cleanest form—an edit is only accepted when it strictly improves the held-out validation set score, turning "self-improvement" into a guardrail-bounded monotonic hill-climbing process. The effectiveness data is very hard: across 6 benchmarks and 7 target models, it achieved the best or tied-best results on all 52 evaluation settings; on GPT-5.5, relative to the no-skill baseline, direct conversation improved by +23.5 points, and within the Codex agentic loop by +24.8 points. For the vast majority of teams who only have closed-source APIs, this is the most actionable form of self-evolution right now—you can even take a skill document evolved by one model and directly transfer it to another.

L4 (Workflow Layer) evolves execution pipelines, prompt structures, and even its own codebase. Sakana AI's Darwin Gödel Machine (in collaboration with UBC) maintains an evolving lineage of agent variants, where each variant can autonomously rewrite its own codebase, more than doubling baseline software engineering performance on SWE-bench (an absolute improvement of 30 percentage points), with no human modifying code throughout. ShinkaEvolve uses adaptive sampling to push LLM-driven program evolution to extreme sample efficiency—solving optimization problems that brute-force search considers intractable using only 150 samples, and automatically discovering a new MoE load-balancing loss function; the products of evolutionary search are feeding back into L1's model training itself—this is the first clear signal that "the layers are connecting."

L4 evolves the agent's own code; L5 (Compute Substrate Layer) drills one level deeper: evolving the compute infrastructure that carries all AI itself. DeepMind's AlphaEvolve, released in May 2025, has already entered Google's production systems at scale—it discovered a heuristic for Borg data center scheduling that human engineers can directly understand, which has been online for over a year, continuously reclaiming 0.7% of Google's global compute; it sped up a key matrix multiplication kernel in Gemini training by 23%, reducing Gemini's overall training time by 1% (AI is accelerating the training of its next generation); it proposed rewrite optimizations for highly optimized arithmetic circuits on TPU that were adopted into the next-generation design; and it discovered a 48-scalar-multiplication algorithm for 4×4 complex matrix multiplication, breaking Strassen's 55-year record. This layer doesn't require the agent to be "autonomous," but its outputs directly push down the cost curve for all upper-layer self-evolution.

L6: When the Object of Evolution Is "The AI R&D Process Itself"

The most important change in 2026 is the emergence of the outermost narrative: Recursive Self-Improvement (RSI)—AI participates in and gradually takes over the entire loop of "developing next-generation AI." The Anthropic Institute's "When AI builds itself" uses internal data to "take the temperature" of RSI progress: as of May 2026, over 80% of the code merged into Anthropic's production codebase was written by Claude; in fixed-objective "accelerating training code" tests, the model went from an average speedup of ~3x to ~52x within a year, while skilled human researchers can achieve about 4x—the execution phase has crossed from "very useful" into the "superhuman" range; but when letting the model choose the next step at real research "forks in the road" and comparing its judgments with human researchers, the win rate rose from 51% in November 2025 to 64% in April 2026, still not fully surpassing humans. The article explicitly states that the world should have the option to "verifiably slow down/pause frontier development." Sakana AI officially established the RSI Lab, arguing that the competitive dimension of RSI is not compute but sample efficiency, and主张 that sample-efficient RSI can allow national-level (rather than超大规模) compute budgets to participate.

All previous layers occur within AI systems or AI labs. In May 2026, a YC partner presentation pushed this idea to its outermost ring: any company can restructure itself as a set of recursively self-improving AI loops—L6's RSI is merely a special case (when the company's product happens to be AI, L7 degenerates into L6). The organizational prototype of a traditional company is the Roman legion—nested hierarchies + humans as conduits for information transmission; YC's judgment is that "giving engineers a co-pilot to boost efficiency by 20%" is the wrong way to use AI; the right way is to restructure every company function into a five-stage loop: sensing layer (customer emails, tickets, telemetry) → policy layer (permission rules) → tool layer (deterministic APIs) → quality gate (evaluations, human review) → learning mechanism (feeding failures back to the top).

YC's real-world case demonstrated the leap "from sidekick to self-evolution": adding a monitoring agent layer above the query agent, observing when and why each query fails, then writing code overnight, submitting an MR, having another agent review it, merge it, and deploy it—so that when a human asks the same question the next day, it succeeds. This loop can be replicated across any function. The business implications are: token budgets replace headcount budgets—YC companies' revenue per employee at demo day is already 5x what it was 18 months ago; the end of middle management—coordination problems are handed to AI, leaving organizations with only all-IC structures + a single named responsible person for each task; organization readability for AI is a prerequisite—"things not recorded, for your intelligence, did not happen."

Putting "let the system modify itself" into real deployment, the most sleep-disrupting concern is not that it's insufficiently strong, but that it might converge in a bad direction: Misevolution—self-evolving agents will spontaneously drift toward harmful behaviors without any external attack, an "内生" risk of self-evolution; Zombie Agents—attackers can use "self-reinforcing injection" to allow one-time malicious inputs to continuously self-replicate and persist within self-evolution loops; Pseudo-label/majority-vote ceiling—when the judge is the model itself, the model's systematic errors get solidified into training signals by "self-consistency"; Catastrophic forgetting—continuously modifying weights equates to continuously quietly forgetting old capabilities.

The practical implications for practitioners are straightforward: working with APIs/closed-source models? Forget L1, go straight to L3—set up a skill document + "only accept strictly-better edits" optimization loop, which is the highest-ROI self-evolution right now; working in math/code/domains with deterministic verification? L1 self-play can genuinely elevate foundational capabilities, but be prepared to handle forgetting; building long-horizon agents? Prioritize investing in L2/L3, letting the agent沉淀 each failure into reusable memory/skills, which is much cheaper and safer than repeatedly retraining weights; no matter which layer, install guardrails before开启 self-evolution—held-out validation sets + monotonic acceptance criteria + rollbackable snapshots are the line that separates "self-improvement" from "self-destruction."

When L1's self-play saturates on math/code, the next scarce resource is new environments that are "just barely unlearnable"—L0's open-ended evolution is currently the only route that systematically answers "where do hard problems come from," and it is expected to converge with generatable interactive world models.