Latent Residual Reasoning for Ranking in Generative Recommendation

CCS Concepts

• Information systems → Recommender systems.

ACM Reference Format: Haihan Shi, Ruidong Han, Wenjie Wang, Shangyu Chen, Sunhao Dai, Yongqi Li, Yangyang Li, Fei Jiang, Wei Lin, Fuli Feng, and Xiangnan He. 2026. Latent Residual Reasoning for Ranking in Generative Recommendation. In Proceedings of the 35th ACM International Conference on Information and Knowledge Management (CIKM ’26), November 7–11, 2026, Rome, Italy. ACM, New York, NY, USA, 12 pages. https://doi.org/10.1145/3799682.3841103

Introduction

In the era of information explosion, recommender systems have become fundamental components of online web platforms [4, 11], 20, 29, 30, 43, 44] by providing users with personalized item suggestions. Among various recommendation architectures, generative recommendation (GR) [6, 10, 11, 16, 27, 30, 37, 39, 43] has garnered significant interest from both academia and industry.

For the ranking task in recommendation, some GR methods [11, 30, 43] employ a discriminative loss for modeling, utilizing a streamlined Transformer [35] architecture. In the setting considered in this work, user context and explicit candidate items are organized into a shared token sequence, while a candidate mask enables parallel candidate scoring without information leakage across candidates. This approach improves system utilization during both training and inference and has shown strong effectiveness in large-scale recommendation systems. However, these methods predominantly adopt a fast-thinking direct prediction paradigm, where the final result is obtained through a single inference step. Since ranking requires fine-grained scoring over candidate items, a key question is whether additional inference-time computation can further refine these scores beyond one-shot prediction.

Inspired by the success of the Chain-of-Thought [40] (CoT) mechanism in Large Language Models [1, 24] (LLMs), recent work has begun exploring the integration of reasoning into recommendation models by introducing multiple intermediate reasoning steps before generating final recommendations. Some of these methods [3, 7, 8] employ LLMs as recommendation models and introduce mechanisms analogous to explicit CoT in LLM, allowing the recommender to perform reasoning in textual space before generating final recommendations. However, such methods are highly dependent on the reasoning techniques inherent in LLMs [18], which come with a significant computational overhead [31]. In addition, LLMs have not completely replaced more widely deployed non-textual recommendation models, limiting the applicability of these approaches in widely deployed ranking scenarios. Therefore, a more practical direction is to introduce latent reasoning [12], i.e., multi-step computation in continuous latent space, into widely used Transformer-based recommendation models, including ID-based recommendation settings. Existing attempts along this direction target autoregressive semantic-ID generation [22] or refine user representations for next-item recommendation [25, 28, 32, 33, 41] with Transformer-based recommenders [14, 17]. These task interfaces differ from ranking with explicit candidates, where user context and candidate items are jointly encoded to directly produce candidate scores. The OnePiece framework [5] further demonstrates the feasibility of latent reasoning in industrial ranking through block-wise candidate-representation refinement and progressive multi-task supervision.

Despite this progress, designing latent reasoning for fine-grained candidate scoring raises three challenges. First, latent reasoning must be aligned with the learning objective of candidate ranking. Whereas semantic-ID generation and next-item recommendation optimize different objectives, ranking requires fine-grained scores for explicit candidates. Therefore, successive reasoning steps should be formulated and supervised to progressively improve candidate scores under the ranking objective. Second, in the ranking process, multiple candidate items are scored simultaneously. An intuitive solution is to independently assign one or more reasoning tokens to each candidate item, which we refer to as the candidate-specific reasoning process. However, such a design may fail to effectively

leverage global user information, which plays a central role in existing retrieval-oriented latent reasoning. Third, existing latent reasoning frameworks predominantly rely on end-to-end training, which requires replacing or retraining well-established online recommenders and thus limits practical applicability. Consequently, another critical challenge is how to enable latent reasoning through parameter-efficient adaptation with minimal disruption.

To address the above challenges, we propose Refiner, a latent Residual reasoning framework with parameter-efficient finetuning for ranking in generative recommendation. To align latent reasoning with the ranking objective, we design a residual latent reasoning mechanism that performs additive refinement in score space. Instead of predicting full scores from scratch at each step, Refiner estimates corrections to the preceding predictions and accumulates them for final ranking. To complement the candidate-specific reasoning process, we further introduce history queries to provide condensed user behavior representations that supply a global view of user interests during candidate-specific reasoning. Finally, we develop a parameter-efficient fine-tuning framework by freezing the pre-trained base model and introducing lightweight LoRA [15] modules together with a dedicated reasoning prediction layer, which together enable latent reasoning with minimal disruption to existing recommender systems. We implement Refiner on two ranking models, including the deployed industrial GR model MTGR [11]. Extensive experiments on two public benchmarks validate its general effectiveness. Furthermore, Refiner demonstrates consistent improvements on a large-scale offline industrial dataset and in an online A/B test within an industrial setting. We also observe notable gains in scenarios involving cold-start items and long-sequence users with complex behavioral patterns. The contributions of this work are summarized as follows:

