PaperlayerView exact revision on arXiv

Source-linked AI summary

Meta$^n$: Recursive Self-Improvement through Emergent Depth

Zae Myung Kim, Young-Jun Lee, Seungyeon Jwa, Dongyeop Kang

arXiv:2608.24735v1cs.AIcs.CLeess.SY

TL;DR

Self-improving LLM agents generally improve answers without improving the process that produces them, while fixed drivers limit recursive meta-depth. Meta^n repeatedly applies a fixed meta-operation to traces and code from lower layers, and it outperforms prior self-improving agents across eight benchmark families and two backbones, with the clearest result on ARC-AGI-2.

  • Problem

    Existing self-improving LLM agents refine answers rather than the process producing them, while fixed drivers constrain realized meta-depth.

  • Method

    Meta^n recursively reapplies a fixed meta-operation Ω to lower-layer traces and code, building layers until Ω stops finding improvements.

  • Results

    Across eight benchmark families and two backbones, Meta^n outperforms prior self-improving agents on every benchmark family; on ARC-AGI-2, it alone solves any held-out task.

  • Takeaways & Limitations

    Most of recursion’s lift comes from passed conditioning between layers, while distinct layer roles emerge without prompts prescribing them.

  • Takeaways & Limitations

    The study uses the same model as base solver and improver, leaving deployment with a stronger improver over a weaker base untested.

Abstract

from arXiv · show

Self-improving LLM agents refine answers, not the process that produces those answers. Systems that add a meta-level hold that level fixed, and those that edit themselves must leave part of their own editing machinery untouched to stay stable, capping the meta-depth they realize at roughly two. We present Meta$^n$, which keeps the meta-operation fixed and recurses on its input instead. That operation, $Ω$, is applied repeatedly to its own products, reading the traces of the solver stack below together with the code that produced them, then writing the next layer as a strategic pre-process and a library of callable helpers. Because $Ω$ never changes, it cannot destabilize the system, and because its input strictly grows, each layer reasons from a higher vantage than the last. Depth is set by convergence rather than fixed in advance, and an evolutionary archive searches over layer chains. Across two backbones, Meta$^n$ outperforms prior self-improving agents on all eight benchmark families. The sharpest case is ARC-AGI-2, built to resist skill memorization, where it alone scores above zero. Ablations indicate that most of the gain from recursion comes from the conditioning each layer passes to the next, and distinct layer roles emerge with depth although no prompt prescribes them. Code available at https://github.com/minnesotanlp/meta-n

1 Introduction

Meta^n addresses the limitation that current self-improving agents refine answers without refining the process that produces them. It recursively reapplies a fixed meta-operation to accumulated traces and code, achieving depth through convergence and improving performance across diverse benchmarks.

  • Existing self-improving LLM agents typically examine, revise, and retry answers without changing the process that improves them.
  • Prior meta-improvement systems either freeze an external meta-process or leave a driver fixed, limiting realized meta-depth.
  • Meta^n repeatedly applies one fixed meta-operation Ω to its own outputs, using lower-level execution traces and the code that produced them.
  • 0.131: removing recursion lowers CO-Bench archive-best validation from 0.845 to 0.714, isolating the reported recursion gain.
  • Each recursive layer can write a strategic pre-process and reusable helper library, then assess whether earlier code should be retained, refined, or overridden.
  • Across eight benchmark families and two backbones, Meta^n outperforms prior self-improving agents on every benchmark family, with largest margins on hard held-out tasks.
  • On ARC-AGI-2’s held-out split, Meta^n is the only evaluated system to solve any task, while OpenEvolve and Gödel Agent solve none.

2 Metan: Evolutionary Meta-Recursion

Meta^n recursively applies one fixed meta-operation to increasingly rich inputs, building layered solver improvements without modifying the improver itself. Its layers combine strategic pre-processing, reusable helpers, recursive conditioning, and convergence- or archive-based orchestration.

  • 2.1 Paradigms of Meta-Improvement: Prior self-improving systems either freeze an external meta-process or leave a driver unmodified, limiting realized meta-depth despite permitting deeper architectures.The paper characterizes this as a stability-versus-depth dilemma.
  • 2.1 Paradigms of Meta-Improvement: Meta^n applies a fixed Ω recursively to traces and previously generated code, so each depth receives strictly richer input without changing the improver.From depth 3 onward, Ω inspects the code stack as well as execution traces.
  • 2.2 The Meta-Layer at Depth d: Ω and M_d: Each meta-layer writes a strategic pre-process and a library of reusable helper functions, then a wrapper composes that layer around the solver below.The build-step runs offline; the run-step executes the completed layer for each task.
  • 2.3 Compositional Recursion: Strategies, Tactics, and What Ω Sees: Recursion expands compositional behavior and gives Ω a richer view of prior decisions, enabling deeper layers to frame contexts that shallower layers fill in.The paper describes these as multiplicative coverage and strictly richer input.
  • 2.3 Compositional Recursion: Strategies, Tactics, and What Ω Sees: Deeper layers can interfere with useful guidance, but Ω can diagnose regressions from traces and code, roll back harmful directives, and retain beneficial helpers.In the LawBench example, depth 3 regresses the score from 0.807 to 0.773, while depth 4 recovers to 0.833.
  • 2.4 Orchestration: Linear and Evolutionary Modes: Depth grows until improvements converge, while evolutionary archive search preserves and explores multiple candidate layer chains instead of relying only on greedy extension.Linear recursion can stop after an unlucky Ω call; the archive variant hedges against that failure mode.

