cs.AIAug 29, 2026

Evaluating Tiny Recursive Models Across Training for Code Generation

Authors: Anjani Sirivella, Aanisha Newaz, Glaucia Melo

Organizations: Dept. of Computer Science Toronto Metropolitan University Toronto, ON, Canada

Read PDF
Ask AI
Cite

Copy citation

DOINot available for this paper

Abstract

Code generation increasingly relies on large transformer models, whose capability advances with scale. Yet such a scale is costly, creating demand for small models, especially where data is limited. Recursive models address this by reusing a single block to add depth rather than stacking independent layers. Such models are typically evaluated by teacher-forced fit (next-token loss on ground-truth prefixes) or task accuracy, at a single checkpoint, whereas code is produced by free-running generation, where the model extends its own output. Whether a teacher-forced advantage survives free-running generation, and whether it holds across training, remains open. To study both, we compare a ~28M-parameter autoregressive Tiny Recursive Model (TRM-AR) on natural-language-to-Python code generation against parameter-matched and depth-matched controls, tracking fit and generation across 40 epochs and three seeds. The fit ranking between the recursive model and the depth-matched control reverses twice. Selecting each checkpoint by validation loss and examining the trajectory yields a consistent comparison. At equal parameters, TRM-AR fits, generates, and generalizes better than the parameter-matched control while recovering approximately 45% of the validation-loss gap and 57% of the generation-quality gap between the two controls, at roughly 175 times the per-step cost of the parameter-matched control. However, at equal effective depth, the larger transformer fits and generates better at its validation optimum, suggesting TRM-AR's advantage lies in resistance to overfitting, not greater capability. These findings suggest that recursive code generation models should be evaluated jointly on fit and generation across the training trajectory rather than at a single checkpoint.

Figures & tables

SplitRecords
Train38,119
Validation4,765
Test4,765
Total47,649
TABLE I: Corpus Splits
ArmDepth realizationEff. depthParametersNon-emb. params a
TRM-ARrecursive shared 22 -layer block202027,830,7842,099,200
vanilla-2L22 independent layers2227,830,0162,098,432
vanilla-20L2020 independent layers202046,713,60020,982,016
TABLE II: Architecture and Parameter Counts of the Three Arms
ArmSel. epoch aVal. loss ↓\downarrowTest ppl. ↓\downarrowJudge ↑\uparrow bGap tv{}_{\text{tv}} ↓\downarrow c
TRM-AR40401.277±0.0151.277_{\pm 0.015}3.53±0.053.53_{\pm 0.05}2.85±0.062.85_{\pm 0.06}0.14±0.013\mathbf{0.14}_{\pm 0.01\phantom{3}}
vanilla-2L40401.379±0.0061.379_{\pm 0.006}3.92±0.023.92_{\pm 0.02}2.49±0.062.49_{\pm 0.06}0.27±0.0130.27_{\pm 0.01\phantom{3}}
vanilla-20L20201.154±0.003\mathbf{1.154}_{\pm 0.003}3.14±0.01\mathbf{3.14}_{\pm 0.01}3.12±0.02\mathbf{3.12}_{\pm 0.02}0.29±0.0030.29_{\pm 0.003}
TABLE III: Validation-Selected Point Estimates for the Three Arms
Fig. 1: Which arm wins depends on when the comparison is read: fit and generation can rank the three arms differently at a given epoch, and the fit ranking reverses twice across training. Trajectories of the three arms across the nine snapshot epochs: (a) teacher-forced fit (validation loss) and (b) free-running generation (judge score, 00 – 1010 ). Solid lines are the seed-mean; shaded bands are ±1\pm 1 standard deviation across the three seeds; the epoch axis is log-scaled. Dotted vertical guides mark the two fit crossovers in (a) (epochs 88 and 4040 ) and, in (b), the epoch from which vanilla-20L leads generation ( 88 ).
Fig. 2: After an early transient common to all arms, TRM-AR holds a small, flat generalization gap, while the iso-depth control overfits after epoch 2020 . Generalization gap (train −- validation) across training; solid lines are the seed-mean and shaded bands are ±1\pm 1 standard deviation across the three seeds. The epoch axis is log-scaled.
More in this topic

Recursive Language Models

Recursive Language Models use repeated or decomposed computation to extend language-model reasoning beyond a single pass.

See all 59 papers

Explore similar work

CardsList
Apr 23, 2026

Feedback Over Form: Why Execution Feedback Matters More Than Pipeline Topology in 1-3B Code Generation

Small language models (1-3B) are practical to run locally, but individually limited on harder code generation tasks. We ask whether composing them into pipelines can recover some of that lost capability. We study code generation pipelines built from 1-3B models with execution feedback, and use a NEAT-inspired evolutionary search to test whether more complex pipeline structure helps beyond a simple refinement loop. We evaluate on HumanEval (164 problems) and sanitized MBPP (427 problems), all with local inference on a single laptop. Self-refinement with execution feedback improves code generation by more than 4 standard deviations on both benchmarks. The gains are narrow in mechanism: refinement fixes many runtime errors (especially NameError and SyntaxError), but rarely fixes logic errors such as AssertionError. Within our tested general-purpose model pool, generator identity mattered less than refiner capability: a 1.5B generator paired with a 3B refiner matched a 3B model doing both roles. Early stopping is essential; without it, every iteration is net-negative. The code-specialized models outperform every general-purpose pipeline configuration, suggesting model specialization matters more than pipeline architecture. Preliminary text-only pipeline experiments without execution feedback did not show gains at this scale. In our constrained search space, evolutionary search mostly rediscovered the same simple generate-execute-refine loop we found manually, with no clearly significant gain from added topology. Single-evaluation fitness inflates results by 5-7 percent, selecting lucky genomes over good ones. On these benchmarks at 1-3B scale, execution feedback mattered more than added pipeline complexity in determining whether composition helped.

Charles Junichi McAndrews

LLM Self-RefinementExecution-Guided Code GenerationError Feedback
AskPDF
May 28, 2026

Improving Small Language Models for Code Generation with Reinforcement Learning from Verification Feedback

Reinforcement learning with verifiable rewards (RLVR) trains language models using programmatically checkable signals such as unit-test outcomes, enabling direct optimization for functional correctness in code generation. We conduct an empirical study of RLVR for Python code generation on the MBPP benchmark using two small models (Qwen3-0.6B and Llama3.2-1B) with LoRA fine-tuning. Across multiple reward formulations such as: unit-test-only rewards, static-analysis-only shaping via the Ruff linter, and a combined reward, we compare group-based policy optimization variants (GRPO and GSPO) and evaluate both functional correctness and behavioral diagnostics. In our experimental setting, RLVR improves pass@1 on MBPP test by up to 13 percentage points under proposed combined reward configuration. However, we find that reward shaping can induce systematic behavioral shifts: using only static-analysis penalties may bias the policy toward shorter completions that reduce lint errors without reliably improving functional correctness. In contrast, combined rewards mitigate this degeneration and yield more stable trade-offs between correctness and style constraints. Overall, our results highlight that RLVR effectiveness for code generation is highly sensitive to reward design and optimization granularity, and that diagnostics beyond pass@1, including generation length, Ruff severity profiles, and execution error types are useful for identifying failure modes.

Egor Skopin, Evgeny Kotelnikov

RL for Code GenerationReward ShapingReinforcement Learning with Verifiable RewardsCode Generation EvaluationVerified Code Generation
AskPDF
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-TrainingModel CollapseAutomated Code ReviewCode Language Models
AskPDF