• We investigate latent reasoning for fine-grained score refinement in generative ranking beyond direct one-shot prediction.

• We propose Refiner, a residual latent reasoning framework for generative ranking that combines multi-step residual score refinement, candidate-specific reasoning with history queries, and parameter-efficient fine-tuning.

• Extensive experiments on two public datasets, a large offline industrial dataset, and an online A/B test demonstrate consistent improvements, validating the effectiveness and practical utility of Refiner in real-world recommendation scenarios.

Preliminary

In the ranking stage of recommender systems, recommendation models take user-side and candidate item information as input to produce interaction scores for each candidate item across multiple downstream tasks such as Click-Through Rate (CTR) and Click-Through Conversion Rate (CTCVR) prediction. Unlike traditional approaches [9, 21, 46], GR ranking models formulate the ranking task as a sequential transduction task [11, 43] that organizes input data as a token sequence and processes information in a temporal manner, while simultaneously scoring multiple candidate items within a single forward pass. This design improves gradient estimation robustness during training and enables efficient multi-candidate scoring during inference.

Formally, for a user with profile features and behavior sequences, along with $K$ candidate items, the input data is organized as:

• User profile features: $U = [U^1, \ldots, U^{N_U}]$, where $N_U$ denotes the number of user profile features.

• User historical interaction sequence: $\vec{S} = [S^1, \ldots, S^{N_S}]$, where $N_S$ represents the sequence length.

• Candidate item features: $I = [I_1, \ldots, I_K]$, where $I_i$ represents the $i$-th candidate and $K$ is the number of candidates.

The embedding module $\mathcal{E}$ projects all categorical and numerical features into dense vector representations through an embedding process:

These embedded features are then unified into a single token sequence:

where $L$ is the total sequence length and $d$ is the embedding dimension.

To enable simultaneous scoring of multiple candidates while preventing information leakage between them, generative ranking employs a candidate mask $M \in\{0,1\}^{L \times L}$ in the attention mechanism. This mask ensures that all candidate items can attend to all user-side information while prohibiting attention between different candidate items. The masked token sequence is then processed by Transformer blocks $\mathcal{T}$:

Finally, the model selects the output representations corresponding to candidate item positions and passes them through a prediction module $\mathcal{P}$:

where $S$ contains the task-specific prediction scores for all $K$ candidates across $T$ different tasks. The base model is optimized with Binary Cross-Entropy (BCE) supervision over the task labels:

where $L \in\{0,1\}^{K \times T}$ denotes the corresponding ground truth labels.

Based on this formulation, latent reasoning introduces additional computation in continuous hidden space without generating textual traces. Refiner uses the resulting states to produce successive corrections to the candidate scores, as described in the following section.

Method

In this section, we propose Refiner, a residual latent reasoning framework with parameter-efficient fine-tuning for generative ranking recommender systems. The framework consists of three core components: (1) Input Construction with reasoning tokens and history queries, (2) Parameter-efficient Fine-tuning Framework, and (3) Residual Reasoning for progressive score refinement and optimization.

Input Construction

To enable latent reasoning in generative ranking, we extend the input sequence by introducing reasoning tokens and history queries. The key idea is to support candidate-specific latent computation while preserving access to shared user context, which is important for ranking multiple candidates in parallel. Accordingly, reasoning tokens are used to carry candidate-specific intermediate states, while history queries provide a compact representation of global user behavior during the reasoning process.

The initial input sequence is constructed as:

where $L$ is the sequence length, $d$ is the embedding dimension, and $M_0$ is the original candidate mask that prevents information leakage between candidate items.

Reasoning Tokens. For each reasoning step $r \ge1$, we append $K$ reasoning tokens $E_{R_r}$ to the sequence, each corresponding to a candidate item. These tokens are generated auto-regressively from the previous step’s output. Specifically, for step $r$, the reasoning tokens $E_{R_r}$ are obtained from the last $K$ positions of the output hidden states $H_{r-1}$ of the previous step, where $H_{r-1}$ is computed as:

This iterative process enables candidate-specific latent reasoning conditioned on user-side information and previous reasoning states.

History Queries. To enrich the reasoning process with condensed user context, we introduce history queries $E_{HQ}$ from the user historical sequence. We first process the initial sequence $X_0$ with the Transformer $\mathcal{T}$ to obtain output hidden states:

Then, we extract the output representations from the last $N_{HQ}$ positions of the user historical sequence segment (i.e., the part corresponding to $E_S$) to form the history queries:

where $\mathrm{start}_{HQ}$ and $\mathrm{end}_{HQ}$ denote the start and end indices of the last $N_{HQ}$ tokens in $E_S$. This fixed set of history queries captures condensed user behavior information and is reused across all reasoning steps.

The input sequence for the $r$-th reasoning step ($r \ge1$) is constructed by concatenating the initial features, history queries, and all reasoning tokens up to step $r$:

For the mask configuration at step $r$, we extend the original candidate mask $M_0$ to form $M_r$. Specifically, the mask ensures that:

• Each reasoning token at step $r$ can attend to all user-side information ($E_U$, $E_S$, $E_{HQ}$), its corresponding candidate item, and all previous reasoning tokens from steps $1$ to $r-1$ for the same candidate to prevent information leakage.

• History queries follow the same attention pattern as $E_S$, with a causal mask applied within the $E_{HQ}$ segment to maintain temporal consistency.

An example of the reasoning mask is presented in Figure 1.

Parameter-efficient Fine-tuning Framework

Since deployed ranking models are often well-established and costly to fully retrain or replace, Refiner introduces latent reasoning through lightweight adaptation rather than end-to-end replacement. To this end, we propose a fine-tuning framework that freezes most parameters of a pre-trained base model and introduces only a small set of trainable components. Let the pre-trained base model consist of an embedding module $\mathcal{E}_{\mathrm{pretrain}}$, Transformer blocks $\mathcal{T}_{\mathrm{pretrain}}$, and a prediction layer $\mathcal{P}_{\mathrm{pretrain}}$. During fine-tuning, we freeze these components to preserve the original ranking behavior of the base model and avoid unnecessary interference.

We then enhance the model with two additions:

• LoRA-Enhanced Transformer: We integrate Low-Rank Adaptation [15] (LoRA) into the Transformer blocks, creating an enhanced version $\mathcal{T}_{\mathrm{reasoning}} = \mathcal{T}_{\mathrm{pretrain}} + \operatorname{LoRA}(\mathcal{T}_{\mathrm{pretrain}})$. This introduces a small number of trainable parameters while keeping the pre-trained backbone frozen.

• Reasoning Prediction Layer: We add a dedicated prediction layer $\mathcal{P}_{\mathrm{reasoning}}$ for the reasoning steps, which is trained to output residual scores.

The reasoning process involves a roll-out mechanism for generating reasoning tokens and history queries:

• For the first reasoning step ($r = 1$), we use the frozen $\mathcal{T}_{\mathrm{pretrain}}$ to process the initial input $X_0$ and obtain $H_0 = \mathcal{T}_{\mathrm{pretrain}}(X_0, M_0)$. We then extract history queries $E_{HQ}$ from the user historical segment of $H_0$ (as described in Section 3.1) and first-step reasoning tokens $E_{R_1}$ from the last $K$ positions of $H_0$.

of $H_0$ (as described in Section 3.1) and first-step reasoning tokens $E_{R_1}$ from the last $K$ positions of $H_0$.

• For subsequent reasoning steps ($r \ge2$), we use the enhanced $\mathcal{T}_{\mathrm{reasoning}}$ to process the previous input $X_{r-1}$ and obtain $H_{r-1} = \mathcal{T}_{\mathrm{reasoning}}(X_{r-1}, M_{r-1})$. We then extract the next reasoning tokens $E_{R_r}$ from the last $K$ positions of $H_{r-1}$.

This design enables latent reasoning through parameter-efficient adaptation, while preserving the deployed base ranker and minimizing disruption to existing recommender systems.

Residual Reasoning

The residual reasoning component aims to progressively refine prediction scores through multiple reasoning steps. In ranking tasks, small but precise score adjustments can be important for final candidate ordering. Therefore, instead of re-predicting the full scores from scratch at each reasoning step, Refiner models latent reasoning as an additive score correction process over the pre-trained model output.

Let $S_0$ denote the initial score matrix from the pre-trained model, computed as:

where $\mathcal{T}_{\mathrm{pretrain}}(X_0, M_0)[-K:]$ refers to the output hidden states at the candidate positions.

For each reasoning step $r \ge1$, we compute a refinement score matrix $S_r$ as follows:

• The input sequence $X_r$ (constructed as in Section 3.1) is processed by the enhanced Transformer $\mathcal{T}_{\mathrm{reasoning}}$ to obtain hidden states:

• The output representations at the candidate positions (i.e., the last $K$ positions of $H_r$) are passed through the reasoning prediction layer $\mathcal{P}_{\mathrm{reasoning}}$ to yield $S_r$:

The cumulative refined score up to step $r$ is defined as the sum of the initial score and all refinement scores from step 1 to $r$:

Each reasoning step is trained to reduce the remaining prediction error through this cumulative score refinement process. Since the reasoning head predicts continuous additive score corrections, we optimize the refinement objective using the mean squared error (MSE) between $S_{\mathrm{cum},r}$ and the ground truth label matrix $L \in\{0,1\}^{K \times T}$:

The total loss for all reasoning steps (from $r = 1$ to $R_{\mathrm{steps}}$, where $R_{\mathrm{steps}}$ is the total number of reasoning steps) is the sum of the individual MSE losses:

This residual optimization encourages each reasoning step to incrementally reduce the remaining prediction error, enabling progressive score refinement for ranking tasks.

The overall training framework of Refiner is illustrated in Figure 2 with $N_{\mathrm{HQ}} = 2$, $R_{\mathrm{steps}} = 2$ and $K = 2$. During the residual reasoning phase, Refiner enhances the pre-trained model by incorporating LoRA modules and an additional prediction head $P_{\mathrm{reasoning}}$ for latent reasoning fine-tuning. The black arrows represent the direct prediction pathway, where Refiner utilizes the fully frozen base model to obtain initial scores requiring refinement, along with the representations used to construct $E_{R_1}$ and $E_{\mathrm{HQ}}$. During reasoning steps 1 and 2, Refiner auto-regressively derives subsequent reasoning tokens through $T_{\mathrm{reasoning}}$ and performs residual score correction.

Experiments

We conduct extensive experiments and analyses on public and industrial datasets to answer the following research questions:

• RQ1: How does Refiner perform compared to strong baselines, including latent reasoning methods?

• RQ2: How do the different components of Refiner affect the performance?

• RQ3: How robust is Refiner across different user and item groups?

• RQ4: How do key hyperparameters (i.e., the number of history queries and total reasoning steps) affect the performance and inference-time overhead of Refiner?

• RQ5: How effective and practical is Refiner in real-world industrial scenarios?

Experimental Setting

Datasets. To validate the effectiveness of our proposed Refiner framework, we conduct experiments on two widely adopted public datasets and one real-world large-scale industrial dataset. The dataset statistics are summarized in Table 1.

Datasets	# User	# Item	# Interaction	Avg. Length
Steam	33,327	14,377	1.4 million	43
MovieLens10M	3,558	10,680	10 million	506
Industrial	70 million	4 million	2 billion	1363

• Public Datasets. We choose two publicly available real-world datasets for experiments. (1) Steam [17] contains extensive user interactions with video games on the Steam platform. (2) MovieLens10M [13] is a widely used dataset for movie recommendation, containing diverse and complex user-movie interactions. For both datasets, we chronologically sort user interactions based on timestamps and partition them into training, validation, and test sets with a ratio of 8:1:1 [23, 26, 38]. In all three splits, each positive interaction is paired with one randomly sampled negative item following previous work [26, 36], yielding a candidate set of $K = 2$;

the same construction is used for training and evaluation. We use only item IDs and item category IDs as the discrete features for both user interaction sequences and candidate items.

• Industry Dataset. To validate the effectiveness of our method in real-world recommendation scenarios, we construct an industrial-scale dataset from exposure logs of a deployed industrial recommender system following previous work [11]. The request-level candidate-set sizes follow the logged production pipeline rather than a Refiner-specific fixed $K$. For offline experiments, we use one full day of data for training and a portion of the subsequent day’s data for testing. The same candidate construction is used for offline training and evaluation. For online experiments, we use a 14-day dataset, where the first 7 days are used to warm up Refiner and the subsequent 7 days serve as the online observation period while Refiner is updated following the MTGR update schedule. It is worth noting that user interaction history is further divided into long-term historical interactions and short-term real-time interactions in this industrial dataset. However, this distinction does not affect the application of our method.

4.1.2 Backbone and Baseline. We implement our proposed Refiner framework on MTGR [11], a deployed industrial GR model that has demonstrated significant business impact in production, to validate its practical utility and effectiveness. To further demonstrate the robustness of Refiner, we introduce SASRec-ranking, a ranking backbone adapted from SASRec [17]. Specifically, we implement the encoding of the aforementioned features and modify the original attention mask into a candidate mask to adapt SASRec to the ranking stage. We further include several representative traditional point-wise ranking models, xDeepFM [21] and DIN [46], to validate the effectiveness of MTGR and SASRec-ranking. We include ReaRec [33] as a representative latent reasoning baseline originally designed for retrieval. ReaRec models user representation learning as a latent reasoning process over item sequences, where iterative reasoning refines the user representation for item matching. Since it does not explicitly model multiple candidate items in one forward pass, we adapt it to ranking by appending candidate items to the input sequence and extending its attention mechanism for multi-candidate scoring without information leakage across candidates, enabling a fair comparison in the ranking scenario.

