Recursive Self-Improving Recommendation (RSIR)

• RSIR is a closed-loop framework that recursively generates, filters, and retrains on synthetic user interaction data to overcome data sparsity in recommendation systems.
• It employs a hybrid exploration mechanism and strict fidelity control to ensure that generated trajectories align with the true user preference manifold.
• The method implicitly regularizes model training by smoothing the optimization landscape, yielding cumulative performance gains across various recommender backbones.

Recursive Self-Improving Recommendation (RSIR) is a closed-loop framework in which a recommender system repeatedly generates, filters, and trains on its own synthetic user interaction data. In its canonical formulation, the current model produces plausible interaction sequences, a fidelity-based quality control mechanism filters them for consistency with the user’s approximate preference manifold, and a successor model is augmented on the enriched dataset. The central claim is that, under this design, recursive self-improvement can both alleviate extreme interaction sparsity and act as a data-driven implicit regularizer that smooths the optimization landscape, yielding cumulative gains across multiple recommender backbones without relying on external data or teacher models (Zhang et al., 17 Feb 2026).

1. Problem formulation and scope

RSIR is motivated by the data regime of sequential recommendation, where users interact with only a tiny fraction of the item catalog. With users $U$, items $I$, and interaction sequences

$$D_0 = \{s_u\}_{u\in U}, \qquad s_u = (i_1,\dots,i_T), \quad i_t \in I,$$

the base learning problem is next-item prediction under

$$p_\theta(i_t \mid i_{<t}) = p(i_t \mid s_{u,<t}; \theta).$$

After standard preprocessing such as 5-core filtering, the benchmarks used for RSIR—Amazon-Toys, Amazon-Beauty, Amazon-Sports, and Yelp—still exhibit sparsity of approximately $0.9995$–$0.9997$. The framework is designed precisely for this regime, where fragmented supervision and rugged optimization landscapes make models prone to fitting spurious patterns and converging to sharp, brittle minima (Zhang et al., 17 Feb 2026).

Within this setting, RSIR positions itself against three established families of methods. Purely supervised learning on logged interactions remains confined to $D_0$ and therefore inherits the sparsity problem directly. Teacher–student and external-knowledge methods can inject extra supervision through large models, reviews, metadata, or semantic IDs, but introduce cost, domain specificity, and distribution-mismatch risks. Heuristic data augmentation methods such as reordering, insertion, cropping, and masking increase sample volume, yet mainly create altered views of already sparse trajectories rather than new behaviorally plausible trajectories. The RSIR framework instead seeks to generate novel sequences that both densify user trajectories and remain close to the underlying preference manifold, while preventing recursive degradation through explicit fidelity control (Zhang et al., 17 Feb 2026).

A common misconception is that RSIR is simply another form of pseudo-labeling. The framework is more specific: it does not merely relabel unlabeled instances, but constructs a recursive sequence of datasets $\{D_k\}$ and models $\{f_{\theta_k}\}$ in which each iteration changes the effective training distribution through synthetic but fidelity-filtered trajectories. This suggests a closer relationship to self-improving dynamical systems than to static augmentation pipelines.

2. Closed-loop training and synthetic trajectory generation

At iteration $k$, RSIR follows a four-stage loop. First, it trains $I$0 on the current dataset $I$1 using standard next-item prediction: $I$2 Second, it uses $I$3 as a generator to produce a synthetic dataset $I$4. Third, it expands the dataset by union,

$I$5

after filtering duplicates and very short sequences. Fourth, it trains a successor model $I$6 on $I$7. The successor may either be initialized from scratch, denoted RSIR, or fine-tuned from $I$8, denoted RSIR-FT (Zhang et al., 17 Feb 2026).

