Meta^n stacks agent layers with a frozen improver and hits 0.331 on ARC-AGI-2

Four researchers at the University of Minnesota and Seoul National University have published Meta^n, a self-improving agent architecture built on an unusual constraint: the improver never changes. A single fixed, LLM-prompted meta-operation — called Ω — is applied over and over to its own outputs, stacking solver layers until it stops finding improvements. On ARC-AGI-2, the benchmark built to resist skill memorization, the resulting stack scores 0.331 where the two prior self-improving agents it is compared against sit at 0.003 and 0.054; on ARC-AGI-2's held-out split, the authors report Meta^n is the only system to solve any task at all.

The paper is by Zae Myung Kim, Young-Jun Lee, Seungyeon Jwa and Dongyeop Kang, with code released under MIT at minnesotanlp/meta-n.

#The dilemma it is trying to dissolve

The authors' framing is the interesting part. Today's self-improving agents, they argue, refine answers rather than the process that produces answers. Systems like FunSearch, AlphaEvolve and ADAS put a fixed evolution loop outside the solver — the solver improves, the improver does not, so realized meta-depth is 1. Self-editing agents like Gödel Agent and DGM go further but must freeze some driver component (Gödel Agent's action API, DGM's archive maintenance) to avoid corrupting themselves, which the paper scores as a realized meta-depth of about 2.5.

Figure 2: the two existing paradigms and where Meta^n places itself. Credit: Kim et al., arXiv:2608.24735.

Meta^n's move is to freeze the improver by design and recurse on its input instead. Ω's prompt is roughly "given the full execution context of the system below you, write code that improves it." Each call reads the traces of the solver stack beneath it and — from depth 3 upward — the code that produced those traces, then emits two things: a short Python pre-process that injects strategic context before each solver call, and a small library of callable helper functions. Because Ω itself never mutates, it cannot destabilize the system; because its input strictly grows, each layer reasons from a higher vantage point than the last.

Figure 1: the recursive stack (left) and search progress against Gödel Agent and OpenEvolve on LawBench (right). Credit: Kim et al., arXiv:2608.24735.

The paper's clearest illustration: on CO-Bench's assignment_problem, a single LLM call writes a script importing scipy.optimize, the sandbox has no scipy, the task scores 0.0, and a flat refinement loop keeps retrying variants of the same import. Meta^n's depth-2 Ω, looking at all 36 tasks at once, notices the shared dependency failure and emits "do not use scipy" plus a validate_output() helper. The depth-2 solver reimplements the Hungarian algorithm and scores 1.0.

#Results

Two backbones — Gemma 4 31B-IT and GPT-5.2 — across eight benchmark families, three seeds each. Under GPT-5.2:

The margins are honest about where they are thin. On Symptom2Disease — a 22-label prompt-rewrite task — Meta^n's lead is +0.013 to +0.025 with overlapping per-seed ranges, and the authors explicitly do not claim significance. On AlgoTune the agentic variant underperforms its own single-shot sibling (×14.11 vs ×18.47 on one seed), because Ω's extra context over-constrains an already-optimized kernel contract.

#The ablation is the finding

Stripping recursion while leaving the orchestration intact drops CO-Bench archive-best validation from 0.845 to 0.714 on Gemma (−0.131), and reproduces at −0.080 on GPT-5.2 CO-Bench and −0.158 on GPT-5.2 AlphaEvolve Math. But the component breakdown locates the gain somewhere unglamorous: removing the inter-layer context string alone costs −0.094, accounting for roughly 72% of what recursion buys. The callable code library — the part that looks like real engineering — accounts for about 15%, and the search machinery for the remaining 13%.

The other reported emergent behavior: layer roles differentiate with depth although no prompt prescribes them. Rollback is exactly zero at depth 2 under both LLM raters, then appears at depth 3 (55% of emissions on code substrates) — a corrective role that cannot exist until there is something to correct. Inter-rater agreement is Cohen's κ = 0.59, weakest on the most abstract role categories.

#Caveats

This is an unrefereed preprint. The same model sits at the base solver and at every Ω call, which is the right control for separating depth gains from capability gains but leaves the obvious deployment case — a strong improver over a weak base — untested. Depth is not unbounded in practice: runs halt between depth 3 and depth 6 because Ω stops finding improvements. And it is not cheap — roughly $632 per Meta^n seed on ARC-AGI-2, ~3 hours for a single-shot CO-Bench run and ~10 hours agentic, ~28 hours for the 89-task TerminalBench 2.0 run.