4.1.3 Evaluation Metrics. We focus on two prediction tasks, CTR and CTCVR, on the industrial dataset following [11], and frame the ranking task as CTR prediction on the public datasets [36]. We adopt AUC and Group AUC (GAUC) to evaluate model performance. GAUC is calculated by averaging user-level AUC, offering a more detailed assessment of ranking quality.

4.1.4 Implementation Details. All experiments use NVIDIA A100 GPUs and 3 random seeds. For MTGR in the offline industrial experiments, we adopt the architecture with 3 Transformer blocks, 2 attention heads, and an embedding dimension of 512 following [11]. We use smaller model sizes for MTGR and SASRec-ranking on the public datasets to avoid overfitting. For traditional CTR models, we adjust the embedding dimension among $\{32, 64, 128, 256, 512\}$. The learning rate $\eta$ for MTGR and traditional recommender models is tuned over $\{1 \times10^{-4}, 5 \times10^{-4}, 1 \times10^{-3}\}$. For our proposed Refiner framework, we perform a hyperparameter search for the LoRA rank $r$ over $\{32, 64, 128\}$ and its corresponding scaling factor $\alpha$ over $\{64.0, 128.0, 256.0\}$. The number of history sequences $N_{\mathrm{HQ}}$ is selected from $\{0, 1, 2, 4, 8, 16\}$. Regarding the online experiments, we additionally construct an incremental update framework. This framework leverages a warm-start strategy, where each day’s Refiner model is initialized from the previous day’s Refiner checkpoint and the current day’s MTGR checkpoint. During each daily Refiner update, the corresponding MTGR checkpoint is kept frozen, while only the additional Refiner parameters are optimized on the current day’s data. In this way, Refiner is updated following the MTGR update schedule. A detailed explanation of the online update framework is provided in § 5.4.

Overall Performance (RQ1)

We conduct extensive comparisons among traditional ranking models, GR backbones, and latent reasoning methods instantiated on both MTGR and SASRec-ranking. The experimental results on public datasets are presented in Table 2, while the industrial dataset results are shown in Table 3. In the main experiments, the total number of reasoning steps is fixed to 1, and the impact of varying this hyperparameter is further analyzed in § 5.3. From Table 2 and Table 3, we have the following key observations:

Method	Steam				MovieLens10M
	AUC		GAUC		AUC		GAUC
	Mean	Std	Mean	Std	Mean	Std	Mean	Std
xDeepFM	0.6560	0.0013	0.6501	0.0015	0.6433	0.0015	0.5919	0.0011
DIN	0.7522	0.0017	0.7261	0.0013	0.6583	0.0016	0.6369	0.0019
SASRec-ranking	0.7450	0.0015	0.7342	0.0012	0.6935	0.0018	0.6651	0.0019
SASRec-ranking+ReaRec	0.7494	0.0011	0.7394	0.0017	0.6988	0.0014	0.6705	0.0013
SASRec-ranking+Refiner	$0.7511^{*}$	0.0016	$0.7415^{*}$	0.0014	$0.7022^{*}$	0.0010	$0.6742^{*}$	0.0015
Improv.	($\uparrow$ 0.8%)	–	($\uparrow$ 1.0%)	–	($\uparrow$ 1.3%)	–	($\uparrow$ 1.4%)	–
MTGR	0.7698	0.0025	0.7397	0.0023	0.7674	0.0021	0.6755	0.0025
MTGR+ReaRec	0.7785	0.0028	0.7443	0.0021	0.7719	0.0024	0.6827	0.0027
MTGR+Refiner	$0.7872^{*}$	0.0027	$0.7594^{*}$	0.0029	$0.7864^{*}$	0.0022	$0.7043^{*}$	0.0029
Improv.	($\uparrow$ 2.3%)	–	($\uparrow$ 2.7%)	–	($\uparrow$ 2.5%)	–	($\uparrow$ 4.3%)	–

Method	CTR				CTCVR
	AUC		GAUC		AUC		GAUC
	Mean	Std	Mean	Std	Mean	Std	Mean	Std
MTGR	0.7404	0.0003	0.6909	0.0002	0.8553	0.0002	0.7046	0.0003
MTGR+ReaRec	0.7410	0.0003	0.6913	0.0002	0.8567	0.0003	0.7054	0.0003
MTGR+Refiner	$0.7417^{*}$	0.0004	$0.6920^{*}$	0.0003	$0.8574^{*}$	0.0003	$0.7061^{*}$	0.0003
Improv.	($\uparrow$ 1.8‰)	–	($\uparrow$ 1.6‰)	–	($\uparrow$ 2.5‰)	–	($\uparrow$ 2.1‰)	–

