Recursive self-improvement is a self-fulfilling cycle where an intelligent system autonomously rewrites its own code and architecture. Once the system exceeds a certain level of intelligence, that improvement accelerates beyond the imaginable.
Our system applies the same improvement cycle at the code layer while keeping intelligence fixed and code deployment gated by human review and/or controls.
The pattern, stated generally
Provide AI with a measurable objective and time to improve. Build an evaluation that scores progress. Let an improvement engine propose changes and test experiments against each other. This can be applied to developing language models, as Andrej Karpathy's autoresearch showed, or to the code with CodeEvolver.
In both improvement cycles, the system keeps winners, discards losers, and iterates until progress plateaus. That loop doesn't care whether the thing being mutated is a prompt, an agent, a rules engine, or a language model. It cares only that the objective is measurable.
Why AI applications first
Three reasons. The gap between typical and optimal is enormous — months of manual tuning still leaves 30%+ relative improvement on the table, which is rarely true of mature classical software. The change surface is language-shaped, which today's coding agents handle well. And evaluation infrastructure is already becoming standard practice in AI engineering, so the precondition for optimization — a system that can be scored — increasingly exists.
What changes as models improve
Each model generation expands what the engine can safely mutate: from instructions, to pipeline code, to module architecture, toward whole-system design. Counterintuitively, better models make optimization more valuable, not less — every model release reshuffles what the optimal system looks like, and the re-optimization that follows is exactly the work nobody wants to redo by hand.
The destination: improvement as infrastructure. Not a sprint your team runs when quality complaints pile up, but a standing process — like CI for correctness or observability for uptime — that holds your software near its optimum as everything around it shifts. AI applications are the beachhead. Software with a measurable objective is the market.