Synthetic generation is not unconstrained. For each user sequence $I$9, RSIR generates $$D_0 = \{s_u\}_{u\in U}, \qquad s_u = (i_1,\dots,i_T), \quad i_t \in I,$$0 synthetic trajectories. A random prefix $$D_0 = \{s_u\}_{u\in U}, \qquad s_u = (i_1,\dots,i_T), \quad i_t \in I,$$1 is selected as seed context, and generation proceeds autoregressively. At each step, the candidate pool is drawn from a hybrid exploration mechanism: $$D_0 = \{s_u\}_{u\in U}, \qquad s_u = (i_1,\dots,i_T), \quad i_t \in I,$$2 With probability $$D_0 = \{s_u\}_{u\in U}, \qquad s_u = (i_1,\dots,i_T), \quad i_t \in I,$$3, candidates are sampled from the user’s own history, which supports exploitation and recombination of known preferences; with probability $$D_0 = \{s_u\}_{u\in U}, \qquad s_u = (i_1,\dots,i_T), \quad i_t \in I,$$4, candidates are sampled from the global item set $$D_0 = \{s_u\}_{u\in U}, \qquad s_u = (i_1,\dots,i_T), \quad i_t \in I,$$5, which permits exploratory expansion near the boundary of the user’s preference support. The model’s outputs are then restricted to $$D_0 = \{s_u\}_{u\in U}, \qquad s_u = (i_1,\dots,i_T), \quad i_t \in I,$$6, top-$$D_0 = \{s_u\}_{u\in U}, \qquad s_u = (i_1,\dots,i_T), \quad i_t \in I,$$7 scoring candidates are retained within that pool, and the next synthetic item is sampled from this restricted distribution (Zhang et al., 17 Feb 2026).

This bounded exploration mechanism is central to the RSIR loop. Pure exploitation, corresponding to $$D_0 = \{s_u\}_{u\in U}, \qquad s_u = (i_1,\dots,i_T), \quad i_t \in I,$$8, fails to expand the preference support; pure exploration, corresponding to $$D_0 = \{s_u\}_{u\in U}, \qquad s_u = (i_1,\dots,i_T), \quad i_t \in I,$$9, wastes effort on irrelevant candidates and causes many trajectories to be rejected later by fidelity control. Empirically, the best trade-off occurs around $$p_\theta(i_t \mid i_{<t}) = p(i_t \mid s_{u,<t}; \theta).$$0, indicating that RSIR depends on balancing local plausibility against support expansion rather than maximizing either one independently (Zhang et al., 17 Feb 2026).

The framework is explicitly model-agnostic. It is instantiated with SASRec, CL4SRec, and HSTU, while treating $$p_\theta(i_t \mid i_{<t}) = p(i_t \mid s_{u,<t}; \theta).$$1 as a black box that ranks items given a partial sequence and supports top-$$p_\theta(i_t \mid i_{<t}) = p(i_t \mid s_{u,<t}; \theta).$$2 queries. This suggests that RSIR is not tied to a particular sequential architecture, but to the closed-loop logic by which a recommender turns its own predictions into new training data.

3. Fidelity control and the preference-manifold view

The distinctive mechanism of RSIR is fidelity-based quality control. After a candidate next item $$p_\theta(i_t \mid i_{<t}) = p(i_t \mid s_{u,<t}; \theta).$$3 is sampled from $$p_\theta(i_t \mid i_{<t}) = p(i_t \mid s_{u,<t}; \theta).$$4, the framework forms the provisional context

$$p_\theta(i_t \mid i_{<t}) = p(i_t \mid s_{u,<t}; \theta).$$5

and checks whether at least one remaining true future item stays highly ranked under the current model: $$p_\theta(i_t \mid i_{<t}) = p(i_t \mid s_{u,<t}; \theta).$$6 If the condition holds, the synthetic step is accepted and generation continues; otherwise, the trajectory is terminated immediately (Zhang et al., 17 Feb 2026).

Operationally, this means that a synthetic perturbation is retained only if, after adding it, the model can still recover some true future item within top-$$p_\theta(i_t \mid i_{<t}) = p(i_t \mid s_{u,<t}; \theta).$$7. The exact preference manifold is unknown, so RSIR uses the current recommender together with the logged future suffix as a proxy. The resulting binary fidelity indicator is

$$p_\theta(i_t \mid i_{<t}) = p(i_t \mid s_{u,<t}; \theta).$$8

Only steps with $$p_\theta(i_t \mid i_{<t}) = p(i_t \mid s_{u,<t}; \theta).$$9 are retained (Zhang et al., 17 Feb 2026).

