iCoder-27B: Recursive AI-Led Development of Frontier Industrial Coding Model

Cheng Yang; Jiayang Lyu; Shangyuan Liu; Guibin Zhang; Jiong Lin; Xinlei Yu; Junchi Yan; Shuicheng Yan

cs.AIAug 28, 2026

iCoder-27B: Recursive AI-Led Development of Frontier Industrial Coding Model

Authors: Cheng Yang, Jiayang Lyu, Shangyuan Liu, Guibin Zhang, Jiong Lin, Xinlei Yu, Junchi Yan, Shuicheng Yan,

Organizations: School of Artificial Intelligence, Shanghai Jiao Tong University · National University of Singapore

Abstract

Recursive AI, the prospect of AI taking an increasingly complete role in building and improving AI, is a crown jewel of AI for AI. Although recursive self-development has become practical for small models, bounded tasks, and fixed time budgets, a more consequential realization of this ambition, i.e., developing a release-ready, frontier-competitive model, remains far more challenging. In this work, we ask how little human involvement is sufficient for an agent to develop a frontier model. We concentrate human input into a high-density, low-frequency interface: experts encode objectives, stage scaffolds, permission boundaries, and operating procedures as reusable research skills, while the agent instantiates these priors, selects experiments, diagnoses outcomes, and revises the training strategy. In the challenging domain of industrial coding, the agent evolves data and coordinates SFT, on-policy self-distillation, and reinforcement learning with verifiable rewards, ultimately producing iCoder, a 27B model for RTL design and GPU kernel optimization. Across seven benchmarks, iCoder leads RTLLM, outperforming GPT-5.5 and Claude-Opus-4.8; ranks second on CVDP and KernelBench L2, exceeding GPT-5.5 by 16 points; and ties Claude-Opus-4.8 for the best TritonBench result. Exploratory case studies further show iCoder's competitive iterative RTL and GPU-kernel optimization with substantially fewer tokens. These results chart an engineering path toward recursive self-improvement, in which humans distill the principles of model building, agents operationalize them through evidence-driven experimentation, and each generation of AI becomes a more capable architect of the next.

Figures & tables

Figure 2: Overview of our human-guided self-evolving training framework. Research skills are distilled into model-training SOPs, resource permissions, and module-level operations, providing low-frequency human guidance at high-leverage decisions. The agent then autonomously iterates through data evolution, SFT, OPSD, and RLVR to close remaining capability gaps and produce the frontier model, iCoder-27B.

Prior layer	Human-specified content	Boundary on agent action
Objective and scaffold	Target capability, completion criteria, and the Data–SFT–OPSD–RLVR stage roles	May select experiments and transitions, but may not silently redefine the deliverable.
Skill excerpt — stage controller data $\longrightarrow$ SFT $\longrightarrow$ OPSD $\longrightarrow$ RLVR $\hookleftarrow$ returning to data is normal
[1.2pt/1.5pt] Resource access	Approved repositories, models, data, launchers, compute, storage, and external-side-effect permissions	May use registered capabilities within budget; new identities or permissions require a human gate.
[1.2pt/1.5pt] Verification	Task-contract schema, official-harness requirement, integrity checks, and pass/fail/unjudged semantics	May integrate and audit a verifier profile; may not weaken or replace the approved correctness criterion.
[1.2pt/1.5pt] Research method	Controlled pilots, explicit baselines, artifact lineage, stop rules, and regression-aware checkpoint selection	May formulate hypotheses and choose the next discriminating test; conclusions must cite registered evidence.
[1.2pt/1.5pt] Governance and memory	Task Queue, experiment log, decision records, and approval boundaries	May write run-scoped findings and negative results; the released Human Prior remains immutable during the run.

Table 1: Scope of the human prior. Research Skills specify reusable procedures and non-negotiable boundaries while leaving empirical choices to the agent. Run-specific identities and measured findings are recorded separately in the project state.

