What if an AI could evolve its own goals mid-search — converting plain-language targets into runnable code to score each new attempt?

This explores how turning a plain-language goal into runnable code lets an agent rewrite what it's optimizing for mid-search, rather than treating the objective as a fixed input. The clearest answer in the corpus comes from SAGA's bi-level design Can agents evolve their own objectives during search?: an outer LLM loop proposes new objectives in natural language and *compiles them into a scoring function* the inner optimization loop can use immediately. The compilation step is what makes evolution possible — a goal expressed as prose can't score candidates, but a goal expressed as executable code can, so the results of one round of optimization become evidence the outer loop uses to redraft the objective for the next round. Goal design stops being a one-time human input and becomes part of the discovery loop.

Why code specifically? Because language is generative but not directly measurable, and executable functions are measurable but not easily reimagined. Compositional language lets an agent *imagine* goals it has never seen by recombining familiar concepts Can language help agents imagine goals they've never seen? — that's the proposal half. Compiling to code closes the gap between an imagined goal and a testable one. This mirrors a broader finding that tools (and code is a tool) provably expand what a model can reason about, unlocking strategies that are impossible or hopelessly verbose in pure text Do tools actually expand what language models can reason about?. An objective you can only describe is inert; an objective you can execute can be scored, compared, and mutated.

The deeper reason this matters is that self-improvement is bounded by a generation–verification gap: a model can propose fixes endlessly, but every reliable improvement needs something external to check it What stops large language models from improving themselves? What actually constrains large language models from self-improvement?. Compiling goals into code is a way of *manufacturing that external verifier from the goal itself* — the compiled function becomes the ground truth that scores the search, so the loop isn't just the model grading its own homework in prose. The Darwin Gödel Machine makes the same move at the level of whole agents: it abandons formal proofs of improvement in favor of empirical benchmarking against runnable tests, keeping an evolutionary archive of variants Can AI systems improve themselves through trial and error?. Executable objectives are what let 'did this actually get better?' be answered by running something instead of arguing about it.

There's a useful way to place this in the landscape of self-improving agents, which tend to split into a slow parametric loop that rewrites model weights and a fast non-parametric loop that rewrites prompts, memory, and tools Do self-improving agents really split into two distinct loops?. Evolving compiled objectives lives in that fast loop — cheap and reversible, because rewriting a scoring function is far less costly than retraining. It connects to the view of language agents as optimizable computational graphs, where the structure being tuned is code you can edit and rewire, not weights you have to relearn Can we automatically optimize both prompts and agent coordination?.

The caveat worth carrying away: compiling a goal into code guarantees it's *executable*, not that it's *right*. A scoring function can be run, optimized against, and still point at the wrong thing — symbolic goal encoding without contact with the real world can drift between what you stated and what actually matters Can AI systems achieve real alignment without world contact?. Objective evolution buys you a search that can rewrite its own target; it doesn't buy you a search that knows the target is worth reaching.