• On public datasets, MTGR and SASRec-ranking generally achieve substantial performance gains over traditional recommender systems. Specifically, as shown in Table 2, MTGR substantially outperforms xDeepFM and DIN on both Steam and MovieLens10M, demonstrating the effectiveness of GR backbones for ranking tasks.

• Both evaluated latent-reasoning extensions, i.e., ReaRec and Refiner, improve their corresponding direct-prediction backbones across the public and industrial datasets. In industrial practice, an improvement of 1‰ is generally considered meaningful. For example, on the CTR GAUC metric, the observed gain yields a paired t-test $p$-value of 0.008, confirming its statistical significance. These results show that the evaluated extensions provide gains beyond direct prediction in our settings.

• Refiner consistently achieves higher AUC and GAUC than the adapted ReaRec baseline on both public and industrial datasets. Together with the component analysis in § 5, these results support the effectiveness of Refiner’s ranking-oriented design in the evaluated settings.

Remark. The smaller numerical gains on the industrial dataset are likely due to the fact that Refiner is built on top of an already deployed recommender in a large-scale production environment, where the remaining room for improvement is naturally more limited than on public benchmarks. Nevertheless, these consistent offline gains remain meaningful in practice, and their practical value is further supported by the online results in § 5.4.

Further Analysis

In this section, we conduct a more detailed investigation of the proposed Refiner framework. Specifically, in § 5, we perform ablation studies to examine the impact of removing individual components (RQ2). In § 5.1, we analyze Refiner’s performance across different user behavior sequence lengths and item popularity groups in the test set to demonstrate its robustness (RQ3).

Furthermore, § 5.2 and § 5.3 investigate the effects of the number of history queries $N_{\mathrm{HQ}}$ and reasoning steps $R_{\mathrm{steps}}$ on both model performance and inference-time overhead (RQ4), providing guidance for applying Refiner in real-world systems.

Ablation Study (RQ2)

We systematically evaluate the effectiveness of individual components in the Refiner framework on the Steam dataset through ablation studies. Specifically, we examine the following variants: removing history queries (w/o H.Q.), removing the LoRA adaptation in $\mathcal{T}_{\mathrm{reasoning}}$ (w/o LoRA), removing residual reasoning (w/o Residual), i.e., replacing the residual refinement objective with direct prediction supervision using BCE loss at each reasoning step, and an End-to-End training framework that directly optimizes the initialized model with both $\mathcal{L}_{\mathrm{Base}}$ and $\mathcal{L}_{\mathrm{reasoning}}$ without the additional LoRA module and $\mathcal{P}_{\mathrm{reasoning}}$. The corresponding results are summarized in Table 4.

Method	CTR
	AUC	(Dec.)	GAUC	(Dec.)
Refiner	0.7872	-	0.7594	-
w/o H.Q.	0.7764	($\downarrow$ 1.4%)	0.7495	($\downarrow$ 1.3%)
w/o LoRA	0.7841	($\downarrow$ 0.4%)	0.7413	($\downarrow$ 2.4%)
w/o Residual	0.7763	($\downarrow$ 1.4%)	0.7523	($\downarrow$ 0.9%)
End-to-End	0.7650	($\downarrow$ 2.8%)	0.7316	($\downarrow$ 3.7%)

The experimental results in Table 4 show that: (1) removing any evaluated component leads to performance degradation, supporting the effectiveness of the complete Refiner framework. (2) Removing history queries degrades performance, suggesting that compact global user context contributes to candidate-specific reasoning in the evaluated setting. (3) Under the evaluated reasoning architecture, replacing residual refinement with direct BCE supervision at each step yields lower performance, supporting the cumulative residual formulation over this direct-prediction alternative. (4) The End-to-End variant performs worst among the evaluated variants, suggesting that directly optimizing the full model may weaken the functional separation between base prediction and reasoning refinement.

Group Analysis (RQ3)

To evaluate the robustness of the proposed Refiner framework, we conduct a group-wise analysis by partitioning users and items into distinct subgroups. Specifically, users are categorized into three equal-sized groups based on their behavior sequence length, with higher group indices corresponding to longer sequences. Similarly, items are grouped into three categories based on interaction frequency, where higher indices denote more popular items. Each item group is balanced to contain an equal number of samples following established practice [33]. The results are depicted in Figure 4.