Skill component	Exposed primitives and invariants	Agent decision space
Task contract	Specification, generated-artifact boundary, interface, reference status, and task-native harness	Normalize each seed and determine whether its current oracle is usable.
Condensed executable rule — item contract item $:=$ instruction $+$ reference solution $+$ verifier require all three parts to agree
[1.2pt/1.5pt] Evolution operators	Behavior-preserving rewriting and reconstruction; contract-bound behavioral mutation	Select an operator per seed and revise the operator library from pilot failures.
Skill excerpt — solution-first evolution mutate reference solution $\rightarrow$ derive instruction $\rightarrow$ generate verifier from the same mutation
[1.2pt/1.5pt] Generation roles	Separate proposal, implementation, specification, and audit roles	Decide when a teacher-generated candidate can become a verified reference.
[1.2pt/1.5pt] Admission gates	Interface preservation, leakage checks, semantic-change tests, solvability, compilation, and execution	Order cheap and expensive gates, classify failures, and allocate retries.

Table 2: Data Research Skill exposed to the agent. The Skill supplies executable primitives and admission invariants, while transformation and corpus-composition choices remain evidence-driven.

Figure 3: Verifier-guided construction of the shared executable task pool. The agent normalizes RTL and GPU-kernel seeds into a common item contract, selects among three evolution routes to form candidate task–oracle pairs, and applies ordered task-native validation gates. Failures update routing and retry decisions; admitted items are deduplicated and balanced before stage-specific rescreening for SFT, OPSD, and RLVR.

Skill component	Exposed primitives and invariants	Agent decision space
Format contract	Prompt template, response boundary, extraction, tokenizer, and loss mask	Audit compatibility and reject format changes that invalidate comparison.
[1.2pt/1.5pt] Capability-gap filter	Repeated student and teacher sampling with task-native verification	Choose sampling budgets and the failure/success predicate defining the subset.
Condensed executable rule — model-relative filtering student trials $\leftarrow$ sample(student, task) subset $\leftarrow$ select(gap-predicate(student trials))
[1.2pt/1.5pt] Verified target	Complete teacher trajectory retained only after an executable pass	Select among passing trajectories and record uncovered tasks.
Condensed executable rule — target admission candidates $\leftarrow$ sample(teacher, task) retain $y$ only if verifier $(y)=$ pass; log uncovered tasks
[1.2pt/1.5pt] Training integrity	Length audit, no-truncation rule, production-path smoke test, checkpoint and telemetry requirements	Choose sequence budget, parallel layout, batch configuration, and save cadence.

Table 3: SFT Research Skill exposed to the agent. The prior fixes data and training integrity requirements but leaves the model-relative curriculum, scale, and stopping decision to experiment.

Skill component	Exposed primitives and invariants	Agent decision space
Target and data	Named measured weakness, repeated sampling, execution-feedback loop, and recoverability evidence	Define the eligibility predicate and rescreen it under the current checkpoint.
Condensed executable rule — entry contract require named weakness $+$ baseline measurement require teacher advantage relevant to that weakness
[1.2pt/1.5pt] Privileged view	Plan, failed responses, verifier diagnostics, and matched control contexts	Select components, ordering, granularity, and stopping point for $c^{\star}$ .
[1.2pt/1.5pt] Information boundary	No reference answer, code-overlap scan, independent audit, and context integrity	Reject leaking plans and decide whether a component remains admissible.
[1.2pt/1.5pt] Learning signal	Frozen privileged scoring, executable outcome, group baseline, and clipped update family	Decide what determines update direction and how teacher evidence assigns token credit.
Skill excerpt — offline OPSD phases roll out $\rightarrow$ score $\rightarrow$ weight $\rightarrow$ train generation and teacher scoring remain outside the update phase

Table 4: OPSD Research Skill exposed to the agent. The prior defines a verifier-anchored self-distillation family; data eligibility, privileged evidence, and the learning rule are selected through controlled tests.

