Imagine a coding agent that works with the same team for six months. It sees every code review, recurring failure, abandoned abstraction, and correction that never made it into the documentation. A capable memory system can retrieve those events later. Yet retrieval alone does not ensure that the agent becomes better at the underlying work. Its context grows; its learning procedure stays fixed.

This distinction matters as agents move from short benchmark episodes to persistent deployment. A long-running agent should not need to reread its entire history before every decision. At some point, repeated experience should be consolidated into a more efficient policy, a better tool, a new memory procedure, or a capability the original model did not reliably possess.

Position. Recursive self-improvement will be useful only when an agent can modify a sufficiently expressive part of itself, can reverse and audit each modification, and can deliberately seek capabilities outside its current repertoire.

The three conditions are interdependent. Freedom without stability produces brittle systems. Stability without exploration produces a well-behaved local optimum. Exploration without a sufficiently expressive update surface merely rearranges what the agent already knows. The rest of this essay develops this argument and separates what we have demonstrated from what remains a research program.

The context accumulation trap

The default response to a long deployment is to retain more state: longer contexts, retrieval indexes, episodic memory, user profiles, and logs. These mechanisms are necessary. They let the agent recover facts and decisions that no single prompt can hold. But they change the information available to a fixed system; they do not necessarily change the system's capability.

Our work on knowledge boundaries makes the limitation concrete. For a fixed model, some knowledge can be elicited by prompting, some becomes available only with external evidence, and some remains beyond reliable reach. Likewise, ALCUNA shows that models struggle with genuinely new knowledge, especially when new information must interact with what is already stored internally. These results do not prove that every agent needs online weight updates. They do show why “put it in the context” is not a complete theory of learning.

A useful deployment architecture therefore needs two forms of adaptation:

  • Non-parametric adaptation changes prompts, memory, tools, workflows, and other harness state.
  • Parametric adaptation changes how the model itself represents or executes a capability.

The research question is not which form wins. It is how an agent should decide between them, modify them safely, and evaluate whether a change deserves to persist.

Four levels of self-modification

It helps to organize agent designs by the deepest surface their optimization loop can change. The levels below describe increasing freedom, not a universal ranking: a lower level can be the right engineering choice when the task is narrow or the risk of adaptation is high.

Swipe horizontally to compare all four levels.

Four levels of self-modification: L1 optimizes outputs, L2 optimizes harness components under a fixed optimizer, L3 recursively optimizes the harness and optimizer, and L4 also exposes weights to bounded optimization.
Figure 1. Four levels of self-modification. Blue marks optimization by a fixed algorithm; amber marks a recursively optimized component. The two consequential boundaries are whether the optimizer is editable and whether the model's weights are editable.

Swipe horizontally to compare all columns.

Level Editable surface What remains fixed Representative system
L1 Task output or solution artifact Harness, optimizer, model AlphaEvolve
L2 Prompt, memory, tools, modules Update rule or meta-optimizer ChemAgent
L3 Harness and its optimizer Base-model weights Gödel Agent
L4 Harness, optimizer, and bounded weight updates External safety and evaluation boundary WeAct (ongoing)

At L1, the system searches over answers or programs. AlphaEvolve, for example, uses an evolutionary coding pipeline to improve a target algorithm under evaluator feedback. At L2, a fixed meta-algorithm updates parts of the harness. ChemAgent updates structured memories for chemical reasoning, but the rule that performs the update is still designed in advance.

L3 crosses the recursion boundary: the machinery that proposes improvements is itself editable. L4 crosses a second boundary between conditioning a model and changing the function it computes. That extra freedom is necessary only when the desired capability cannot be recovered reliably from the current weights.

Requirement I: freedom to improve the improver

A fixed optimizer creates a subtle ceiling. It may search an enormous space of prompts, workflows, or agents, but its own proposal rule, decomposition strategy, and acceptance criteria remain human choices. Adding a meta-optimizer simply moves the fixed boundary up one level.

Gödel Agent tests a more direct alternative. The agent includes a sensor that reads its running logic and an executor that can rewrite that logic, including the procedure responsible for future rewrites. Changes take effect in the next recursive call, so the current execution can finish before the new implementation is loaded.

The important result is not merely that code was edited. The agent changed the method by which later solutions would be produced. On MGSM, Gödel Agent outperformed the prior Meta Agent Search baseline by 11%. In a Game of 24 case study, it abandoned an LLM-based solver after repeated failures, wrote a search procedure, and reached 100% accuracy. The system found a qualitatively different algorithm rather than another prompt variation.

Subsequent systems strengthen the case that an editable optimizer is a useful design primitive. The Darwin Gödel Machine evolves a growing archive of coding agents and empirically validates self-modifications. Hyperagents combines a task agent and the meta-agent that modifies it into a single editable program, so improvements can target both task behavior and the procedure that generates future agents.

