A fixed meta-operation that recurses on its input, not itself, is the key insight

Most self-improving agents fix a ceiling for themselves without knowing it. They refine answers, not the process that produces answers, and the systems that do add a meta-level freeze the meta-mechanism to stay stable. Meta^n identifies this as the core dilemma and sidesteps it by keeping a single meta-operation fixed while recursing on its input instead of on itself.

The operation reads the full execution traces of the solver stack below, plus the code that generated those traces, then writes the next layer as a strategic pre-process and a library of callable helpers. Because the operation never changes, it cannot corrupt the system. Because its input grows strictly with each application, each layer reasons from a higher vantage than the last. Depth is not set in advance; the stack grows until the operation stops finding improvements.

The worked example in the paper is clarifying. A flat self-refinement loop, seeing only traces, repeatedly retries the same broken import. Meta^n's second layer, looking across all tasks simultaneously, notices a pattern of dependency failures and emits a helper that sidesteps the missing library entirely. A third layer then sees both the new traces and the code that produced them, so it can distinguish a bad directive from a sound helper and roll back only the former. That rollback behavior is the paper's sharpest empirical signal: it is exactly zero at depth two and appears only once a layer has something to correct.

Ablations locate where the gain actually lives. Inter-layer conditioning, a string of strategic context passed between layers, accounts for the majority of the lift over a depth-one baseline. Callable code transfer accounts for most of the remainder. The recursion machinery itself contributes a smaller share. This is a useful decomposition: the expensive-looking mechanism turns out to be mostly doing information routing.

The ARC-AGI-2 result is the hardest to dismiss. That benchmark was designed to resist skill memorization, and both comparison systems score near zero on its held-out split. Meta^n is the only system to solve any tasks at all. On benchmarks with many orthogonal failure modes, the cross-task code library compounds into the largest margins; on benchmarks with a narrow action surface, like single-prompt classification, the margins shrink to within seed noise.

Two honest caveats emerge from the paper itself. AlgoTune is the over-constraint case: a pre-optimized kernel contract leaves little headroom, and the extra context tightens rather than improves the code. And the entire evaluation uses the same model at every layer, which is the right control for isolating depth gains but leaves the practical deployment case, a stronger model sitting above a weaker base, untested.