(a) Candidate contexts and final composition
Context view	Information beyond the task prompt	Disposition
Bare context $c_{\varnothing}$	None; the model receives only the task prompt.	Reference
[1.2pt/1.5pt] Direction-only plan $c_{\mathrm{plan}}$	A task-specific repair direction; code, assignments, constants, and answer-specific mappings are prohibited.	Include plan
[1.2pt/1.5pt] Generic domain hint	Task-independent domain advice without evidence from the current attempt.	Exclude
[1.2pt/1.5pt] Error-conditioned experience	A failed response paired with its diagnostic verifier output.	Include signal
[1.2pt/1.5pt] Coarse experience $c_{\mathrm{coarse}}$	Failed responses plus verifier stage or mismatch rate and a general repair checklist.	Include

Table 5: Privileged-context construction and matched ablations. Panel (a) summarizes all context variants considered by the agent and the resulting composition of

c^{\star}

. Panel (b) reports controlled comparisons for plan guidance, verifier diagnostics, feedback granularity, and task–context matching. Each comparison uses its own matched evaluation set and should be interpreted within the corresponding row.

Benchmark	Metric	SFT	B0	B1	B2
VerilogEval	Spec-to-RTL avg@4	73.88	57.37	79.33	84.70
VerilogEval	Code-complete avg@4	81.73	56.09	79.97	81.90
RTLLM	Functional avg@4	60.50	40.50	59.00	61.20
RTLLM	Syntax avg@4	83.50	61.50	79.50	92.50
ArchXBench	Functional pass@1	22.54	11.27	23.94	36.60
ArchXBench	Syntax pass@1	59.15	29.58	60.56	67.61

Table 6: Controlled comparison of OPSD objectives from the same SFT checkpoint under matched data and training budget. B0 uses the teacher gap as the update direction, B1 uses verifier outcome alone, and B2 augments the B1 outcome direction with bounded teacher-based token credit. Higher is better. The best result in each row is bold and the second-best distinct result is underlined. N/A denotes an unavailable SFT measurement.

Skill component	Exposed primitives and invariants	Agent decision space
Executable verdict	Task-property contract, official harness profile, positive-pass evidence, and pass/fail/unjudged record	Integrate profiles and decide when integrity is sufficient for online use.
[1.2pt/1.5pt] Reward eligibility	Candidate-independent failure attribution and task-scoped exploit detectors	Identify reward exploits and determine where each hard gate applies.
Condensed executable rule — exploit gate if exploit detected: reward $\leftarrow 0$ else: reward $\leftarrow$ task adapter(raw verdict)
[1.2pt/1.5pt] Reward adapter	Versioned mapping from judged evidence to binary or graded scalar rewards	Decide whether meaningful partial or performance ordering exists for a task family.
[1.2pt/1.5pt] Missing supervision	Closed infrastructure taxonomy, bounded retry, sentinel, and masking contract	Classify failures, set stop thresholds, and prevent system faults from becoming gradients.
Condensed executable rule — unjudged contract unjudged $\rightarrow$ sentinel outside the legitimate reward range exclude from group statistics; set $A=0$ ; normalize by valid count

Table 7: RLVR Research Skill exposed to the agent. Raw executable verdicts remain stable, while eligibility, reward adaptation, and optimization are revised only through registered experiments.

Observed signal	Diagnosis	Retained intervention	Role in RLVR
Kernel-specific reward validity
Correct output without genuine kernel computation	Surface correctness could be achieved without performing the specified task.	Converted launch, identity, and scoped delegation checks into hard eligibility gates.	Prevent reward exploitation.
[1.2pt/1.5pt] Genuine KernelBench speedups rejected	A uniform delegation rule contradicted the benchmark’s task definition.	Restricted delegation gating to backends that prohibit framework computation.	Preserve valid partial replacements.
RTL-specific behavioral validity
Testbench exited without an explicit positive verdict	Absence of a failure message was being interpreted as functional correctness.	Required an explicit pass signal and otherwise failed closed.	Prevent false-positive RTL rewards.
[1.2pt/1.5pt] Harness failed before evaluating the candidate	Missing payloads or mismatched toolchains contained no evidence about policy quality.	Routed enumerated pre-candidate failures to retry and the unjudgeable sentinel.	Prevent verifier faults from becoming RTL supervision.