What this establishes. L3 systems can discover useful changes to their own optimization machinery. It does not establish monotonic improvement, an unbounded design space in practice, or safety under unrestricted self-modification. In Gödel Agent's MGSM robustness analysis, 14% of optimization trials ultimately ended below the initial policy.

That failure rate is not an incidental footnote. It motivates the second requirement: a self-modifying system needs an update representation that makes rollback, attribution, and regression testing ordinary operations.

Requirement II: reversible internal actions

Harness-level changes remain limited by the base model. When the missing capability is not reliably represented in the weights, L3 can reorganize inference but cannot manufacture the capability from nothing. Direct weight editing appears to solve this problem, yet it creates three others.

  1. Catastrophic forgetting: a narrow update can overwrite capabilities that were not part of the local objective.
  2. Verifiability collapse: an opaque gradient update is difficult for the agent, evaluator, or operator to attribute to a specific decision.
  3. Recursive instability: every flawed update changes the model responsible for judging and producing the next update.

Our ongoing WeAct work treats weight changes as internal actions. A frozen base model is paired with a library of capability-specific, low-rank deltas. During a trajectory, the agent can load or offload a delta through the same explicit action interface it uses for search or code execution.

WeAct sequence: the agent loads a math weight delta when math capability is needed, then replaces it with a code delta while preserving the same context, memory, and intermediate results.
Figure 2. WeAct exposes weight deltas as internal actions. The agent preserves its context and intermediate state while changing the capability configuration used for the next step.

This interface is different from calling a specialist sub-agent. A sub-agent receives a query and returns a result across an interface boundary. A loaded delta changes how the same agent processes the context, memory, and intermediate results it already holds. The implementation currently uses LoRA because adapters are cheap to swap and easy to version, but the design principle is broader: a weight change should be named, bounded, inspectable, and reversible.

Reversibility does not make an update safe by itself. It makes safety mechanisms implementable. A failed delta can be removed. A regression can be attributed to a specific artifact. Two configurations can be evaluated under the same context. The base model remains a recovery point, and acceptance can depend on both target-task gain and a held-out regression suite.

Preliminary evidence. In current internal evaluations, WeAct improves over the strongest tested baseline by 8% on GAIA and 6% on BrowseComp. These results are ongoing and have not yet undergone peer review. The completed system selects from a pre-trained delta library; autonomous creation of new deltas remains future work.

Requirement III: choosing what to learn next

An agent can have expressive and reversible updates and still stop improving. If every new training target is derived from its own successful outputs, the loop is biased toward variations of capabilities it already has. The system needs an exploration pressure that points beyond its covered region.

I propose a Diversity Critic for this role. The Critic receives candidate capabilities from sources outside the current policy - a paper abstract, code commit, user correction, tool description, or recurring failure cluster - and estimates how different each candidate is from what the base model and current delta library already cover.

1

Encode candidates

Map methods and capabilities into a representation initialized from text and refined with behavioral or activation fingerprints.

2

Estimate coverage

Represent the elicitable skills of the base model together with the capabilities supplied by validated deltas.

3

Select a frontier

Rank candidates by novelty, deployment value, learnability, and safety rather than distance alone.

4

Train and validate

Create a bounded delta, test target gains and regressions, and add it to the library only after acceptance.

Diversity is a search heuristic, not a utility function. The farthest capability may be irrelevant, impossible to learn with the available data, or unsafe to acquire. A practical Critic must combine novelty with deployment value, learning cost, confidence, and policy constraints. Its output should be a falsifiable proposal - what to learn, why it is not already covered, how success will be measured, and which existing capabilities are at risk.

Composition adds another constraint. The current public version of our atomic-skills study finds that reinforcement learning synthesizes composite reasoning only after the atomic prerequisites are sufficiently mastered. This suggests an ordering principle for the Critic: acquire missing atomic capabilities before spending updates on a composite target that depends on them.

The representation itself must also evolve. As the base model and delta library change, the boundary between “covered” and “novel” moves. The geometry-of-reasoning perspective offers one possible tool: activation trajectories can complement text descriptions when two methods sound different but induce similar internal behavior, or sound similar while changing reasoning in distinct ways.

A closed loop for post-deployment learning