3 Experiments

Across two backbones and eight benchmark families, Metan leads prior self-improving agents, with especially large gains on code and difficult reasoning tasks. Ablations and role analyses attribute these gains to recursion, cross-task transfer, and depth-dependent specialization, while also revealing interference and compute trade-offs.

  • 3.1 Main Results: Metan leads every benchmark family on at least one estimator under both backbones, with large stable wins on code substrates and narrower margins on prompt-rewrite tasks.The CO-Bench margin over OpenEvolve reaches +0.168 on GPT-5.2, while LawBench separates by +0.040 over Gödel Agent.
  • 3.1 Main Results: 0.331 is Metan’s ARC-AGI-2 dev score, versus 0.123 for its best single chain, while both prior baselines solve none on the held-out split.ARC-AGI-2 is designed to resist skill memorization, separating meta-level abstraction from object-level refinement.
  • 3.1 Main Results: Archive-best exceeds the best single chain by 0.06 to 0.07 on CO-Bench across both backbones, indicating additional value from searching multiple layer chains.On a representative Gemma run, constrained guillotine cutting rises from 0.000 to 0.996 and maximal independent set from 0.000 to 0.908.
  • 3.1 Main Results: Agentic improves archive-best on seven of eight benchmark families, but uses roughly 4 to 10× more tokens and can over-constrain AlgoTune.Its stronger Layer-1 seed also provides richer traces for subsequent meta-layers.
  • 3.3 What Each Depth Learns: Layer roles specialize with depth: generic tactical primitives dominate some depth-2 emissions, specialized libraries dominate 68% of code depth-3 emissions, and regressions emerge at depth 3.The aggregate d2→d3 mean lift is −0.006, with 41% of chain-task pairs strictly regressing at depth 3.

4 Conclusion

Meta^n keeps one meta-operation fixed while recursively expanding its input, allowing the stack to deepen until improvements stop. Across tested benchmarks, it leads broadly, while deployment settings and useful depth remain open questions.

  • Meta^n applies a fixed meta-operation Ω to accumulated traces and code, so each layer receives a strictly larger information set without editing the improver.The stack deepens until Ω stops finding improvements.
  • Across eight benchmark families and two backbones, Meta^n leads every benchmark family on at least one estimator, with the widest margins where failures are diverse.
  • On ARC-AGI-2, Meta^n reaches 0.331 while object-level iteration remains near the floor.The benchmark is designed to resist skill memorization.
  • Approximately 72% of recursion’s lift comes from passed context, versus about 15% from callable code transfer.Roles also emerge across depth without explicit role prompts.
  • The practical deployment case remains untested because the experiments use the same model for the base solver and every Ω invocation.The paper identifies stronger-improver-over-weaker-solver evaluation as a next experiment.
  • Observed runs stop between depth 3 and depth 6 when Ω stops finding improvements, not because reasoning capacity or context capacity is exhausted.

B Related Work

Prior systems improve programs, source code, prompts, or scaffolding while keeping their generating or search mechanism fixed. Meta^n adds recursive meta-layers that modify lower layers, producing hierarchy, convergence-based depth, and emergent specialization.

  • Prior approaches: Single-level self-improvement, evolutionary optimization, and architecture search all keep the mechanism that generates, mutates, or searches fixed.Their critic or evolutionary selection rule is not itself recursively improved.
  • Meta^n: Meta^n stacks meta-layers so each layer generates code that modifies the layer below rather than changing the universal improver itself.
  • Self-reference: Self-referential agents can edit source code, but practical systems leave part of the improvement machinery fixed, limiting realized meta-depth to approximately two.
  • Meta-scaffolding: Meta-scaffolding systems search surrounding infrastructure or evolve prompts, generally operating at one or two levels of abstraction.
  • Meta^n: Its structural reframing yields layered hierarchy, cross-layer reshaping, convergence-based emergent depth, and one Ω prompt template across heterogeneous benchmarks.
  • Meta^n: Realized depths span 2 to 6, with generic primitives, task-aware routing, deeper specialization, and rollback emerging without prescribed roles.