Table 8: Failure-driven refinement of RLVR across kernel and RTL tasks. Each row links an observation available to the agent to its diagnosis and the intervention retained for the final training run. Absolute rewards are compared only within rollout groups for the same task. Verifier implementation details are reported separately in Appendix A.2 .

Figure 4: Overview of training pipeline. The shared executable task pool supports three successive parameter-update stages. SFT builds a capability-gap corpus from the first verified teacher trajectory; OPSD transfers privileged experimental context to a bare-context student through verifier-signed token credit; and RLVR converts online execution outcomes into domain-aware rewards while masking unresolved trajectories. The task-native verifier changes roles across stages, from correctness checking, to feedback construction, to failure diagnosis and reward assignment, yielding iCoder-27B.

Stage	Training unit	Total	RTL	Kernel
SFT	Verified teacher trajectory	28,952	18,256 (63.0%)	10,696 (37.0%)
OPSD	Recoverable executable task	1,874	1,349 (72.0%)	525 (28.0%)
RLVR	Stratified verified task	13,212	6,058 (45.8%)	7,154 (54.2%)

Table 9: Post-training data by stage. SFT counts complete verified teacher trajectories, OPSD counts recoverable executable tasks, and RLVR counts stratified verified tasks.

Benchmark	Metric	iCoder 27B	Qwen3.6 27B	InCoder 32B	InCoder-32B Thinking	DeepSeek V4-Pro	GLM 5.2	Kimi K2.6	GPT 5.5	Claude Opus-4.8	Hy3	Gemini 3.5-Flash
VerilogEval	Spec-to-RTL avg@4	86.3	70.1	62.5	65.9	69.9	66.0	72.4	90.1	82.7	83.8	89.1
VerilogEval	Code-complete avg@4	86.0	70.8	58.2	54.2	79.8	74.8	78.5	91.4	81.9	81.6	83.8
RTLLM	Functional avg@4	68.0	49.6	48.0	44.2	67.5	64.0	59.0	66.0	64.7	53.5	63.5
CVDP	Functional avg@5 (%)	44.1	33.9	36.9	30.3	38.5	39.5	42.1	39.5	47.7	39.7	29.7
RealBench	Syntax pass@5 (%)	61.7	38.3	60.0	55.0	36.7	43.3	58.3	80.0	83.3	41.7	68.3
RealBench	Functional pass@5 (%)	26.7	16.7	46.7	36.7	16.7	25.0	25.0	28.3	36.7	16.7	26.7

Table 10: Performance comparison on industrial coding benchmarks. The best result in each row is shown in bold, and the second-best distinct result is underlined; ties receive the same formatting.

Figure 5: RLVR training dynamics and outcome. All is the unweighted mean of the six verification backends, and Kernel and RTL the means within each domain; the bold reward curve is an exponential moving average of the per-step values. Shaded bands mark the first epoch and the dashed line the reported checkpoint.

Panel of Figure 6 — Figure 6: Matched trajectories on two validation problems, sampled from the same checkpoints before and after RLVR. The excerpts reproduce model reasoning verbatim, and RTL verdicts come from the benchmark testbench.

Figure 7: Evaluation-driven RTL search on eight designs adapted from RTLScout. Translucent points show every testbench-valid, successfully synthesized candidate retained by the evaluator; the opaque staircase is the cumulative best. Both are expressed as cell-count reduction from that task’s recorded seed, and endpoint icons identify the model. Bold numbers beside the icons give the final synthesized cell counts; each panel reports its baseline cell count along the bottom. Dotted gold references on the 8-bit ALU and MCM $(13,25,63)$ show refreshed iCoder final results whose candidate indices are unavailable. Their horizontal icon positions are visual anchors rather than candidate indices. Elsewhere, the horizontal axis counts valid synthesized candidates, not raw attempts or wall-clock rounds; failures and excluded candidates therefore do not advance it.