The three requirements fit into a conservative improvement loop. The loop is recursive because the editable harness includes parts of the proposal and learning machinery. It is controlled because evaluation, permissions, and recovery remain outside the editable boundary.

  1. Observe. Collect task outcomes, corrections, traces, and recurring failures without treating the raw log as permanent context.
  2. Diagnose. Separate missing information from a missing procedure, a harness defect, or a missing model capability.
  3. Propose. Let the self-referential harness revise its workflow, or ask the Diversity Critic for a capability target outside current coverage.
  4. Train. When a weight-level change is justified, create a versioned delta rather than mutate the base model in place.
  5. Validate. Measure the predicted gain, held-out generalization, and regressions under fixed budgets and reproducible configurations.
  6. Accept or revert. Promote only changes that satisfy the external acceptance policy; retain rejected proposals as evidence for later iterations.

The output of a six-month deployment is therefore not a six-month prompt. It is an inspectable collection of artifacts: a compact memory, an evolved harness, a library of validated capability deltas, the evaluations that justified each change, and a record of rejected updates.

Evidence ledger

Demonstrated
Harness-level recursive self-modification can improve task-solving and the optimization procedure itself (Gödel Agent; follow-on evidence from DGM and Hyperagents).
Preliminary
Reversible, mid-trajectory weight deltas can improve deep-research agents while preserving a stable base (WeAct).
Proposed
An agent can autonomously train new deltas and use a Diversity Critic to choose capability targets beyond its current covered region.

Safety boundaries and open questions

Recursive self-improvement is sometimes framed as a demand for fewer constraints. I take the opposite engineering view: a more editable inner system requires a more explicit outer boundary. The goal is not unrestricted self-modification. It is to expose a useful action space while keeping authority, evaluation, and recovery outside that space.

  • Immutable control plane. The agent must not be able to disable its evaluator, expand its own permissions, change its compute budget, or overwrite the recovery path.
  • Versioned modifications. Every harness edit and weight delta needs an identity, parent version, predicted effect, and rollback operation.
  • Independent acceptance tests. The same component that proposes an update should not unilaterally decide that it succeeded.
  • Cumulative regression suites. A new capability is not an improvement if it silently erases previously validated behavior.
  • Bounded deployment. Update frequency, data access, tool authority, and target domains should be governed by an external policy.

Several research questions remain open. How should a system distinguish a retrieval problem from a capability problem? When do multiple deltas compose cleanly, and when do they interfere? What representation measures meaningful novelty rather than surface difference? How much evidence is required before an update persists across users or deployments? And how should operators inspect an evolved harness once its structure no longer resembles the human-written seed?

The central evaluation should be longitudinal. A self-improving agent should face a stream whose capability targets shift over time, while a fixed held-out suite measures whether useful coverage grows without unacceptable regressions. Short benchmark gains are necessary evidence, but they do not test the claim that motivates the architecture: that an agent can become a more capable collaborator after release.

Conclusion

Persistent agents need a path from experience to capability. Memory and retrieval preserve what happened; self-modification changes what the agent can do with it. The four-level taxonomy identifies where that change can occur, from output search to harness updates, editable optimizers, and bounded weight actions.

My position is deliberately conditional. Recursive self-improvement is not achieved by granting arbitrary write access to an agent's code or weights. It requires three pieces at once: enough freedom to improve the learning process, an update representation that is reversible and auditable, and an exploration mechanism that selects capabilities the current system does not already cover. Gödel Agent provides evidence for the first piece. WeAct is an ongoing attempt at the second. The Diversity Critic defines the proposed third piece. Building and evaluating the full loop is the work ahead.

References

  1. Novikov et al. (2025). AlphaEvolve: A Coding Agent for Scientific and Algorithmic Discovery.
  2. Tang et al. (2025). ChemAgent: Self-updating Memories in Large Language Models Improves Chemical Reasoning. ICLR 2025.
  3. Yin et al. (2025). Gödel Agent: A Self-Referential Agent Framework for Recursively Self-Improvement. ACL 2025.
  4. Zhang et al. (2026). Darwin Gödel Machine: Open-Ended Evolution of Self-Improving Agents. ICLR 2026.
  5. Zhang et al. (2026). Hyperagents.
  6. Yin et al. (2024). Benchmarking Knowledge Boundary for Large Language Models. ACL 2024.
  7. Yin et al. (2023). ALCUNA: Large Language Models Meet New Knowledge. EMNLP 2023.
  8. Yin et al. (2024). History Matters: Temporal Knowledge Editing in Large Language Model. AAAI 2024.
  9. Mialon et al. (2023). GAIA: A Benchmark for General AI Assistants. ICLR 2024.
  10. Wei et al. (2025). BrowseComp: A Simple Yet Challenging Benchmark for Browsing Agents.
  11. Cheng et al. (2025). Atomic Skills are the Prerequisite: When Reinforcement Learning Synthesizes Compositional Reasoning, and When It Only Amplifies.
  12. Zhou et al. (2026). The Geometry of Reasoning: Flowing Logics in Representation Space. ICLR 2026.