From Figure 4, we make the following observations: (1) As user sequence length increases, MTGR’s performance gradually declines. This phenomenon may stem from the fact that longer user histories often involve more complex behavioral patterns and more long-tail items, which increase the difficulty of ranking. Refiner consistently improves performance across all user groups, demonstrating its robustness in handling users with different history lengths through candidate-specific latent refinement conditioned on user context. (2) MTGR’s performance deteriorates as item popularity decreases. This trend is consistent with the general difficulty of modeling cold-start or less frequent items in recommender systems. Refiner consistently improves performance across all item groups, with the most pronounced gains on the least popular item group. This suggests that Refiner is particularly helpful when the base recommendation model has less reliable item representations and there is more room for refinement. For high-popularity items, the backbone model can already capture strong collaborative signals from sufficient interaction data, leaving less room for additional refinement. As a result, the relative gains from Refiner are smaller on the most popular items.

Impact of History Queries Number (RQ4)

To systematically investigate the impact of the number of history queries $N_{\mathrm{HQ}}$ on both model performance and inference-time overhead, we conduct a sensitivity study by varying $N_{\mathrm{HQ}} \in\{0, 1, 2, 4, 8, 16\}$ while fixing the number of reasoning steps to 1 and keeping all other parameters unchanged. The corresponding performance metrics (AUC and GAUC) and relative inference latency (RIL) are presented in Figure 3(a). Here, RIL is computed relative to the baseline configuration with $N_{\mathrm{HQ}} = 0$ and one reasoning step, providing a normalized measure of the additional inference overhead introduced by different history-query settings.

From Figure 3(a), we observe two key findings: (1) A moderate number of history queries (e.g., $N_{\mathrm{HQ}} = 2$ or 4) achieves the best performance. When $N_{\mathrm{HQ}}$ is too small, the reasoning process has limited access to condensed global user context, which weakens refinement quality. In contrast, excessively large $N_{\mathrm{HQ}}$ may introduce redundant history signals and make the refinement process less focused. (2) Introducing a small number of history queries incurs limited relative overhead in the current implementation, with RIL remaining below 1.1 compared to the baseline. These results support the effectiveness of history queries in the evaluated setting, showing that a small number of compact user-context tokens provides useful global information with limited relative overhead.

Impact of Total Reasoning Steps (RQ4)

In this section, we investigate the impact of the total number of reasoning steps $R_{\mathrm{steps}}$ on both model performance and inference-time overhead. Specifically, we vary $R_{\mathrm{steps}} \in\{1, 2, 3, 4\}$ during both training and inference, and present the results in Figure 3(b). Here, RIL is calculated relative to the one-shot prediction of the MTGR backbone. From Figure 3(b), we observe that Refiner achieves clear performance improvements over the base model when using a small number of reasoning steps. This result indicates that a limited amount of multi-step latent refinement is already effective for improving ranking quality beyond direct one-shot prediction. However, as the number of reasoning steps continues to increase, the additional gains quickly diminish, a trend that is also observed in [32, 33]. To further analyze this behavior, we visualize the average relative ratio (ARR) between the absolute residual score magnitude at each reasoning step and the absolute magnitude of the initial direct prediction scores, together with the incremental performance improvement per step relative to the previous step (IRS) in the 4-step reasoning model, as shown in Figure 5. The results show that the magnitude of residual scores progressively decreases as the reasoning process deepens, indicating that later steps contribute only limited additional adjustments to the initial predictions. Combined with the steadily increasing inference latency, these findings suggest that 1 or 2 reasoning steps are sufficient in our evaluated settings to achieve a favorable trade-off between performance gains and inference-time overhead.

Remark. The reported RIL reflects the current implementation of Refiner. Since the additional reasoning passes have not undergone dedicated serving-level optimization, these relative measurements should not be interpreted as a general end-to-end efficiency comparison with fully optimized production rankers.

Online Experiments (RQ5)

To further evaluate the practical utility of Refiner in a real-world industrial setting, we deploy Refiner on top of the 15-layer online MTGR model in a large-scale online recommendation platform. Online candidates are supplied by the upstream retrieval stage, and the same pipeline-defined candidate construction is used for training and evaluation. In the online setting, Refiner uses a single reasoning step due to latency considerations, following the offline trade-off between effectiveness and inference-time overhead. We conduct an online A/B test on a 1% production traffic bucket, with the production MTGR model as the control and MTGR+Refiner as the treatment. The experimental traffic covers millions of exposures per day, providing a reliable basis for online evaluation. To align Refiner with the daily update pipeline of the deployed system, we build an incremental update framework, as illustrated in Figure 6. Specifically, each day’s Refiner is initialized from the previous day’s Refiner checkpoint together with the current day’s MTGR checkpoint. During each daily Refiner update, the corresponding MTGR checkpoint is kept frozen, while only the additional parameters of Refiner are optimized on the current day’s data. Following this incremental framework, we first warm up Refiner for 7 days and then conduct A/B testing over a subsequent 7-day observation window, during which Refiner remains updated following the online MTGR model schedule.