Figure 8: Reported cost–quality trade-off and search outcomes for the EDA case study. (a) Mean quality first computes cell-count reduction against the common recorded seed for each task and then averages the eight reductions with equal weight. Output tokens are summed across the recorded calls and serve as a cost proxy rather than monetary cost. (b) Outcome shares use the available candidate logs, retain all generated candidates in the denominator, and show reward-exploit candidates as a separate excluded category; the refreshed final-result metadata does not alter these counts. Runs nominally use 60 proposals per task; one DeepSeek-V4-Pro log contains an additional proposal. iCoder used a 32,768-token output cap, whereas HY3 and DeepSeek-V4-Pro used 131,072.

Figure 9: Evaluation-driven search trajectories for eight GPU operators. Translucent points are distinct generation-indexed candidates that the archive marks as compiled and correctness-valid; exact duplicate records are removed. The opaque staircase is the cumulative best. Every latency is divided into the same task’s archive-designated reference latency, and the dashed line marks the resulting $1\times$ anchor. Endpoint icons identify the model. When endpoints overlap, a short leader connects an offset icon card to its exact point. Candidates without a recorded search-generation identifier do not appear in this plot.

Figure 10: Reported cost–performance trade-off by operator. Each endpoint pairs the run’s total reported output tokens with its best reference-relative speedup. A ray begins at the archive-designated reference implementation $(0,1)$ , so its slope visualizes the descriptive gain per million reported output tokens used for case selection. Tokenizers, output limits, and proposal counts are not matched across models; the horizontal axis is a search-cost proxy, not dollar cost, GPU time, or controlled compute.

Appendix figures & tables5 assets

Supplementary material from the paper’s appendix.

Appendix

Figure 11: Distribution of the shared executable task pool. The left chart shows the RTL–kernel split and the functional-family composition within each domain; the bars below compare cumulative coverage by the largest one, three, and five families. The right tables report the corresponding task counts and within-domain shares.

Benchmark	Tasks	Max tokens	Sampling ( $n$ )	Reported metrics	Verification
VerilogEval Spec-to-RTL	156	49,152	$n=4$ , temp. 0.8	Spec-to-RTL avg@4	Icarus Verilog simulation
VerilogEval Code-complete	156	49,152	$n=4$ , temp. 0.8	Code-complete avg@4	Icarus Verilog simulation
RTLLM	50	49,152	$n=4$ , temp. 0.8	Functional avg@4	Icarus Verilog simulation
CVDP (cid003)	78	49,152	$n=5$ , temp. 0.8	Functional avg@5	Icarus Verilog + cocotb
ArchXBench v1.5	71	49,152	$n=1$ , temp. 0	Functional pass@1	Self-checking testbenches
RealBench-Module	60	49,152	$n=5$ , temp. 0.8	Syntax/functional pass@5	Verilator build and simulation

Appendix

Table 11: Evaluation infrastructure and benchmark-specific settings.

Operator	Computation	Task origin	Reference implementation (archived latency)	Main display
Vector Sum	Full reduction over all vector elements	In-house	torch.sum ( $135.8\,\mu$ s)	Yes
Cumulative Sum	Row-wise prefix sum along dimension 1	In-house	torch.cumsum ( $333.6\,\mu$ s)	Yes
Causal Conv1D	Left-padded convolution for sequence modeling	In-house	PyTorch conv1d with left padding ( $142.9\,\mu$ s)	Yes
Asymmetric MatMul	Irregular-shape matrix multiplication	In-house	PyTorch matmul / cuBLAS ( $1225.0\,\mu$ s)	Yes
Grayscale Conversion	Weighted RGB-to-luminance transform	In-house	PyTorch weighted tensor sum ( $474.1\,\mu$ s)	Yes
GDNO	Gated Delta-Net block recurrence for linear attention	In-house	PyTorch chunked recurrence ( $198.4\,\mu$ s)	No: HY3 missing