C Experimental Setup Details

The experiments cover heterogeneous benchmarks, model backbones, baselines, evolutionary settings, and cost measurements. Configurations standardize key Ω parameters while allowing benchmark-specific search budgets and reporting choices.

  • Benchmark settings: ARC-AGI-2 runs only under GPT-5.2 with seeds 42/43/44 and approximately $632 per Meta^n seed.
  • Benchmarks: The benchmark suite includes CO-Bench, Symptom2Disease, LawBench, TerminalBench 2.0, AlphaEvolve Math, symbolic regression, and algorithm speedup tasks.CO-Bench has 36 problems; TerminalBench 2.0 has 89 tasks across 13 categories.
  • Benchmark settings: AlphaEvolve Math uses 15 problems for the Gemma single-shot run, 16 for agentic and Meta^n runs, and 10 for the OpenEvolve GPT-5.2 run.The task pool changed as problems were ported into the adapter.
  • Hyperparameters: The Ω prompt template, output schema, ε = 0.02, and α = 0.3 remain fixed across evolutionary benchmark rows, while beam width, branching, and patience vary by benchmark.
  • Solver settings: Single-shot variants allow up to two executor-level retries, whereas agentic variants allow up to 8 observe-then-act turns.Both variants share the same evolutionary hyperparameters.
  • Cost: A CO-Bench single-shot run takes approximately 3 hours and the agentic run approximately 10 hours; the 89-task TB2 agentic run takes approximately 28 hours.Costs are dominated by evaluations or Docker startup rather than Ω calls.
  • Baselines: Gödel Agent and OpenEvolve are run as prior self-improving comparators, with corrected or compute-equalized configurations where required.
  • Ablations: The depth-1 Meta^n ablation uses four runs per seed, seeds 42/43/44, and approximately 870K tokens per seed without a held-out test pass.

D Design Decisions and Rationale

Metan fixes the meta-operation and constrains how generated layers interact with the solver, while using convergence and archive search to control recursion. The design also makes explicit trade-offs around safety, failure-focused traces, depth, and compute.

  • Model consistency: The same LLM is used at the base solver and every Ω invocation, isolating recursion from model heterogeneity.Headline runs use Gemma 4 31B-IT; GPT-5.2 is used for the cross-model study.
  • Isolation: Ω-generated code runs through a non-invasive wrapper that cannot mutate inner solver state, task objects, or earlier libraries except by name override.This design rules out self-corruption bugs in the scaffolding.
  • Safety: Static analysis and isolated smoke tests screen generated code for dangerous imports, blocked attributes, excessive length, and definition-time crashes.The code-length limit is 10,000 characters, and invalid library functions are skipped with a warning.
  • Trace conditioning: A 3:1 failure-to-success trace ratio preserves failure diagnosis while retaining positive exemplars; lower and higher ratios respectively dilute failures or overfit constraints.The ratio was tuned on a 10-task CO-Bench pilot, with 0.75 selected as the smallest ratio preserving positive examples.
  • Archive search: The evolutionary archive separates depth from quality and transfers strategies across candidates, opening per-task headroom beyond any single chain.A depth-2 candidate can outperform a depth-3 candidate.

E Extended Methodology

The extended methodology keeps Ω’s call interface fixed while adapting its trace payload to depth and searching over candidate chains. It also analyzes how emitted layer roles change across 596 emissions using independent annotations.

  • Evolutionary orchestrator: Evolutionary Meta-Recursion maintains an archive of chain-and-score pairs, samples parents, generates children with Ω, and returns the archive’s highest-scoring chain.Parent sampling combines archive performance with an exploration term, while depth and patience constrain the search.
  • Fixed operation: Ω’s system prompt, output schema, and parser remain identical at every depth; only the trace payload adapts to available signal.Each call sees at most 20 traces, with 65% of context reserved for traces and 35% for prior code.
  • Depth-aware inputs: At depth 2, Ω receives per-task traces containing generated code, truncated stdout/stderr, exit codes, error summaries, evaluator feedback, and baseline-comparison flags.The payload marks tasks as improved or regressed relative to the baseline.
  • Depth-aware inputs: At depths 3 and above, raw traces become structured summaries of task performance, failure patterns, prior-layer effectiveness, and representative traces.Evolutionary mode additionally supplies archive-best results for regressed tasks as an explicit improvement ceiling.
  • Role analysis: Across 596 Ω emissions, two independent raters classify layer roles into categories such as environment constraints, tactical primitives, routing, and specialized libraries.An emission may receive multiple categories, so within-depth fractions need not sum to 100%.
  • Role analysis: The depth-emergence and code-versus-text patterns reproduce under either rater, although agreement is weakest for the two most abstract roles.Agreement is near-perfect for syntactic cues such as task routing and prompt engineering.