The paper interprets this through a manifold hypothesis. User preference trajectories are assumed to lie near a low-dimensional manifold $0.9995$0 in sequence space, and accepted synthetic perturbations are treated as approximately tangent to that manifold. Strict $0.9995$1 values enforce stronger adherence but produce little data; overly loose $0.9995$2 values admit off-manifold noise. This trade-off is not merely heuristic: without fidelity control, the first recursion can produce small gains because of increased data volume, but subsequent iterations exhibit catastrophic collapse. On Amazon-Sports, removing fidelity control causes NDCG@10 to fall from $0.9995$3 to $0.9995$4 over recursive iterations, whereas fidelity-controlled RSIR supports sustained multi-iteration improvement (Zhang et al., 17 Feb 2026).

This point addresses the main controversy around recursive self-training in recommendation. Closed-loop retraining is often associated with model collapse, confirmation bias, or synthetic drift. RSIR does not deny that risk; rather, it treats fidelity leakage as the central failure mode and makes it explicit. A plausible implication is that RSIR’s viability depends less on synthetic generation capacity per se than on whether the fidelity filter tracks the target behavior manifold tightly enough.

4. Implicit regularization and error dynamics

The theoretical analysis presents RSIR as an implicit regularizer induced by generated data. If $0.9995$5 denotes the accepted synthetic set at iteration $0.9995$6, the generated-data loss is

$0.9995$7

and training the successor model is written as

$0.9995$8

This is then interpreted as

$0.9995$9

where $0.9997$0 is an implicit regularizer induced by the synthetic trajectories accepted under the current model (Zhang et al., 17 Feb 2026).

Under the manifold view, the paper defines

$0.9997$1

Linearizing around $0.9997$2 and using the assumption that accepted perturbations lie in the tangent space $0.9997$3, the regularizer reduces to a manifold tangential gradient penalty,

$0.9997$4

The effect is not generic smoothness, but targeted smoothing along directions consistent with user preference trajectories. The paper summarizes this as a push toward wide, flat minima aligned with the preference manifold (Zhang et al., 17 Feb 2026).

The error analysis gives a second perspective. Let $0.9997$5 be the generalization error at iteration $0.9997$6. Then

$0.9997$7

where $0.9997$8 is the contraction factor induced by valid on-manifold synthetic data and $0.9997$9 is the fidelity leakage, namely the fraction of synthetic data that is actually off-manifold. This decomposition yields a contraction-plus-noise recursion. If $D_0$0 stays sufficiently small, recursive training reduces error; if it exceeds a breakdown threshold, the process diverges (Zhang et al., 17 Feb 2026).

The same analysis explains why gains accumulate and then plateau. Even under good fidelity control, the irreducible term $D_0$1 does not vanish. As error shrinks, the contraction benefit weakens while the leakage term persists, producing the empirically observed pattern of early cumulative gains followed by oscillation or saturation. This suggests that RSIR is best understood not as unlimited recursive improvement, but as recursive regularization under bounded fidelity leakage.

5. Empirical behavior, efficiency, and transfer

RSIR is evaluated on Amazon-Toys, Amazon-Beauty, Amazon-Sports, and Yelp, using SASRec, CL4SRec, and HSTU as backbones. Main metrics are NDCG@10, NDCG@20, Recall@10, and Recall@20, with additional results for Precision@10, F1@10, and MRR@10. The framework yields consistent improvements across datasets and architectures after a single recursive iteration. For example, with SASRec plus RSIR retraining, Amazon-Toys improves from NDCG@10 $D_0$2 and Recall@10 $D_0$3; Amazon-Beauty improves from $D_0$4 in NDCG@10 and $D_0$5 in Recall@10; Yelp improves from $D_0$6 and $D_0$7, respectively. HSTU plus RSIR also improves on Toys from NDCG@10 $D_0$8 and Recall@10 $D_0$9, while Yelp Recall@10 rises from $\{D_k\}$0 (Zhang et al., 17 Feb 2026).

The recursive aspect is visible over longer horizons. On Amazon-Sports with SASRec, Recall@10 increases from $\{D_k\}$1 at iteration 0 to $\{D_k\}$2 at iteration 1 and reaches $\{D_k\}$3 by iteration 3, an overall $\{D_k\}$4 gain relative to the base model. On Yelp, Recall@10 moves from $\{D_k\}$5 to $\{D_k\}$6 after one iteration and to $\{D_k\}$7 by iteration 3, followed by oscillation or plateau. These trajectories match the contraction-plus-noise picture from the theoretical section (Zhang et al., 17 Feb 2026).

