Can an agent rewrite its own modification algorithm during runtime?

Gödel Agent proposes a three-tier taxonomy of agent design freedom and places itself at the top tier. "Hand-Designed Agent" systems follow "the same policy π all the time, regardless of environmental feedback"; "Meta-Learning Optimized Agent" systems update that policy "based on a meta-learning algorithm I... at training time," but the meta-algorithm I itself "remains unchanged once deployed." Gödel Agent instead lets the agent "freely decide its own routine, modules, and even the way to update them," updating both the policy and the updater together each step: (πt, It) becomes (πt+1, It+1). The paper calls this self-reference — "the property of a system that can analyze and modify its own code, including the parts responsible for the analysis and modification processes" — and places it as the "highest degree of freedom" in its design-space figure, inspired by Schmidhuber's Gödel machine.

Mechanically, the agent's main loop is a recursive function rather than a fixed loop, in which an LLM decision function chooses among four actions: self_inspect (read its own current code from runtime memory), interact (call the environment's utility function U to score the current policy), self_update (have an LLM rewrite (π, I)), and continue_improve (recurse if no other action applies). The implementation achieves self-awareness and self-modification through "monkey patching" — reading and overwriting Python's own runtime memory — so the agent rewrites its running code during the loop that is rewriting it, guided "solely by high-level objectives through prompting," with no predefined routine or fixed optimization algorithm constraining the search.

This is a concrete, code-level instance of the first dial in What separates self-improvement from policy improvement?: Gödel Agent not only puts the improver I inside the agent, it makes I itself a target of self_update, so the dial's inside/outside boundary collapses into one self-modifiable object. The standard it is judged against, the utility function U, stays external and fixed — by the second dial this reads as "anchored," despite the paper's own label "self-referential." Against Do self-improving agents really split into two distinct loops?, it sits in the fast, non-parametric loop — fine-tuning its own LLM modules is named future work, not current behavior — but extends that loop's scope from prompts, memory and tools to the update algorithm itself. Can AI systems improve themselves through trial and error? is the later, named successor in the same Gödel-machine lineage: where Gödel Agent runs one recursive self-modification trajectory, DGM replaces that single trajectory with an evolutionary archive of variants validated empirically on benchmarks.

The excerpt gives no figures comparable to DGM's measured SWE-bench and Polyglot jumps — only that results "demonstrate... significant performance gain... surpassing various widely-used agents," unquantified here. The paper's own Limitations and Discussion sections flag the rest: it does not compare against the most engineered existing systems (OpenDevin is named explicitly as out of scope); it does not find "the exact point at which the agent can no longer comprehend and improve itself" as self-generated complexity grows, citing Yampolskiy (2015); and its Safety Considerations section argues, rather than demonstrates, that "fully self-modifying agents will require human oversight and regulation" as capability increases. At this strength the excerpt establishes feasibility of one self-referential, code-level loop, not a measured advantage over harder baselines or an account of when self-reference breaks down.