Appendix

Table 12: Operator definitions, task provenance, and archive-designated reference implementations for the full eleven-task case-study archive. The main-text display retains eight tasks under its stated post-hoc rule.

Verification scope	Candidate and trusted context	Native oracle	Required execution evidence
Module-local completion	Candidate completion joined to a trusted module prefix and executed by a fixed harness	Pinned Icarus transcript	Exactly one target module compiles and executes; the transcript matches its trusted profile. Mismatch-reporting tasks additionally require zero mismatches, a positive sample count, and no timeout.
Standalone module	Complete candidate module evaluated beside trusted reference RTL	Reference–candidate trace comparison	Both designs compile under the same generated stimulus, and their output traces agree exactly.
	Complete candidate module with a trusted self-checking harness	Explicit testbench verdict	Simulation reaches a positive verdict and reports no failure; missing positive evidence fails closed.
	Complete candidate module embedded in an allowlisted Icarus/cocotb/pytest harness	Programmatic assertions	Every task-defined assertion completes and the test process exits successfully.
	Complete candidate module with task stimuli, reference-generation scripts, and an output comparator	Task-native golden pipeline	The Makefile-driven generation, compilation, execution, and comparison pipeline completes successfully.
Project-integrated module	Complete candidate module inserted into a protected dependency hierarchy with a trusted reference instance and stimulus generator	Differential project simulation	The Verilator project builds and runs; its normalized transcript matches the pinned trusted profile.

Appendix

Table 13: Implemented RTL verification contracts, ordered by the boundary of the generated artifact. The oracle variants at the standalone-module scope are alternatives selected by the task specification; they do not represent successively larger design scales.

Artifact boundary	Candidate and trusted context	Native oracle	Accepted evidence and measurement
Operator implementation	Candidate device-level operator and a trusted executable reference, run with matched deterministic seeds	Structured numerical equivalence	Output structures and shapes agree and tensor values satisfy the task tolerance. A completed device launch is required; prohibited framework delegation and identity stores invalidate the result.
Reference-model replacement	Candidate replacement module, trusted reference model, and task-defined initialization and input generators	Repeated output equivalence under matched inputs	Correctness is checked across repeated trials. Matched timing against the reference supplies a separate speedup measurement; unchanged framework operators outside the replacement remain admissible.

Appendix

Table 14: Implemented GPU verification contracts. Both compare generated code with trusted reference execution under task-defined inputs, while the admissible implementation boundary and efficiency supervision differ.

Language Model Self-Improvement

Language model self-improvement studies how models use their own outputs, feedback, and experience to improve with less external supervision.

See all 174 papers

Jun 26, 2026

When AI Reviews Its Own Code: Recursive Self-Training Collapse in Code LLMs

Recursive self-training can degrade neural generative models when generated data is reused without fresh human data or external quality control. We study this risk in code LLMs, where AI-generated code can enter real repositories, later become training data, and create a repository-scale self-training loop. While software development traditionally interrupts this loop through pull-request review, tests, compilation, and human approval, AI coding tools now produce code faster than humans can review it, and code review itself is increasingly automated by AI systems. We therefore compare three recursive fine-tuning regimes: no review, human-style exogenous-gate review using model-independent filters such as compilation and static quality checks, and AI-self-gate review using the code LLM's own signals such as perplexity and binary self-scoring. Across multiple code LLMs and benchmarks, every tested recursive regime falls below its own starting point; exogenous filters preserve executable validity and sometimes reduce decline, while AI-self-gate filters can look strong early but later lose their filtering effect. In the clearest case, the binary self-gate enters a rubber-stamp regime where acceptance scores rise while benchmark correctness falls. We explain this behavior by formulating review as gated distributional reweighting, proving that AI self-gating degenerates to ungated self-training under a self-confirming acceptance condition, and giving a spectral analysis of representation-level covariance concentration under recursive retraining. These results suggest that stable recursive code LLM training requires exogenous verification rather than model-coupled self-review.