F Depth 2 Injected Code (Full)

A depth-2 Ω layer converts recurring failure traces into strategic preprocessing and reusable helpers. In the pilot example, it replaces an unavailable dependency with an implementation constraint and improves aggregate performance.

  • Injected preprocessing: The generated depth-2 preprocessing code prohibits scipy and third-party libraries except numpy, requiring optimization algorithms to be implemented from scratch.It also addresses timeout patterns by recommending more efficient algorithmic strategies.
  • Pilot result: A single failure-driven code layer raises mean score from 0.439 to 0.513, a +16.9% relative improvement across 4 of 10 tasks.The improvement comes from preventing the most common failure mode in the pilot.

G Consolidation Guard: Study and Control

Consolidation protects already-solved tasks from regressions caused by deeper routing layers. In the CO-Bench study, it improves the per-task-best trajectory over a compute-matched control while enforcing monotonicity.

  • Motivation: Deeper layers can regress individual tasks when a depth-3 router misfires and overrides effective depth-2 guidance.Consolidation prevents this by preserving the archive’s frozen best traces for non-focus tasks.
  • Study: Consolidation raises the 8-task CO-Bench per-task-best mean from 0.502 to 0.71 ± 0.02 with zero regressions on all 8 tasks.The study uses 3 seeds.
  • Control comparison: +0.10 mean lift over a compute-matched control has a 95% confidence interval of [+0.04, +0.16].The control reaches 0.61 ± 0.03 through best-of-4 seed resampling under the standard orchestrator.
  • Guarantee: Consolidation is monotone by construction, so it cannot regress an already-solved task even when deeper routing misfires.The authors emphasize this trajectory shape alongside the positive mean-lift comparison.

H Symbolic Regression Per-Domain Breakdown

The Symbolic Regression breakdown shows domain-specific variation across Gemma runs, while Metan leads every domain under GPT-5.2 against both baselines.

  • Under GPT-5.2, Metan leads every Symbolic Regression domain against both baselines.The comparison uses agentic archive-best results averaged over seeds 42/43/44.
  • On Gemma, single-shot wins archive-best on chem_react and phys_osc, while agentic wins bio_pop_growth, matsci, and the family mean.The stronger seeds in chem_react and phys_osc leave limited headroom for further improvement.
  • Gödel Agent’s large standard deviations include chem_react at 2.92 ± 3.84, reflecting seed-level solver collapses after single self-modifications regress performance.

I AlgoTune Per-Task Breakdown

The AlgoTune per-task breakdown reveals that agentic recursion underperforms single-shot on several tasks, with the largest losses concentrated in two FFT kernels and aggregate coverage differing across variants.

  • 11.08 of the 17.55 total speedup lost across seven shared tasks comes from the two FFT kernels.The inversion is largest on those kernels in the per-task comparison.
  • Agentic speedup falls from 5.54 to 3.74 on psd_cone_projection and from 2.00 to 1.05 on affine_transform_2d.
  • The remaining three shared tasks are near parity between the variants.
  • Single-shot aggregate speedup is ×18.47 across seven tasks, whereas agentic aggregate speedup is ×14.11 across eight tasks and ×15.96 on the matched seven.eigenvectors_complex has a per-task log only in the agentic run, where its speedup is ×1.11.

J Gödel Agent Baseline Details

The Gödel Agent baseline is highly sensitive to its harness and budget: its published interface collapses on heterogeneous CO-Bench tasks, while increased search budget yields only limited gains.

  • ∼0.000 archive-best performance on both backbones results when Gödel Agent’s published harness supplies one generic solver without per-instance solve().The collapse reproduces exactly across seeds and is attributed to the interface rather than the model.
  • 5× and 10× larger GPT-5.2 per-task GA budgets raise CO-Bench held-out test scores from 0.502 to 0.615 and 0.628.Token spend rises to 5.6M and 11.4M per seed, respectively.
  • At 17M tokens, Metan reaches 0.870 on CO-Bench, while GA’s per-iteration curve oscillates between 0.4 and 0.6 without an upward trend toward it.
  • Gödel Agent invokes self-modification intermittently across benchmarks and produces byte-identical solver snapshots across all seven AlgoTune iterations.The action is invoked four times on Symptom2Disease, six times on LawBench, once on AlphaEvolve Math, once on CO-Bench, and zero times on AlgoTune.
Loading 2608.24735v1…