1 Introduction↩︎

Sequential recommender systems aim to infer user preferences from historical interaction sequences to predict the next relevant item. Existing approaches primarily enhance sequence modeling capacity through Markov models [1], [2], recurrent networks [3], and Transformer-based architectures [4], [5]. These methods encode interaction histories in a single forward pass, relying on deeper architectures to capture complex behavioral patterns, lacking mechanisms to iteratively refine or correct preference representations once computed. Consequently, they are limited in their ability to progressively improve estimates or recover from approximation errors. On the other hand, recent reasoning-enhanced approaches based on large and small language models [6]–[8] enable multi-step reasoning and inference, but incur substantial computational overhead and rely on token space of the language models.

In this work, we revisit sequential recommendation problem from a recursive inference perspective and ask: can user preferences be modeled as a persistent latent state that is recursively refined? We propose RecRec (Recursive Recommendation), a lightweight model that maintains a compact latent state and updates it through a shared recursive module conditioned on interaction evidence, enabling progressive refinement beyond single-pass encoding. A key challenge in recursive refinement is semantic drift, where accumulated approximation errors during recursive updates cause representations to deviate from the original evidence. To address this, we introduce an evidence-anchored correction mechanism that grounds each update in the interaction context, ensuring stable refinement. Our approach is inspired by the Tiny Recursive Model (TRM) [9], but differs by focusing on correction-guided refinement of a persistent latent preference state under direct supervision.

Our contributions can be summarized as follows:

• We formulate sequential recommendation problem as recursive latent state inference problem, modeling user preferences as a persistent latent state refined over multiple steps.

• We propose RecRec, a lightweight recursive recommendation model that introduces an evidence-anchored correction mechanism to stabilize recursive updates and prevent semantic drift.

• We demonstrate through extensive numerical experiments that RecRec achieves competitive performance against state-of-the-art sequential, graph-based, and reasoning-based recommenders, while maintaining a compact parameter footprint (3.9M–14M) across multiple benchmark datasets and evaluation metrics.

2 Related Work↩︎

We organize related work into approaches based on sequential modeling, latent reasoning, and language models.
Sequential Recommendation. Early systems modeled user behavior using Markov chains [1], [2] or recurrent neural networks [3], [10], [11] to capture short-term dependencies. Transformer-based models [5], [12], [13] later established strong baselines by utilizing self-attention to model long-range history. However, these methods encode sequences into contextual representations via a single forward pass, lacking the ability to explicitly structure user preference through recursive reasoning.
Latent Representation and Reasoning. To address the lack of structural reasoning in pure sequence models, latent-factor approaches [14], [15] learn compact representations from interaction data. This paradigm extends to graph-based [16], [17] and knowledge-aware [18], [19] methods which propagate embeddings over relational structures. Recent work like ReaRec [20] attempts to integrate reasoning into this latent space, yet it remains constrained by fixed-depth architectures that do not recursively refine a shared global preference state.
LLM and SLM-based Recommendation. To overcome the limitations of static latent embeddings, recent work explores LLM-based recommenders [6], which offer strong reasoning but at high computational cost. SLM approaches [8] provide a lighter alternative with intermediate reasoning, yet rely on explicit language generation rather than compact latent states. Motivated by this, we propose a framework that combines efficient latent modeling with recursive reasoning, detailed in Section 4.

3 Problem Formulation↩︎

Let \(\mathcal{U}\) and \(\mathcal{I}\) denote the sets of users and items, respectively. For each user \(u \in \mathcal{U}\), we represent their chronologically ordered interaction history as \(\mathcal{S}_u = (i_1, i_2, \dots, i_l)\), where \(i_j \in \mathcal{I}\) and l is the length of the sequence. Each item in the sequence is associated with a pre-trained semantic embedding \(\mathbf{e}_{i_j} \in \mathbb{R}^d\) derived from frozen SBERT embeddings of item metadata, providing semantic initialization. We define the set of historical embeddings as \(\mathcal{H} = \{\mathbf{e}_{i_1}, \mathbf{e}_{i_2}, \dots, \mathbf{e}_{i_t}\}\). To handle variable sequence lengths during batch processing, we introduce a history mask \(\mathcal{M} = (m_1, m_2, \dots, m_t) \in \{0, 1\}^t\), where \(m_j=1\) if \(i_j\) is a valid interaction and \(m_j=0\) otherwise. The objective is to learn a recommendation model that predicts the next item \(i_{t+1}\). Following [5], to assess a model’s performance, items are randomly sampled to form a candidate set \(\mathcal{C}_u\) (ground-truth item with sampled negatives), and evaluated under a leave-one-out protocol.