The framework also changes the data distribution itself. Training density increases by as much as $\{D_k\}$8 after 8 iterations, while Approximate Entropy increases rather than decreases. This contrast is used to distinguish RSIR from insertion-style augmentation, which also increases density but reduces Approximate Entropy and therefore injects repetitive, low-information patterns. Weak-to-strong transfer experiments further show that stronger teachers yield larger gains, but even weak teachers can still improve strong students; the paper reports nontrivial gains such as $\{D_k\}$9 in that setting. The abstract formulates this more broadly as “weak models can generate effective training curricula for stronger ones” (Zhang et al., 17 Feb 2026).

Efficiency is also emphasized. On Amazon-Toys, RSIR data generation takes approximately 3m 45s, and RSIR retraining takes approximately 2m 16s, which is slightly faster than base training at 2m 34s. The paper contrasts this with DR4SR, which requires approximately 68m for generation and approximately 10m 40s for training. This supports the claim that the framework is efficient enough for iterative use and that the smoothing effect can accelerate retraining rather than merely add overhead (Zhang et al., 17 Feb 2026).

6. Relation to broader recursive self-improvement research and unresolved issues

RSIR sits within a wider body of work on recursive self-improvement, self-referential agents, and self-improving recommenders, but its mechanism is distinct. STOP treats scaffolding design as a meta-optimization problem and recursively improves the improver itself via

$\{f_{\theta_k}\}$0

where the self-improvement target is the scaffolding code rather than the language-model weights; it also shows that generated improvers can discover beam search, genetic algorithms, simulated annealing, and UCB-style exploration (Zelikman et al., 2023). Gödel Agent generalizes this idea to a self-referential agent that modifies both its task policy $\{f_{\theta_k}\}$1 and its meta-algorithm $\{f_{\theta_k}\}$2 through runtime memory inspection and monkey patching, formalized as

$\{f_{\theta_k}\}$3

This places RSIR within a broader family of systems in which policy and optimizer are both mutable, although the RSIR paper itself focuses on synthetic data recursion rather than open-ended code rewriting (Yin et al., 2024).

Within recommendation research specifically, RISER offers a different route to recursive improvement. It argues that Long CoT is structurally misaligned with sequential recommendation because of excessive inference latency and the lack of explicit cognitive reasoning patterns in behavior data, and instead proposes RL directly in item-token space. Its update combines a modified GRPO objective with SimPO preference learning,

$\{f_{\theta_k}\}$4

turning non-learnable failed rollouts into pairwise preference data and stabilizing the recursion through oversampling with de-duplication, a certainty-aware token mask, and selective KL-Cov regularization (Ding et al., 31 Jan 2026). RecMind, by contrast, realizes recursive improvement inside a single recommendation episode: its Self-Inspiring planner conditions new states on the full set of previously explored Thought–Action–Observation paths rather than only the final branch, improving zero-shot and few-shot recommendation without parameter updates (Wang et al., 2023). RAM contributes another, architectural sense of recursion by reusing fixed item representations across blocks and recursively refining user state, mitigating the localization-deficit problem that appears in self-attention-based sequential recommendation (Peng et al., 2022).

The limitations of RSIR remain substantial. The main paper explicitly notes dependence on initial model quality, sensitivity to the fidelity threshold $\{f_{\theta_k}\}$5, computational overhead from extra generation and retraining, and the risk of feedback loops and exposure bias in closed-loop deployment (Zhang et al., 17 Feb 2026). A further complication, already formalized in earlier recommendation theory, is that recommendation policies can influence user interests themselves: in that model, the recommender strategy $\{f_{\theta_k}\}$6 and user-interest profile $\{f_{\theta_k}\}$7 co-evolve according to

$\{f_{\theta_k}\}$8

so recommendation quality and user preference formation become coupled dynamical variables rather than separable modules (Meshram et al., 2018). This suggests that any deployed RSIR system would need to address not only data sparsity and optimization landscape smoothing, but also the endogenous evolution of the environment it is trying to optimize.

Taken together, these results place RSIR at the intersection of self-training, meta-optimization, and sequential decision-making. Its distinguishing contribution is not merely that a recommender can train on its own outputs, but that recursive self-training can be stabilized by bounded exploration and fidelity control, interpreted geometrically as manifold-aligned data generation and analytically as contraction under bounded leakage.