As shown in Table 5, Refiner achieves consistent online gains over MTGR during the 7-day experimental window, with PV-CTR increasing by 0.75%, UV-CTCVR increasing by 0.21%, and GMV increasing by 0.46%. These results demonstrate that Refiner can be effectively integrated into a real-world recommender system and deliver meaningful business improvements on top of an already deployed strong ranker. For completeness, we provide the daily performance trend over the 7-day observation window in Appendix A.1, which further illustrates the stability of the online gains.

Metric	PV-CTR	UV-CTR	UV-CTCVR	Order-Number	GMV
Impr.	+0.75%	+0.12%	+0.21%	+0.19%	+0.46%

Related Work

Generative Recommendation

Generative Recommendation (GR) [6, 11, 16, 27, 30, 37, 43] has emerged as a promising paradigm by reformulating recommendation as a sequence transduction problem. Existing GR research can be broadly divided into two categories based on tokenization strategies and training objectives. The first category [6, 27, 37] emphasizes semantic item identification, where items are tokenized into discrete semantic codes for autoregressive generalization. Representative works such as TIGER [27] leverage RQ-VAE [19] to tokenize items into hierarchical semantic IDs for autoregressive item prediction. The second category [11, 16, 43] focuses on encoding item features into dense embeddings while adopting discriminative training objectives. Representative works in this line have demonstrated strong performance in large-scale recommendation settings. In ranking variants, user context and explicit candidate items are jointly encoded to produce candidate scores through parallel processing. Our work builds on this paradigm and introduces latent reasoning for progressive score refinement.

Reasoning for Recommendation

Reasoning-enhanced recommendation broadly follows explicit or latent paradigms. Explicit methods [3, 7, 8, 42] use LLMs [2, 34] to generate textual reasoning chains, but incur substantial inference overhead. Latent methods instead perform multi-step computation in continuous hidden spaces [5, 22, 25, 28, 32, 33, 41, 45]; for example, Latent$R^{3}$ [45] optimizes compact latent reasoning in LLM-based recommenders through reinforcement learning.

Within the latent paradigm, existing methods target different recommendation interfaces and learning objectives. CARE [22] refines autoregressive semantic-ID generation, whereas ReaRec, CaLR, and related methods [25, 28, 32, 33, 41] refine user representations for next-item recommendation. OnePiece [5] covers retrieval and ranking through grouped candidate interaction and progressive supervision. Its full ranking configuration trains a set-wise backbone end to end, allows interaction among candidates, and uses contextual inputs defined by the business setting. Refiner instead formulates each reasoning step as an additive correction to candidate scores, while preserving isolated candidate processing and training only lightweight modules.

Conclusion and Future Work

This work investigates latent reasoning for fine-grained candidate scoring in generative ranking. To address the key design challenges, Refiner incorporates three components: (1) a residual reasoning mechanism that accumulates score corrections across reasoning steps to align latent computation with the ranking objective; (2) history queries that retain compact global user context during candidate-specific reasoning; and (3) a parameter-efficient fine-tuning framework that adapts established ranking backbones without retraining the full model. Experiments on two public datasets, a large-scale offline industrial dataset, and an online A/B test show consistent improvements over the evaluated baselines, while further analyses indicate gains across different user and item groups.

For future work, one promising direction is adaptive reasoning depth selection. Refiner currently applies a fixed reasoning depth to all instances, although simple cases may require fewer refinement steps while harder cases may benefit from additional computation. Future work may investigate adaptive depth allocation or stopping mechanisms that balance refinement quality and inference cost.

Limitations. The evaluation has two main limitations. (1) Differences in task interfaces and backbone requirements restrict the number of directly comparable methods for latent reasoning. (2) A fair comparison with OnePiece [5] requires a backbone that supports interaction among candidates and contextual inputs defined by its business setting, which are unavailable in our current production setup. Nevertheless, the industrial offline results and online A/B test provide evidence of Refiner’s practical effectiveness in the evaluated production setting.

Acknowledgments

This work was supported by the Open Innovation Program for jointly trained master’s-to-doctoral students at the Institute of Computing Technology, Chinese Academy of Sciences (2024-02-KF-LH-01).

Additional Online Performance Analysis

Daily Online Performance Trend

As shown in Figure 7, the relative gains in PV-CTR and UV-CTCVR remain positive throughout the 7-day observation window rather than being driven by a single day. Despite mild fluctuations under evolving traffic and model checkpoints, the overall trend supports the stability of Refiner under incremental updates.

GenAI Usage Disclosure

ChatGPT and OpenAI Codex assisted with language refinement, LaTeX checks, and code development and debugging. The authors reviewed and validated all outputs, conducted all experiments, and retain full responsibility.

References