4 Methodology↩︎

In this section, we detail the architecture of RecRec, illustrated in Figure 1. Our model is designed to recursively update the user’s preference representation while explicitly correcting for semantic drift across steps.

4.1 Recursive Refinement with Self-Correction↩︎

RecRec performs iterative preference refinement over \(T\) steps using a shared recursive block. Instead of a single hidden representation, the model maintains three states: a static context \(x\), a preference state \(y_t\), and a latent state \(z_t\).
Context Initialization: The context \(x\) is obtained via masked mean pooling to frozen SBERT embeddings of the interaction history \(\mathcal{H},\) as follows: \(x = \sum (\text{Embed}(\mathcal{H}) \odot \mathcal{M})/\sum \mathcal{M},\) where \(\odot\) denotes the inner product operator. We initialize \(y_0 \leftarrow x\) and \(z_0 \leftarrow \mathbf{0}\).
Refinement Loop: At each outer step \(t \in \{0, \dots, T-1\}\), the model performs \(n\) inner recursive updates to stabilize the latent representation \(z_t.\) During this process, the preference state \(y_t\) remains fixed, while the latent state \(z\) is iteratively updated using a shared non-linear transformation \(f_{\phi}\). Specifically, for each inner step \(j \in \{1, \dots, n\}\): \[\label{eq:inner95refine} z^{(j)}_t = f_{\phi}([x \,\|\, y_t \,\|\, z^{(j-1)}_t]),\tag{1}\] where \([\cdot\|\cdot]\) denotes concatenation operator and \(z^{(0)}_t\) is inherited from the previous outer step. This inner recursion progressively refines \(z\) conditioned on both the static evidence \(x\) and the current preference estimate \(y_t\), allowing the model to iteratively reconcile contextual information before updating the preference state. By applying the same transformation across steps, the model traces a structured trajectory in latent space rather than relying on a single-pass transformation.
Self-Correction Mechanism: A key challenge in recursive refinement is semantic drift, where repeated application of a shared nonlinear transformation causes the latent state to deviate from the original evidence. To mitigate this, we introduce a correction gate \(g_t\) that adaptively controls the influence of the original context \(x\) during refinement, as given below: \[\label{eq95gate} g_t = \sigma(W_t [x \,\|\, y_t]),\tag{2}\] where \(W_t\) is a learnable parameter matrix of gate correction mechanism and \(\sigma\) denotes the sigmoid function. Given the final inner-loop state \(z_t^{(n)}\), we compute a corrected latent state as follows: \({z}_{t} = (1 - g_t) \, z_t^{(n)} + g_t \, x,\) which interpolates between the refined representation and the original evidence. Note that \(g_t\) can be interpreted as a data-dependent trust coefficient that regulates the contribution of recursive updates. This mechanism explicitly anchors the recursive updates to the observed interaction history, preventing error accumulation and ensuring stable refinement across steps. Unlike standard deep models where such alignment is implicit, the correction gate provides a direct and adaptive pathway for evidence injection during inference.
Preference Refinement: The preference state, \(y_t,\) is updated using the corrected latent representation \({z}_t\) as follows: \[\label{eq:intent95update} {y}_{t+1} = y_t + L \cdot \underbrace{\tanh\!\left(f_\phi\!\left([x \,\|\, y_t \,\|\, \tilde{z}_t]\right)\right)}_{\Delta_t},\tag{3}\] where \(L\) is a scaling factor controlling the update magnitude. Note that, \({y}_{t+1}\) is the updated state for the next iteration. This residual formulation produces an incremental update \(\Delta_t\) conditioned on both the current preference state and the corrected latent representation. By iteratively applying small, controlled updates, the model refines user preferences over multiple steps while maintaining stability.

4.2 Deep Supervision and Learning Objective↩︎

To effectively train the shared parameters \(\phi\) in Eq. 1 and \(W_t\) in Eq. 2 while mitigating vanishing gradients across recursive steps, we employ deep supervision. Starting from an initial state \(y_0 = x\), the model performs \(T\) refinement steps. At each step \(t \in \{0, \dots, T-1\}\), an updated representation \({y}_{t+1}\) is computed and used for supervision against the target item \(i_{\text{target}}\) using the cross-entropy loss as follows: \[\mathcal{L}_{CE}({y}_{t+1}, i_{\text{target}}) = - \log \left( \frac{ \exp({y}_{t+1} \cdot \mathbf{e}_{\text{target}}^\top / \tau) }{ \sum_{j \in \mathcal{C}} \exp({y}_{t+1} \cdot \mathbf{e}_j^\top / \tau) } \right),\] where \(\mathbf{e}_j\) denotes the embedding of candidate item \(j\), \(\mathcal{C}\) is the candidate set consisting of the ground-truth item and sampled negatives, \(\tau\) is the softmax temperature. The total loss is defined as: \(\mathcal{L}_{\text{total}} = \frac{1}{T} \sum_{t=0}^{T-1} \mathcal{L}_{CE}({y}_{t+1}, i_{\text{target}}).\) This step-wise supervision encourages the model to produce progressively refined and predictive representations at each recursion step, rather than relying solely on the final output. Gradients are backpropagated through both the inner recursion (Eq. 1 ) and the outer refinement updates (Eq. 3 ), enabling stable optimization of the shared recursive core. This contrasts with standard sequential recommenders that apply supervision only at the final prediction layer.