Xinyuan Song, Zekun Cai, Liang Zhao

Emory University, Atlanta, GA, USA · The University of Tokyo, Tokyo, Japan · LocationMind, Tokyo, Japan

Self-Training Model Collapse Automated Code Review Code Language Models

Ask PDF

Aug 20, 2026

AI4AI-Bench: Benchmarking LLM Agents in Algorithmic Design for Recursive Self-Improvement

Recursive self-improvement (RSI) asks whether an AI system can improve the process that produces AI systems, so that the next system inherits the improvement. That process is the training algorithm: a better objective or update rule improves the compute\mbox{-}capability exchange rate for every subsequent run, including the one that produces the next agent. Whether RSI is feasible therefore turns on whether an agent can design training algorithms. No benchmark isolates that ability: existing suites are won by collecting data or by tuning hyperparameters, and none tells a change to how a run is executed apart from a change to how the model learns. We present AI4AI\mbox{-}Bench, 10 frozen research repositories spanning 10 training algorithm families. In each task, an agent has 4 hours on one B300 to rewrite the training algorithm; its code is then rerun from scratch for up to 12 hours and scored by a fixed evaluator hidden from the agent, against the repository's original algorithm under the same procedure. Because the 10 metrics are incommensurable, every task is mapped onto one scale on which

0

is an uninformative model,

0.1

is the algorithm the repository ships, and

1.0

is the task optimum. Across 29 configurations of 6 systems on all 10 tasks the mean score is

0.166

, and the best system reaches

0.250

: even the strongest closes under a fifth of the distance between the algorithm that was already there and the optimum. The submissions show where that distance went: most never change how the model learns at all, and the minority that do average

0.226

against

0.126

for the rest. More reasoning effort mostly buys the willingness to go there, taking that minority from

8\%

of submissions to

64\%

and the mean score from

0.094

0.196

. We release the task suite, the evaluators and every scored submission, so that the measurement can be repeated as these systems change.

Yizhe Chi, Wenyi Li, Deyao Hong +7

Navers Lab, Einsia.AI · Tsinghua University

Recursive Self-Improvement Automated Algorithm Discovery AI Agent Benchmarks LLM Agent Evaluation

Ask PDF

Jun 11, 2026

Recursive Agent Harnesses

Recursive language models (RLMs) showed that recursion over model calls is an effective strategy for long-context reasoning, and production coding agents have begun to write code that spawns subagents at scale, most recently in Anthropic's dynamic workflows. We name and study the pattern between these two lines of work, where the recursive unit is a full agent harness with filesystem tools, code execution, and planning rather than a model call with no tools. We call this the Recursive Agent Harness (RAH) and frame it as harness recursion, the code-first extension to the model recursion of RLMs. A parent agent generates and runs an executable script that spawns subagent harnesses in parallel for fine-grained workloads and uses structured function calls for small subtasks. We provide a controlled evaluation on long-context reasoning. With the backbone held fixed at GPT-5 to match the published Codex and RLM baselines, RAH improves the Codex coding-agent baseline from 71.75% to 81.36% on Oolong-Synthetic (199 samples, 13 context-length buckets up to 4M tokens), a gain attributable to the harness rather than the model. With a stronger backbone, Claude Sonnet 4.5, the same design reaches 89.77%.

Elias Lumer, Sahil Sen, Kevin Paul +1

PricewaterhouseCoopers, U.S.

Tool-Augmented Language Model Agents LLM Agent Orchestration Long-Context Inference Multi-Agent Coding LLM Agent Harnesses AI Agent Architecture

Ask PDF

Abstract

Language Model Self-Improvement

Explore similar work

When AI Reviews Its Own Code: Recursive Self-Training Collapse in Code LLMs

AI4AI-Bench: Benchmarking LLM Agents in Algorithmic Design for Recursive Self-Improvement

Recursive Agent Harnesses