4pt

5 Experiments and Results↩︎

3pt

5.1 Datasets↩︎

We evaluate RecRec on three publicly available datasets [21] from different domains: Luxury Beauty (11,690 users, 6,534 items, 71,898 interactions), Video Games (64,039 users, 33,611 items, 508,508 interactions), and Steam Games (67,610 users, 10,978 items, 5,023,170 interactions). All datasets were preprocessed to remove users and items with fewer than five interactions prior to SBERT embedding extraction. These datasets cover diverse domains and interaction densities, enabling evaluation across varying sparsity and sequence characteristics. Implementation details can be found in Appendix.

5.2 Comparative Performance Evaluation↩︎

We compare RecRec against classical, sequential, recursive, and LLM-based recommenders. Across all datasets, RecRec achieves consistent gains while maintaining a substantially smaller parameter footprint.
Comparison with Sequential and Graph-based Recommenders. As shown in Table 1, RecRec consistently outperforms established baselines, including graph-based models (LightGCN [17], NGCF [16]) and sequential architectures (SASRec [5], UniRec [22]). Following [5], we adopt an interaction history length of 50 and a candidate set size of 100 for all models in Table 1. Despite this more challenging setting, RecRec outperforms all baselines, while maintaining substantially smaller parameter footprint (e.g., only 3.9M parameters on Luxury Beauty). The recursion-based baseline ReaRec [20] provides the strongest competing performance; however, RecRec preserves a consistent advantage, particularly on early-ranking metrics such as HR@1 and NDCG@1. Importantly, this improvement is not driven by pre-trained semantic initialization. The RecRec(Random) variant, which replaces SBERT embeddings with random uniform initialization, achieves comparable performance (\(\pm2\%\)), indicating that gains primarily arise from recursive refinement and latent stabilization rather than external semantic priors.
Comparison with LLM-based Baselines. We additionally compare RecRec against three representative LLM-based recommenders spanning key design paradigms: ALLMRec [23], which aligns LLM token representations with collaborative filtering objectives; TallRec [24], a state-of-the-art large-scale (7B) sequential recommender; and GPT4Rec [25], a parameter-efficient variant that adapts pretrained LLMs for recommendation. To ensure a standardized comparison, we adopted the configuration utilized for all three baselines, setting the interaction history length to 10 and the candidate set size to 20 following [23]. Furthermore, we utilized a point-wise scoring evaluation setting, consistent with the methodology in TallRec [24], where the model calculates individual likelihood scores for each candidate in the set. This differs from the setting in Table 1 (history = 50, candidates = 100), leading to uniformly higher absolute HR@1 values across all models. As shown in Table 3, RecRec consistently outperforms these LLM-based approaches across multiple datasets.
Effect of Recursion Steps (\(T\)). Our analysis on the Steam dataset shows that at \(T=1\), RecRec reduces to a single-pass architecture (HR@1: 0.49). Increasing \(T\) leads to consistent performance gains, with HR@1 peaking at \(T=7\) (HR@1: 0.59). Beyond this point, performance degrades (e.g., HR@1 drops to 0.55 at \(T=13\)), indicating over-refinement. As shown in Fig. 2, the average rank improves up to \(T \approx 6\text{--}7\) before plateauing and slightly degrading. A consistent trend is observed in HR@1, which peaks at \(T=7\) and declines thereafter. This suggests that while early recursion effectively refines user intent, deeper recursion yields diminishing returns, potentially due to error accumulation in repeated nonlinear updates.
Parametric Efficiency. RecRec exhibits superior parameter efficiency, outperforming the next-best baseline, ReaRec [20], with 22% fewer parameters. Remarkably, RecRec surpasses LLM-based models like ALLMRec and GPT4Rec despite a 99% smaller footprint (3.9M vs. 7B).
Effect of Model Depth. We vary the depth of the core MLP, \(f_{\phi}\), given in Equation 1 , from 2 to 10 layers on the Steam dataset. Performance is highest at 5 layers (HR@1: 0.61, HR@10: 0.94) with 6.2M parameters, improving from HR@1: 0.60 at 2 layers. Increasing the depth to 10 layers (21.1M parameters) degrades performance (HR@1: 0.55), indicating overfitting to dataset-specific patterns rather than improved generalization. Overall, this suggests that recursive refinement provides a more parameter-efficient alternative to increasing network depth, as deeper models tend to overfit rather than enhance preference estimation.

5.3 Ablations↩︎

Ablation results for the core components of RecRec, namely the correction gate, inner recursion, and latent state, are shown in Table 2. Due to space constraints, we present results only on the Steam Games dataset; corresponding results for the other datasets are provided in the Appendix. First, removing the correction gate yields the largest degradation across all metrics, compared to removing either the inner recursion or the latent state, underscoring its critical role in stabilizing recursive updates and mitigating error accumulation. Next, removing the latent state, \(z\), which serves as an internal reasoning representation, forces memory-less updates and leads to a substantial performance drop, as the model can no longer maintain a persistent summary of interaction history across recursion steps. Finally, excluding the inner recursion mechanism consistently degrades performance, highlighting the importance of iterative refinement within the weight-shared core for learning a stable latent state prior to the final update to \(y.\)

6 Conclusion↩︎

We presented RecRec, a lightweight sequential recommender that models user preferences as a recursively refined latent state. RecRec achieves competitive performance through iterative refinement with only 3.9M–14M parameters, consistently matching or outperforming strong baselines across multiple benchmarks. Ablation studies show that gains arise from structured recursion, correction-gated stabilization, and persistent latent state modeling rather than increased capacity or external semantic priors. Our analysis further reveals that recursive refinement improves performance up to a certain number of refinement steps, beyond which error accumulation leads to degradation. This highlights an inherent trade-off in recursive inference and suggests that future work should explore adaptive stopping criteria or theoretically grounded convergence mechanisms for stable refinement.

Appendix↩︎

6.0.0.1 Implementation Details.

We implement RecRec in PyTorch, fixing embedding sizes to 384 for all baselines and using a maximum sequence length of 50. Following the leave-one-out protocol, we pair each ground-truth item with 99 negative samples to form a 100-item candidate set, as in [5]. Models are trained for up to 50 epochs with a batch size of 512 using Cross-Entropy loss and the Adam optimizer (\(lr=10^{-3}\)). To enhance stability, we apply exponential moving average with a decay rate of 0.999. All experiments were conducted on a single NVIDIA RTX 3090 GPU.

6.0.0.2 Analysis of Model Confidence.

To empirically validate the stability of our iterative refinement process, we examine the model’s Confidence Margin (\(M\)). We define this margin as the logit distance between the target item and its most competitive “distractor” in the candidate set.

For a given refinement step \(t\), let \(y_t\) be the predicted preference vector and \(\mathbf{e}_i\) be the embedding of candidate item \(i\). The score is computed as \(s_{t,i} = y_t \cdot \mathbf{e}_i^\top\). The confidence margin \(M_t\) is formally defined as: \[M_t = s_{t, \text{target}} - \max_{j \neq \text{target}} s_{t,j}\] where \(s_{t, \text{target}}\) is the logit of the ground-truth item.

As shown in Fig. 3, the average confidence margin increases steadily and peaks at \(T=7\), mirroring the performance trend observed in Fig. 2. Beyond \(T=7\), the confidence begins to degrade alongside the accuracy. This alignment provides empirical evidence for our “over-refinement” hypothesis: while initial iterations successfully filter noise and align the latent state \(z\) with the user intent \(x\), excessive recursion through the non-linear core \(f_\phi\) eventually introduces cumulative numerical errors or semantic drift that the correction gate \(g_t\) can no longer fully solve.

6.0.0.3 Comparative Analysis of Computational Efficiency.

Table 6 presents the latency across three datasets for traditional baselines, LLM-based recommenders, and our proposed model. We observe a clear trade-off between semantic reasoning capability and computational cost. Traditional models like SasRec and graph-based models such as LightGCN are highly efficient. LLM-based models like TallRec and AllmRec incur extreme training overhead, requiring up to 19,800 minutes (\(\approx\)​330 hours) to process the Video Games dataset due to the massive parameter count and generation costs.

In contrast, RecRec achieves a middle-ground efficiency, completing training in approximately 210 minutes on the same dataset. This represents a reduction in training time of over 98% compared to LLM-based recommenders while maintaining competitive performance through its lightweight iterative refinement loop. These results demonstrate that RecRec provides a scalable architecture for sequential recommendation.

References↩︎