1 Introduction↩︎

In recent years, Transformer-based large language models (LLMs) have pushed the frontier of machine intelligence to unprecedented levels. Driven by massive compute scale and advanced training methodologies, LLMs have come to exhibit two exciting properties that guide us to build more powerful models:

• Scaling property in pre-training: When model size, training data, and compute resources are scaled up, the convergence loss follows a regular, extrapolable decay trend [1], [2]. As scaling proceeds, the evaluation scores across multiple benchmarks improve simultaneously, demonstrating the models’ remarkable semantic understanding and generalization capability.

• Reasoning property in post-training: Following pre-training, the post-training stage further unlocks and refines the model’s advanced capabilities via high-quality Supervised Fine-Tuning (SFT) and Reinforcement Learning (RL) [3]–[6]. Driven by these post-training techniques, LLMs learn to follow CoT-style procedures [7], [8], forming a “think-before-answer” reasoning paradigm. This paradigm significantly enhances their capabilities to solve complex, in-depth problems, as exemplified by the OpenAI o1 [9] and DeepSeek-R1 [10] series.

Inspired by the Scaling and Reasoning properties of LLMs, we are deeply curious about whether these two properties can be further leveraged to push the capability of industrial recommender systems. Driven by this motivation, we have started a series of exploration efforts. For the Scaling property, our OneRec V1/V2 series of generative models [11], [12] have validated the scaling property in industrial recommendation scenarios, contributing significant business gains at Kuaishou. For the Reasoning property, we acknowledge that the recommendation-data-driven OneRec model cannot unlock the reasoning ability on its own. Since the OneRec model is trained exclusively on pure itemic sequential data, it has only learned from flat transition patterns without any underlying logical thinking traces. To elicit the reasoning capabilities, our recent models, OneRec-Think [13] and OpenOneRec [14], have explored introducing interleaved itemic-text recommendation data and general-domain reasoning data. In these two models, we have successfully observed that the “think-before-answer” pattern can be generalized to recommendation tasks, allowing us to inspect the underlying logic of the model and to understand the user’s interests as well as the rationale behind the next-item prediction. However, we also notice an unexpected phenomenon: the thinking mode does not show significant advantages on recommendation benchmarks compared with the non-thinking mode.

To explore the root cause of this unexpected phenomenon, we turn to the multi-modal LLM (MLLM) literature, where a strikingly similar reasoning-mode brittleness has been observed. [15] reveals that when textual and visual modalities are insufficiently aligned, models tend to mechanically “read” surface-level visual text rather than genuinely reason about the underlying visual semantics, providing a compelling indication that deep cross-modal alignment is a prerequisite for authentic thinking. Extending this insight, [16] systematically surveys the perception-to-cognition pathway in MLLMs and concludes that advanced interactive reasoning cannot emerge without first establishing robust perceptual alignment between modalities. Building on this alignment foundation, [17] further demonstrates that, even with aligned modalities, reasoning robustness remains fragile unless the CoT traces themselves are carefully structured, specifically by adopting logically coherent, coarse-to-fine reasoning formats that prevent hallucinations and over-thinking.

Taken together, these works converge on two essential and complementary pillars for unlocking genuine reasoning capability: (i) modality alignment in perception, which grounds perception and prevents the model from operating on hollow surface signals; and (ii) CoT quality in cognition, which provides coherent coarse-to-fine reasoning trajectories and enables a faithful think-before-answer process once alignment is in place.

For generative recommendation, as illustrated in Figure 3, these insights carry a clear implication: enabling a model to truly think about user interests demands both (1) deep alignment in perception between itemic modality and natural-language modality, so that itemic tokens become referable, composable semantic units rather than opaque identifiers; and (2) recommendation-specific and logically fluent CoT structures in cognition that are designed to scaffold deliberate reasoning over user histories and item properties on top of this alignment. These two dimensions serve as the cornerstones for building a powerful reasoning model, where we explicitly strengthen text-item alignment and devise tailored coarse-to-fine reasoning formats to make the model genuinely capable of recommendation-oriented thinking.

In light of the above, we propose OneReason, a recommendation foundation model with genuine reasoning capability. Specifically, for better item perception ability, we collect complex and diverse coarse-to-fine alignment pre-training corpora to align the newly inserted itemic tokens with text tokens in the same semantic space. For better reasoning cognition ability, we elaborate a standard thinking structure to ensure CoT quality and build the SFT corpora. Moreover, building on the model after pre-training and SFT, we find that the thinking mode still underperforms the non-thinking mode under multi-domain mixed RL, yet consistently surpasses it when RL is restricted to a single domain. This contrast motivates us to adopt a “specialize-then-unify” RL strategy - we first conduct domain-focused RL to fully unlock thinking-mode benefits within each domain, and then apply rejection sampling fine-tuning [18] or Multi-Teacher On-Policy Distillation [19] for cross-domain balancing and refinement. The overall training process of OneReason is visualized in Figure 2. Meanwhile, we also make an interesting observation: under an equal number of training tokens, adding recommendation CoT supervision can improve non-thinking-mode performance compared with training on pure unCoT data in several domains (see the bottom right panel of Figure 1). We treat this as behavioral evidence that some supervision signals from CoT traces may transfer to direct decoding, rather than as proof that CoT is universally necessary or that the mechanism has been identified.

To evaluate the reasoning ability of our model in recommendation scenarios, we introduce OneReason-Bench, a curated collection of reasoning-oriented recommendation benchmarks. Organized along multiple axes, this benchmark is designed to assess reasoning abilities in a comprehensive and structured manner, and has played a central role in guiding and validating our model development. As illustrated in Figure 1, our OneReason model achieves superior performance across this benchmark, demonstrating its robust reasoning capabilities. To facilitate research on generative recommendation models, we will open-source the OneReason-8B and OneReason-0.8B models and other fine-tuning-related materials to the public.

2 Reasoning Design Philosophy↩︎

Before describing the architecture and training recipes in detail, we first outline the design principle of recommendation reasoning: what is a good CoT trace in recommendation? In classical LLM reasoning tasks involving math, code, or symbolic logic, it is usually assumed that there exist intermediate steps that maintain task constraints and apply relevant world knowledge to logically answer the question step by step. Unlike classical reasoning tasks with a single correct answer, recommendation admits multiple plausible items at once, and the underlying user intent is never directly observable; it must be inferred from a long sequence of historical itemic tokens (where each complete sequence represents some item). Therefore, recommendation reasoning is abductive rather than deductive: it requires hypothesizing latent interest points, modeling how they evolve over time, and using them to justify why specific candidates fit the current context. In other words, a recommendation CoT should select relevant behaviors as hypothesized interest points, compress them into an interpretable preference, model the temporal transitions between these interests, and finally associate the inferred preference state with the recommended item. This distinction motivates our training and evaluation design. We decompose recommendation reasoning into four diagnostic capabilities along two dimensions: (1) Perception (R0), which grounds itemic tokens in their semantic content; and (2) Cognition (R1–R3), which builds progressively deeper reasoning on top of solid perception.

• R0: Perception. Interpreting itemic patterns via their explicit semantic content is the foundational ability; without it, user behavior is uninterpretable.

• R1: Derivation. Reasoning from individual item semantics to item-to-item relations via common-sense or knowledge-based associations; without it, latent interests cannot be extracted from noisy interaction histories.

• R2: Evolution. Reasoning over items of the same latent interest as a temporal process; without it, long-term, short-term, and periodic preferences cannot be modeled.

• R3: Recommendation. Reasoning coherently to produce high-quality decisions across all served domains (e.g., Short-Video, Live-Streaming).

The immediately following section operationalizes this hierarchy as an evaluation instrument, so that the trajectory from pre-training (Section 4) to post-training (Sections 5 and 6) to deployment (Section 9) can be measured at every step against the same diagnostic axes.

3 Benchmark Design for Reasoning Recommendation↩︎

Placing the benchmark before the model description is deliberate: the four-granularity pre-training (Section 4), the compression-then-reasoning SFT (Section 5), and the specialize-then-unify RL (Section 6) are each motivated by specific gaps revealed at the R0–R3 layers of OneReason-Bench. The benchmark therefore functions less as a leaderboard and more as a measurement protocol that justifies, monitors, and ultimately validates every downstream design choice.

While RecIF-Bench in OpenOneRec [14] broadens the evaluation of recommendation foundation models, its reasoning evaluation is still coarse-grained and not sufficiently diagnostic. To address this, we develop OneReason-Bench, extending RecIF-Bench toward multi-level reasoning.

3.1 Task Taxonomy↩︎

OneReason-Bench organizes reasoning-oriented benchmark tasks into a progressive hierarchy: Perception (R0), Derivation (R1), Evolution (R2), and Recommendation (R3). These reasoning layers progress from semantic grounding to relational and temporal reasoning, and finally to integrated recommendation tasks. Table 1 summarizes the taxonomy, and examples are shown in Figure 4.

Unified Task Formulation. All tasks are formulated as sequence generation \(Y=\mathcal{F}(X)\), where \(X\) combines a task instruction \(I\) with a context \(C\) such as itemic patterns, user portraits, or interaction histories. The target \(Y\) can be an itemic pattern, an answer option, a natural-language response, or a structured evolution chain, allowing R0–R3 tasks to share a common generative evaluation protocol.

3.1.1 R0: Perception↩︎

Perception grounds itemic patterns in explicit semantic content, providing the semantic basis for higher-level reasoning and recommendation [14], [20]. We instantiate this layer with three task types:

• Item Understanding: given an item \(i\), the model generates its natural-language description, decoding item semantics from itemic patterns.

• Itemic Pattern Grounding: given a natural-language description, the model grounds it to the corresponding item.

• Item QA: given an item \(i\) and content-grounded multiple-choice options \(\mathcal{O}^{a}\), the model selects the correct option, assessing whether it can use item semantics to answer targeted questions.

3.1.2 R1: Derivation↩︎

Building upon Perception, Derivation evaluates whether the model can reason from individual item semantics to item-to-item relationships under common-sense or knowledge-based associations.

• Item2Item: given a source item \(i\) and a set of candidate items \(\mathcal{O}^{item}\), the model selects the item that best matches the intended item-to-item relation.

3.1.3 R2: Evolution↩︎

Evolution evaluates whether the model can reason over user interests as a temporal process rather than a static preference profile. We design three task variants with increasing autonomy, from extracting topic-relevant actions to generating topic-guided or fully autonomous evolution chains:

• Evolution Action Selection: given a history \(\mathcal{H}\) and a specified interest topic \(t\), the model identifies the historical actions \(\mathcal{A}\) logically connected to that topic.

• Evolution Topic Generation: given a history \(\mathcal{H}\) and a specified interest topic \(t\), the model generates the evolution chain \(\mathcal{E}_t\) describing how this interest developed.

• Evolution Direct Generation: given only the history \(\mathcal{H}\), the model autonomously generates valid interest-evolution chains \(\{\mathcal{E}\}\) without topic guidance.

This layer evaluates multi-hop, temporally structured reasoning about user behavior, providing a bridge from item-level reasoning to context-aware recommendation.

3.1.4 R3: Recommendation↩︎

While the preceding tasks focus on specific R0–R2 capabilities, real-world recommendation scenarios often require models to flexibly combine perception, derivation, and evolution abilities. We therefore introduce integrated recommendation tasks to evaluate the model’s overall reasoning capability in practical recommendation settings. We assess this across two settings:

• Single-Domain Recommendation: given a user portrait \(\mathcal{P}\) and the user’s interaction history \(\mathcal{H}^d\) within a target domain (short video, advertising, e-commerce, or live-streaming¹), the model predicts the next items the user will engage with.

• Cross-Domain Recommendation: given a user portrait \(\mathcal{P}\), the user’s multi-domain interaction history \(\mathcal{H}\), and a specified target domain \(d\), the model predicts the next items in that domain.

Detailed construction procedures, R3 data statistics, and a comparison with existing recommendation benchmarks are provided in Appendix 14.1 and 14.2.

3.2 Evaluation Protocols↩︎

We employ a set of task-specific metrics to cover recommendation accuracy, QA correctness, interest-evolution reasoning, and open-ended generation quality.

3.2.0.1 Text Generation Metrics.

For the Item Understanding task, we reuse the LLM-as-a-Judge protocol introduced in OpenOneRec [14] without modifying its metric definition.

3.2.0.2 Choice and Selection Metrics.

For single-answer choice tasks such as Item QA and Item2Item, we report Accuracy. For multi-answer selection tasks, including Evolution Action Selection, we report F1 computed over the predicted and ground-truth sets.

3.2.0.3 Evolution Generation Metrics.

Evolution Topic Generation and Evolution Direct Generation are evaluated by the Action–Logic Score family. This metric family combines action alignment between the generated and ground-truth evolution chains with logic alignment between the corresponding reasoning statements. The detailed implementation of these metrics is provided in Appendix 14.4.2.

3.2.0.4 Recommendation Metrics.

For recommendation and itemic pattern grounding tasks, we report Pass@\(K\) and Recall@\(K\). Pass@\(K\) indicates whether at least one ground-truth target appears in the top-\(K\) generated outputs, while Recall@\(K\) measures the fraction of ground-truth targets recovered within the top-\(K\) list. The generated itemic patterns are first decoded into item IDs, and metrics are then computed at the item granularity.

3.3 General-Intelligence Sanity Check↩︎

Following OpenOneRec [14], we also retain a general-intelligence sanity-check suite, covering general-purpose tasks such as MMLU-Pro [21], to ensure that recommendation specialization does not come at the cost of general reasoning or instruction-following ability.

With the diagnostic axes (R0–R3) and the general-intelligence guard rail now in place, we are ready to describe the training stack that OneReason-Bench is designed to evaluate. The next section opens with the perception foundation, itemic tokenization and four-granularity pre-training data, that R0 directly probes and on which every higher-order capability is built.

4 Pre-Training Pipeline↩︎

This section details our pre-training methodology. We begin by describing the itemic tokenizer in Section 4.1. Section 4.2 then introduces our core contribution: a four-granularity data system that hierarchically integrates recommendation corpora with general-domain data to achieve deep modality alignment. Section 4.3 systematically ablates each granularity to quantify its specific contribution to the model’s overall performance. Finally, Section 4.4 outlines the three-stage training recipe that operationalizes this data design, from vocabulary warm-up to full-scale training.

4.1 Itemic Tokenizer↩︎

To obtain compact yet semantically grounded item embeddings, we jointly train a multimodal encoder and a decoder LLM on item-understanding tasks. The encoder integrates a Vision Transformer (ViT) [22] and an LLM initialized from the open-source Qwen3-VL [23], together with an audio encoder [24]. It distills rich content signals—including cover images, video frames, text descriptions, and audio—into a compact dense embedding. To optimize the item embedding in an end-to-end manner, we prepend the embedding as a soft prefix to a separate decoder LLM, followed by the item’s text descriptions.

We quantize these embeddings via RQ-KMeans [25]. We use a three-layer codebook, with each layer containing 8192 codes. Each item is thus represented by an itemic pattern consisting of one domain-aware begin token and three sub-tokens. For instance, an itemic pattern is formatted as: \[\text{<|}\texttt{domain}\text{\_begin|><a\_5028><b\_6733><c\_2559>},\] where domain is one of video (video), prod (product), ad (ad), or living (live) for our four recommendation scenarios, or sid for general-domain multimodal data. Unlike OpenOneRec [14], we drop the trailing end token. This reduces the overall context length consumed by itemic patterns, leaving more capacity for the reasoning traces that are essential to our thinking paradigm.

4.2 Pre-Training Data↩︎

Prior generative recommendation works, including OneRec-Think and OpenOneRec, organize pre-training data by task type—item captioning, user behavior sequences, and persona-text interleaving—and mix them for joint training. While this establishes a basic mapping between itemic patterns and natural language, it leaves three structural gaps. First, the semantic expression of items and users tends to be homogeneous, limiting the linguistic diversity the model encounters and weakening representational robustness. Second, the data organization stays at the task level without explicitly modeling the fine-grained semantic hierarchy inside itemic tokens or the relational logic across items. Third, user behavior modeling relies on a narrow conditioning paradigm in which a full user profile maps to a complete behavioral sequence, restricting the model’s ability to generalize across diverse recommendation contexts.

To address these gaps, we restructure the pre-training corpora into four progressive granularities, moving from microscopic token semantics to macroscopic user behavior. This hierarchical design systematically expands the alignment between the textual and itemic modalities along three axes: broader expression diversity; explicit structural reasoning from sub-token composition to inter-item relations; and richer conditioning patterns for user modeling. In the remainder of this section, we detail the construction of both the recommendation corpora and the general-domain corpora that jointly realize this vision.

4.2.1 Recommendation Corpora↩︎

To achieve a deep and seamless fusion between the textual and itemic modality, as shown in Figure 5, we structure our pre-training corpora into four progressive granularities:

• Token Granularity data focuses on individual or compositional sub-itemic-token semantics and achieves modality alignment at the finest granularity.

• Item Granularity data aligns itemic pattern with the textual modality. It pushes cross-modal fusion to the full item level and leverages multi-view tasks and diversified item sources to match complete itemic patterns with comprehensive textual descriptions.

• Relational Granularity data explains the connections between items via natural language. It summarizes the interest-transfer logic of associated items and enables collaborative signals to be encoded into text representations and model parameters.

• User Granularity data accomplishes thorough cross-modal fusion by enabling the model to understand and generate multi-modal content under unified, personalized user contexts.

To empirically validate the enhanced modality alignment afforded by our multi-granularity corpora, we randomly sample a set of items and extract embeddings for both their itemic patterns and textual captions. Each item is paired with its own caption to form a positive pair, while a caption randomly drawn from another item serves as the corresponding negative. Whereas prior work typically reports positive and negative pair similarities in isolation [26], [27], we additionally compute their difference, yielding a positive–negative similarity margin that more directly quantifies the cross-modal alignment. As shown in Figure 6, replacing the pre-training recommendation corpora of OpenOneRec with our proposed corpora consistently shifts the distribution of this margin to the right across all itemic domains, evidencing stronger cross-modal alignment. We defer the comprehensive methodology of this evaluation to Appendix 15.

In the remainder of this section, we describe the detailed construction methodology for the pre-training corpora at each of the four granularities. The detailed token ratios for each corpus are provided in Appendix 15.2.

4.2.1.1 Token Granularity.

Achieving precise alignment between language and itemic patterns requires modeling semantics across a continuous spectrum of granularities. Traditional methods [14] align each itemic pattern with its holistic caption. At the opposite end, recent explorations [28] focus on single-token semantic prediction by pairing each individual sub-token with its semantic meaning. However, the crucial compositional process through which the semantics of these isolated sub-tokens hierarchically combine into the semantics of the full itemic pattern remains implicit and is not explicitly modeled.

To bridge this gap, our token-granularity data is designed to explicitly model the compositional process through which sub-token semantics are progressively integrated into complete itemic-pattern semantics. Building upon the basic premise of single-token semantic alignment, we further introduce two novel components that strengthen sub-token-level semantic understanding while explicitly modeling the hierarchical composition of semantics across granularities:

1. Compositional Prefix Semantic Prediction. We formulate tasks that require the model to predict the combined semantic meaning of a prefix sub-token pair <a_xxxx><b_xxxx>. The data is constructed by leveraging an LLM to summarize the shared semantics of items that share the given prefix. This kind of data explicitly teaches the model how isolated semantics merge and interact at the intermediate sub-token-pair granularity.

   We further construct the reverse direction, Prefix Itemic Token Grounding, where the model must retrieve the correct prefix sub-token pair given a textual description of the combined semantics. This bidirectional formulation ensures that the model not only interprets what a prefix means but also maps semantic concepts back to the corresponding sub-token space.

2. Part-to-Whole Semantic Prediction. We structure the data to elicit a two-step semantic prediction process. The first step predicts the fine-grained semantic explanation for each individual sub-token within the complete sub-token sequence corresponding to a given item, while the second step subsequently synthesizes these discrete semantics into a cohesive, holistic caption for the item. The data thus enforces a structured, multi-step semantic prediction paradigm from parts to the whole.

4.2.1.2 Item Granularity.

Similar to the Itemic Dense Caption Data introduced in OpenOneRec [14], which comprises a bi-directional mapping between itemic patterns and captions, our item-granularity data serve to connect itemic patterns with natural-language descriptions. However, our item-granularity data significantly advances this paradigm through two critical enhancements:

1. Capacity-Aware Caption Coarse-Graining. The captions used as item-granularity alignment targets are often packed with very fine-grained details, yet each item is represented by only three sub-tokens. These sub-tokens capture an item’s coarse semantics but cannot encode such fine details, so aligning them with an over-detailed caption forces the model to hallucinate and pollutes the semantic space. We therefore coarse-grain each caption before alignment, keeping only what three sub-tokens can reliably carry, via three operations. (i) We remove instance-specific noise that the item code cannot recover, such as on-screen OCR text, ASR lyrics, dates, and product model numbers. (ii) We map fine-grained continuous attributes onto coarse buckets—an exact price becomes a price band and an exact age becomes a semantic label such as young adult—and we drop decorative modifiers while keeping the underlying entity (e.g., “pink top with a brown skirt” becomes “top with a skirt”). (iii) We preserve the high-discrimination content skeleton, including the item category, brand, IP, and title names, core selling points, target audience, and key material. Since the noise distribution differs across business domains, we design a separate set of coarse-graining rules for video, product, live, and ad.

2. Multi-Perspective Item QA. While standard captioning builds an initial perception of an item, it often falls short of capturing its nuanced attributes. To deepen alignment, we further construct multi-perspective question-answering data that queries the model from various angles, including target-audience preferences, core product attractions, visual styles, and negative-feedback rationales. This task design elevates alignment from a singular descriptive mapping to a robust, multi-dimensional semantic interrogation of the itemic pattern.

4.2.1.3 Relational Granularity.

In recommendation scenarios, semantic alignment remains incomplete without capturing the collaborative connections between items. Existing paradigms typically rely on implicit collaborative-filtering signals from raw user interaction sequences, leaving item-to-item transitions devoid of explicit and interpretable semantic grounding. To bridge this gap, our relational-granularity data explicitly aligns these collaborative signals with the textual space by constructing interleaved sequences of itemic patterns and natural-language explanations. Specifically, each training sample takes the following form: \[\text{Itemic\_Pattern}_0 \rightarrow \text{Textual\_Explanation}_0 \rightarrow \text{Itemic\_Pattern}_1 \rightarrow \cdots \rightarrow \text{Itemic\_Pattern}_n.\] This data corpus encompasses both direct item-to-item associations (where \(n=1\)) and multi-item interest flows (where \(n>1\)).

We use the internal search-after-play table to construct direct item-to-item associations. Each row in this table links a consumed source video to a specific search result product. This connection is established when a user issues a search query after a valid playback and positively engages with a product from the search results. The accompanying natural-language explanation is generated by fusing the captions of the video and the product into predefined templates.

Compared with direct item-to-item associations, the multi-item interest flows not only feature greater lengths and encapsulate richer collaborative signals per sample, but also provide broader modality coverage, ensure inter-item non-triviality, and yield higher explanation quality.

1. To expand the modality coverage, we further include two data sources apart from the search-after-play table. The first source is the internal TagNext CF Relations, where collaborative video pairs are extracted from positive user behaviors. The second involves aggregating co-occurring item pairs within sliding windows over temporally ordered, multi-domain user behavior sequences. Specifically, an item pair is retained if a substantial number of users provide positive feedback on two items that appear within a specific window size in their temporal behavior sequence.

2. To improve the inter-item non-triviality, we employ a dedicated process. First, we build a cross-user global item graph based on the three aforementioned data sources and randomly sample item chains from it. The sampled item chains capture latent relations that may not be prominent within a single user’s behavior sequence. Since transitions between adjacent items in a sampled chain \([Item_0, Item_1, Item_2, \dots]\) may be somewhat intuitive, we further sample a sub-chain \([Item_0, Item_{\text{interval}}, Item_{2\cdot \text{interval}}, \dots]\) to form the training sample. Sub-chains are discarded if the semantic similarity between any two adjacent item nodes within the sub-chain exceeds a certain threshold.

3. To boost the explanation quality, we leverage an LLM to generate natural-language explanations that articulate the underlying interest transitions from \(Item_{i\cdot \text{interval}}\) to \(Item_{(i+1)\cdot \text{interval}}\). To ground these explanations in real-world transition paths, the LLM is also provided with the semantic captions of the intermediate item nodes \([Item_{i\cdot \text{interval}+1}, \dots, Item_{(i+1)\cdot \text{interval}-1}]\).

4.2.1.4 User Granularity.

As the final part of our pre-training recommendation corpora, the user-granularity data expands the cross-modal alignment to the complete sequential evolution of user interactions.

A key prerequisite for this alignment is high-quality user-side text. However, raw user profiles assembled from business logs typically suffer from noise, incoherence, and rigid template patterns. We therefore employ an open-source LLM to recaption each profile across diverse aspects and formats, transforming them into fluent and natural narratives while preserving the original factual content. Building on these purified profiles, we design two data formats that seamlessly integrate natural language with itemic patterns to enable deep modality alignment:

1. Domain-Grouped Behavior Sequences. Each sequence in this format is anchored by a textual user profile, followed by the itemic patterns derived from the user’s interaction history. The involved itemic patterns are grouped into sub-sequences by their domains. Rather than unfolding the domain-grouped subsequences as a flat narrative, we dynamically structure them through multi-turn QA dialogues. By using natural language to explicitly query specific domain behaviors—often conditioning the prediction in one domain on the history in another—the text acts as an active control signal. The model must comprehend the semantic constraints of the question and map them accurately into the itemic space, thereby solidifying a robust alignment between the textual and itemic modalities.

2. Chronologically Interleaved Behavior Sequence. This data format reconstructs the user behavior sequence strictly by timestamps, naturally interleaving interactions across all domains. This timeline-based restructuring enables the model to differentiate short-term behavioral bursts from long-term interest evolution. Most importantly, to further enforce cross-modal alignment, we probabilistically replace a subset of itemic patterns within this timeline with their corresponding textual captions. This creates an interleaved, hybrid timeline that forces the model to achieve deep semantic integration between continuous natural language and discrete itemic patterns within a unified sequential context.

4.2.2 General-Domain Corpora↩︎

4.2.2.1 Text Corpora.

Beyond the four-granularity recommendation corpora, we maintain a substantial proportion of general-domain text data throughout pre-training, spanning mathematical reasoning, code, scientific literature, medical text, and general instruction-following corpora. This mixture serves to preserve the model’s core capabilities in logical reasoning, structured knowledge understanding, and instruction adherence while it absorbs recommendation-specific knowledge.

4.2.2.2 Multimodal Corpora.

Beyond text-only corpora, we further enrich pre-training with diverse multimodal data, which we convert into itemic-text format by tokenizing the images into itemic patterns. These data span four complementary sources: image-text understanding pairs, text-image interleaved documents, image-editing triplets (source image, editing instruction, target image), and text-to-image generation data. Across all four sources, we selectively retain only samples whose visual semantics operate at a coarse granularity—such as overall image style, dominant subject matter, and high-level scene composition—while discarding samples that hinge on fine-grained details that exceed the representational capacity of three sub-token codes. This deliberate diversity in data format, together with the coarse-granularity filter, jointly serves three purposes:

1. First, each source brings a distinct modality composition and linguistic style, collectively acting as a regularizer that prevents the model from overfitting to the homogeneous patterns of rule-synthesized recommendation corpora.

2. Second, these datasets are curated with high-quality semantic annotations, providing clean supervision signals for concept grounding and compositional visual reasoning.

3. Third, by mapping open-world visual concepts into itemic patterns, they function as external semantic anchors that expand the model’s knowledge boundary beyond the closed recommendation domain, thereby maintaining general multimodal-understanding capability throughout intensive recommendation training.

4.2.2.3 Data Composition Strategy.

Since we continue pre-training from the instruction-tuned Qwen3 backbone [23], a central concern is injecting domain knowledge without eroding its pre-existing instruction-following ability and textual fluency [29], [30]. To this end, and unlike OpenOneRec [14], we adopt a unified next-token prediction objective and route noisy, template-synthesized business data into the loss-masked context, reserving the loss-bearing target for higher-quality text. Consequently, the effective training targets naturally exhibit a roughly 1:1 ratio of QA-style and free-form data: the former keeps the model aligned with instruction formats, while the latter anchors it in natural text distributions. The loss-masked context further allows the model to condition on domain signals without learning to reproduce their noise.

4.3 Ablation Study on Recommendation Corpora↩︎

4.3.1 Experimental Settings↩︎

We perform the ablation study on the 0.8B model with a fixed budget of 30B tokens, keeping the computational cost manageable while our main results are obtained on the 8B model. The five configurations are defined as follows:

• Exp1 (Baseline): the standard OpenOneRec dataset, comprising original item-caption data and user-granularity data (including user-behavior data and user-persona grounding data).

• Exp2 (Exp1 + Token): incorporates our token-granularity data into Exp1, proportionally downsampling the original mixture to maintain the budget.

• Exp3 (Exp2 + Item): replaces the baseline item-caption data in Exp2 with our item-granularity data.

• Exp4 (Exp3 + Relational): integrates our relational-granularity data into Exp3, rebalancing the overall mixture accordingly.

• Exp5 (Exp4 + User): substitutes the baseline user-granularity data in Exp4 with our user-granularity data.

Notably, the token and relational granularity data introduce novel capabilities absent from the baseline, whereas the item and user granularity data serve as upgraded replacements for their baseline counterparts. This sequential pipeline effectively isolates the marginal contribution of each granularity while ruling out any confounding effects from increased data volume.

4.3.2 Results↩︎

To systematically demonstrate the effectiveness of our multi-granularity data construction pipeline, we present the performance trajectory across OneReason-Bench tasks (Table 2). The results reveal a clear capability progression, confirming that each granularity level successfully injects its targeted compositional or semantic competencies into the model.

4.3.2.1 Exp1 \(\rightarrow\) Exp2: Token Granularity.

Adding token-granularity data sharply improves R0 retrieval and understanding across all domains (e.g., Itemic Pattern Grounding_prod 2.42% \(\rightarrow\) 5.81%; Item Understanding_ad 16.37% \(\rightarrow\) 37.86%). R1 Item2Item QA surges from 0.00% to 20.57%, confirming that token-level QA-style data unlocks the QA format absent in the baseline. R2 temporarily drops to 0.00%, indicating disruption of higher-level reasoning.

4.3.2.2 Exp2 \(\rightarrow\) Exp3: Item Granularity.

Replacing the baseline’s captions with multi-perspective item data pushes several R0 retrieval metrics to their peaks. R2 recovers to 0.32%, and R3 cross-domain recommendation improves (e.g., Cross-Live 2.32% \(\rightarrow\) 3.49%). R0 Item Understanding regresses on most domains, attributable to residual noise in business-sourced captions (see Table [tab:item95hallucination95case]).

3pt

4.3.2.3 Exp3 \(\rightarrow\) Exp4: Relational Granularity.

Integrating relational data lifts R1 Item2Item QA to 25.65% and R3 Cross-Prod to 1.54%. Some R0 retrieval metrics decline (e.g., Itemic Pattern Grounding_prod 5.33% \(\rightarrow\) 2.91%), reflecting a trade-off toward relational reasoning. R2 dips slightly (0.32% \(\rightarrow\) 0.18%), since item-to-item relational data does not directly benefit this user-side task.

4.3.2.4 Exp4 \(\rightarrow\) Exp5: User Granularity.

Substituting the baseline’s user data with our temporally-aware sequences pushes R2 to its peak (0.37%) and drives R3 cross-domain recommendation to its highest levels, most notably Cross-Live (3.25% \(\rightarrow\) 8.56%) and Cross-Ad (8.58% \(\rightarrow\) 10.84%). R1 reaches 29.72%, and R0 retrieval metrics recover to earlier peaks.

4.3.2.5 Key Insights.

The ablation reveals three findings: (1) Token- and relational-granularity data expand the model’s skill set through augmentation, while item- and user-granularity data refine existing capabilities through replacement. (2) Capability trade-offs emerge during training—gains in relational reasoning may temporarily reduce static retrieval, but subsequent stages recover these capabilities. (3) User granularity acts as the ultimate integrator, contextualizing all prior knowledge within temporal behavior to achieve peak performance across diverse recommendation scenarios.

4.4 Training Recipe↩︎

Our training recipe, illustrated in Figure 7, unfolds in three stages. The core hyperparameters of each stage are summarized in Table 3.

All stages employ sample packing to improve sequence utilization, producing packed sequences of 48K tokens. The key distinction across stages lies in the maximum length of individual samples within each packed sequence. Stage 1 and Stage 2 restrict individual samples to 4K tokens to prioritize training throughput. In Stage 1, only the newly introduced embeddings and the corresponding LM head weights are trained, while the rest of the backbone remains frozen, allowing the newly introduced itemic-pattern embeddings to settle into the semantic space without disturbing the pre-trained weights. Stage 2 unfreezes all parameters for full joint training, enabling the model to absorb recommendation knowledge from the four-granularity data mixture. Stage 3 lifts the per-sample length limit to 32K tokens, allowing the model to train on full user histories with long-range behavioral dependencies.

5 SFT Pipeline↩︎

Itemic–text alignment pre-training gives the model a necessary perception foundation: it can associate itemic tokens with natural-language content and has absorbed collaborative signals from user behavior. SFT builds on this foundation by cultivating recommendation cognition, namely the ability to operate over grounded itemic tokens under instruction format. We organize this stage around the same R0–R3 hierarchy, but with two complementary training axes. The compression axis teaches the model to reduce long and noisy user histories into typed persona states and compact interest-evolution motifs, so that the later reasoning step can compare a small set of evidence-backed hypotheses rather than a raw behavior log. The reasoning axis teaches dynamic operations: R1 derives one-hop item-to-item bridges, R2 tracks temporal interest evolution, and R3 performs transition judgement for next-interaction prediction. Section 5.1 introduces R0 perception supervision; Section 5.2 and Section 5.3 describe R1 derivation and R2 evolution reasoning; Section 5.4 presents R3 recommendation supervision, where compression and transition judgement are composed into recommendation CoT; and Section 5.5 and Section 5.6 cover itemic-instruction and general-domain data for instruction robustness.

5.1 R0: Perception↩︎

Building on the four-granularity alignment established during pre-training, we further refine the data and carry out high-quality CoT capability construction. R0 provides the perception layer for the SFT stage. Its role is to make itemic tokens readable, controllable, and semantically usable before the model is asked to perform higher-level recommendation reasoning. The caption data covers four major content domains, short videos, e-commerce products, live streamings, and advertising. QA data is narrower: it covers short-video and e-commerce product domains, while live-streaming and advertising contribute caption-style grounding only. R0 therefore contains two complementary task families. The first is bidirectional mapping between itemic tokens and natural-language descriptions, which reinforces item\(\leftrightarrow\)language grounding under instruction-style supervision. The second is question-answering (QA) over platform content, which expands perception beyond caption reconstruction to attribute recognition, audience understanding, negative-feedback analysis, and open-ended semantic comprehension for the two QA-covered domains.

Since the pre-training stage has already established the hierarchical itemic-token space, R0 does not introduce a new tokenizer or repeat the full token-granularity construction. Instead, it turns this hierarchy into explicit SFT supervision. Table 4 shows this difference with the same video itemic tokens: pre-training provides a direct itemic-token-to-caption mapping, whereas R0 asks the model to explain the hierarchical itemic tokens before producing the caption. In this case, the CoT first uses the coarse token to identify a character-centered or ACG-style content type, then uses the middle token to narrow the evidence toward young-female visual presentation, and finally uses the fine token to support the conclusion about personal style and aesthetic display. The key difference is therefore not the target caption itself, but the supervised verbalization of how coarse-to-fine itemic-token semantics support that caption. More bilingual R0 perception examples are provided in Appendix 16.1.1.

The caption data includes both thinking and non-thinking variants. In the thinking format, the model first explains how each itemic token contributes to the final item meaning and then produces the final caption. This explicit coarse-to-fine trace teaches itemic-token-to-text grounding rather than recommendation decision-making: it supplies the semantic substrate later reused by R1 derivation, R2 evolution, and R3 recommendation reasoning. The unCoT variant, in parallel, supervises direct itemic-token-to-caption generation, preserving generation quality and efficiency when explicit reasoning is unnecessary.

3pt

QA supervision is retained as an instruction-style perception supplement: it extends caption grounding from itemic-token decoding to content-aware question answering over structured attributes and open-ended semantics in the video and product domains. Together, caption and QA data convert the aligned itemic-token perception acquired during pre-training into instruction-followable perception ability. In total, R0 contains approximately 941K samples, including about 682K caption samples and 259K QA samples.

5.2 R1: Derivation↩︎

R1 targets cross-item relation derivation. It extends R0 from understanding an individual item to explaining why one item may naturally lead to another. The intended capability is not generic item similarity. Instead, R1 teaches the smallest useful source-to-follow-up bridge: given a source item during student SFT, the model should generate and justify a plausible follow-up itemic-token answer by identifying the need, clue, scenario, constraint, or refinement on the source side. Source–destination pairs are used during teacher-side data filtering and consistency checking; the student training input remains source-only, and the source prompt tokens are not counted as target loss. This local bridge-building ability later becomes part of R3 recommendation CoT, where the model must connect observed behavior, textual evidence, and target-domain decisions rather than rely on surface textual overlap.

R1 is constructed from the same raw candidate pools used in relational pre-training, including TagNext CF relations and after-play-search data. The difference is the supervision standard. Relational pre-training exposes the model to large-scale collaborative transitions, whereas R1 requires each retained pair to support explicit, one-hop, evidence-grounded reasoning. After deduplication, diversification, and embedding-similarity filtering, a locally deployed flagship LLM assigns an explicit-relevance judgement to each pair: explicitly related, explicitly unrelated, or uncertain. We retain only pairs whose relation can be directly supported by visible item evidence, such as item metadata and dense captions, and remove weak pairs whose connection depends mainly on broad assumptions such as audience overlap, popularity, or platform co-occurrence. The full judgement prompt and its English translation are provided in Appendix 16.2.1.

3pt

Table 5 contrasts R1 with relational pre-training. Relational pre-training presents the source item and the related target item in a message-style association. R1 instead keeps a single source itemic-token sequence as the instruction input and supervises the answer side with an explicit bridge followed by the target itemic tokens, making the local relation judgement directly learnable.

For high-confidence candidates, the flagship LLM further extracts compact bridge variables, including source-side need, bridge type, abstract bridge, continuation direction, reason seed, and confidence. These variables separate the relation explanation from the destination item’s surface content: the destination item is used only for consistency checking, while the generated explanation must be written from the source-side evidence and bridge variables. This design reduces target leakage and prevents the model from learning to copy target-only entities or restate the destination description as the rationale. The generation prompt is shown in Appendix 16.2.2, and bilingual sanitized examples are provided in Appendix 16.2.3.

This process distills the raw candidate pools into approximately \(358\)K TagNext CF pairs and \(388\)K after-play-search pairs, from which we sample a refined R1 training set of roughly 400K examples. Overall, R1 converts implicit item-to-item signals into concise derivation supervision: it preserves the collaborative signal introduced during pre-training, but upgrades it into explicit bridge reasoning that can be reused by R3 when connecting user evidence to the next-interest direction.

5.3 R2: Evolution↩︎

R2 targets user interest evolution modeling. It extends recommendation cognition from static preference understanding to temporally structured interpretation of behavior. While R0 grounds item semantics and R1 derives explicit relations between item pairs, R2 asks how intent develops over time: which behaviors act as triggers, which later behaviors refine or correct earlier ones, and how multiple events accumulate into an interpretable trajectory. This capability is essential when the recommendation decision depends not only on what the user interacted with, but also on how the user’s underlying need became more specific.

We construct R2 from full-domain user behavior timelines, where heterogeneous actions are organized chronologically. Rather than treating a timeline as a flat context, a strong LLM first identifies key evolution nodes that indicate meaningful shifts, refinements, or closures in user intent. The extraction emphasizes coherent progression, topic continuity, and nontrivial cognitive increment, converting raw behavior streams into candidate evolution chains with explicit temporal structure. In this sense, R2 is the SFT counterpart of user-level pre-training: pre-training exposes the model to long behavior contexts, while R2 teaches it to explain which parts of those contexts form valid interest-evolution paths.

To improve reliability, candidate chains are filtered by a separate LLM-as-a-Judge quality-evaluation stage. This stage checks whether each proposed trajectory is supported by the original timeline and whether its transitions form a plausible, self-consistent reasoning path. The diagnostic criteria cover order sensitivity, cognitive increment, trigger-source evidence, strong causal-style exclusivity, evidence closure, and no-mind-reading constraints. In practice, this filtering removes pseudo-logical chains, random-consumption chains, same-category drift, and weakly grounded transitions before downstream task construction. The main extraction prompt and its English translation are provided in Appendix 16.2.4; the complete quality-control prompt contains the full set of eleven checks used for second-pass evaluation.

Based on the validated evolution chains, we construct three SFT task families aligned with the R2 benchmark taxonomy:

• Evolution Action Selection: Given a user history \(\mathcal{H}\) and a specified interest topic or candidate chain description, the model identifies the related historical actions \(\mathcal{A}\), encouraging discriminative reasoning over temporal structure.

• Evolution Topic Generation: Given a user history \(\mathcal{H}\) and a specified topic \(t\), the model generates the corresponding evolution chain \(\mathcal{E}_t\), focusing on topic-conditioned temporal reasoning.

• Evolution Direct Generation: Given only the user history \(\mathcal{H}\), the model directly generates valid evolution chains \(\{\mathcal{E}\}\) without topic guidance, requiring the highest degree of autonomy.

During data construction, these three families are organized as selection, topic-generation, and direct-generation samples, respectively. Some samples include CoT rationales that make the temporal-transition judgement explicit, while direct-answer samples are kept for response efficiency and format robustness. Representative sanitized examples for all three training formats are provided in Appendix 16.2.5.

The final R2 dataset contains approximately 130K training instances. Overall, R2 serves as the temporal cognition layer of the SFT mixture. By transforming user timelines into validated evolution supervision under multiple task formats, it teaches the model to interpret user intent as an evolving process rather than a static profile. This temporal scaffold is later reused by R3, where recommendation traces must compress noisy histories, compare candidate interest directions, and decide which direction is best supported by the user’s recent and long-term behavioral evidence.

5.4 R3: Recommendation↩︎

R3 is the recommendation-level composition layer of the SFT mixture. R0–R2 train dedicated capabilities separately, whereas R3 brings them together in the final next-interaction prediction setting. Its contribution is not another standalone reasoning task, but a trace-construction protocol that places R1-style derivation and R2-style temporal-evolution reasoning over a two-axis compressed user state. The R3 block contains both thinking samples and non-thinking direct-answer samples: the former teach structured recommendation cognition, while the latter preserve direct mapping from user context to target itemic tokens and support non-thinking format alignment. This subsection focuses on the construction and evaluation of the CoT traces.

5.4.1 Recommendation Reasoning Trace Construction↩︎

Each R3 synthesis sample is built from three ingredients: a user profile \(\mathcal{P}_u\), a chronological interaction timeline \(\mathcal{H}_u\), and the ground-truth subsequent interaction \(y_u^{+}\). The target interaction is used only as the supervision answer and is explicitly prohibited from appearing directly in the reasoning trace. The trace must therefore reason from the observed profile and behavior evidence as if the answer were unknown. During data construction, the teacher first writes the trace over natural-language user evidence and marks referenced historical items with their original domain ids, such as video, product, live-author, or ad ids, so that every concrete evidence reference remains machine-matchable. A subsequent post-processing stage joins this raw trace with the itemic-token-converted user context, replaces each matched historical id with its itemic tokens, removes unmatched references, and writes the final assistant message as a trace followed by the target itemic-token answer. Thus, the training trace seen by the model is not a text-only rationale: it interleaves natural-language reasoning with itemic-token evidence inside the CoT, while keeping the target itemic tokens outside the reasoning span.

The central design principle is to treat recommendation CoT as a two-axis compression plus transition judgement process. The first axis is persona-type compression, which summarizes stable preference priors, demographic or life-stage clues, temporal rhythm, content preference, price sensitivity, interaction depth, and possible shared-device ambiguity. The second axis is interest-evolution-type compression, which identifies recent trajectory motifs such as triggering search, need expansion, parameter narrowing, scenario continuation, saturation-driven substitution, cross-domain echo, or closure from browsing to purchase. These compressed states reduce long-history noise and provide typed variables that the subsequent reasoning stage can manipulate.

Compression in this setting is task-directed understanding, not a generic summary of the observed history. It preserves evidence useful for next-interaction prediction and suppresses routine, accidental, or weakly supported behavior. This design is motivated by the information bottleneck view of representation learning, where useful representations preserve prediction-relevant information while suppressing input noise [31]; we use this as a design motivation rather than a claim about universal deep-network dynamics [32]. It is also consistent with work connecting language modeling and compression [33] and with the view that reusable abstractions compress long primitive derivations into higher-level concepts [34]. In our setting, the practical implication is that a model capable of compressing a noisy user history into an appropriate persona state and evolution motif has already performed a substantial part of recommendation cognition.

After compression, the trace performs transition judgement over the candidate hypotheses. This stage reuses two earlier SFT abilities. From R1, it inherits local bridge construction: the trace should explain how an earlier item, query, or behavior can naturally lead to a follow-up need. From R2, it inherits temporal evolution judgement: the trace should decide whether a candidate direction is supported by order, continuity, refinement, or closure in the behavior timeline. We use causal-style only as a data-construction heuristic: the teacher prefers evidence-supported triggers, refinements, and scenario continuations over shallow co-occurrence, without claiming identifiable causal effects from observational logs. This heuristic is aligned with causal recommendation studies that emphasize separating genuine user interest from confounding factors or conformity effects, as well as counterfactual explainable recommendation methods that seek explanations with strong decision influence [35]–[37].

Concretely, we adopt a three-stage protocol: Persona Abstraction, Interest Expansion, and Transition Inference. Persona Abstraction performs the persona-type compression axis. Interest Expansion starts from interest-evolution-type compression and expands the most informative behavior signals into a small set of evidence-grounded hypotheses. Transition Inference compares these hypotheses under evidence strength, recency, temporal continuity, persona compatibility, target-domain compatibility, and leakage control, then commits to the most plausible next-interest direction.

5pt

At a conceptual level, the protocol can be written as \[\begin{align} \mathcal{C}_u = \mathrm{Abstract}(\mathcal{P}_u,\mathcal{H}_u), \qquad \mathcal{Z}_u = \mathrm{Expand}(\mathcal{C}_u,\mathcal{H}_u), \end{align} \label{eq:sft-r3-compression}\tag{1}\] \[\begin{align} z_u^{\star} = \mathrm{Infer}_{\mathrm{trans}}\bigl(\mathcal{Z}_u \mid \mathcal{C}_u,\mathcal{H}_u,d\bigr) = \arg\max_{z\in\mathcal{Z}_u} s\bigl(z\mid \mathcal{C}_u,\mathcal{H}_u,d\bigr), \end{align} \label{eq:sft-r3-transition-inference}\tag{2}\] where \(\mathcal{C}_u\) denotes the compressed user state, \(\mathcal{Z}_u\) denotes the expanded set of candidate interest hypotheses, \(d\) denotes the target domain, \(\mathrm{Infer}_{\mathrm{trans}}(\cdot)\) denotes the final transition-judgment step, and \(s(\cdot)\) is a conceptual scoring function that jointly considers evidence strength, recency, temporal continuity, persona compatibility, and target-domain compatibility. The final CoT trace is written as a concise realization of this process with text and itemic-token references interleaved, while the target itemic tokens are emitted only after the reasoning trace. Representative sanitized training samples of the final recommendation CoT format are provided in Appendix 16.3.3, and the complete bilingual construction prompt is provided in Appendix 16.3.1.

5.4.1.1 Persona Abstraction

The goal of Persona Abstraction is to compress sparse and noisy behavioral evidence into a compact, interpretable prior. Given the user profile and interaction history, the teacher model identifies the most plausible user archetype, or summarizes a customized profile when the user does not fit any predefined category. The abstraction is a soft, typed user state rather than a deterministic label: it narrows the set of likely interest directions, but the final inference must still be grounded in observed behaviors. This stage reduces the search space for transition judgement by converting a high-dimensional behavior log into a small number of preference factors, such as family consumption needs, game-skill improvement, live-shopping sensitivity, food preference, fitness goals, or shared-device ambiguity. Table 6 gives representative Chinese persona-abstraction cases, together with English analyses of how each abstraction constrains recommendation reasoning.

5.4.1.2 Interest Expansion

After Persona Abstraction, the model performs Interest Expansion so that the trace does not commit too early to a single explanation. This stage begins with interest-evolution-type compression: it identifies typed motifs from recent trajectory evidence, such as a search-triggered need, a refinement from broad category to concrete parameter, a scenario continuation from content to product, or a cross-domain echo between live, product, ad, and video behaviors. These motifs are then opened into a small set of candidate next-interest hypotheses. In this way, Interest Expansion remains broad enough to represent recommendation uncertainty, but compact enough to prevent the trace from being overwhelmed by raw behavior tokens.

We use four heuristics to keep this expansion broad but evidence-grounded:

• Behavior motivation. The trace should explain the intent behind informative behaviors, especially search queries, because they often directly reveal the user’s current interest and real need.

• Temporal sensitivity. The trace should respect event order and explain how later behaviors may evolve from earlier ones, rather than treating the history as an unordered set.

• Transition coverage. When the user appears to shift from one topic to another, the expansion should preserve plausible before–after directions as candidates, while leaving the final judgement to Transition Inference. If a later behavior abandons all previous conditions without a logical bridge, it should be treated as weakly related or unrelated.

• Noise attenuation. Routine replenishment, random consumption, repeated exposure, and one-off actions are down-weighted because they are usually weak signals for stable future recommendation intent.

Concretely, Interest Expansion requires the reasoning trace to reach the finest reliable granularity supported by evidence. If the history supports interest in a specific mobile game, the trace should not stop at the generic gaming category; if the user repeatedly engages with a particular opera genre, the trace should mention that genre rather than only “traditional culture.” This design keeps the CoT trace fine-grained and evidence-grounded while preserving multiple plausible future directions before the final decision is made.

To calibrate how broad this stage should be, we vary the interest expansion width \(n\) during SFT trace construction and evaluate the resulting think-mode recommendation quality across the four domains. Figure 8 shows a consistent pattern: keeping the expansion compact (\(n\in\{1,3,5\}\)) is consistently better than broader widths such as \(10\) or \(20\). This result fits the compression view above. Once the candidate set becomes too large, the trace starts to carry many weak branches, which dilutes the strongest transition signal and makes the later compare-and-commit step noisier. A small hypothesis set is therefore not a loss of reasoning capacity; rather, it is the point where uncertainty is preserved without letting the reasoning path fragment. In practice, we treat Interest Expansion as a controlled reasoning decompression step: it briefly opens the compressed trajectory into a few plausible directions, then hands a still-compact hypothesis space to Transition Inference.

5pt

5.4.1.3 Transition Inference

The final stage compares the expanded hypotheses against the full context and commits to the most likely subsequent interaction direction. It reuses R1 by requiring a local bridge from antecedent evidence to follow-up need, and reuses R2 by checking whether the candidate direction is supported by temporal order, continuity, refinement, or behavioral closure. The teacher weighs each hypothesis by evidence strength, recency, continuity, persona compatibility, target-domain compatibility, and leakage risk. This compare-and-commit step prevents the trace from merely listing possible interests without making a decision useful for recommendation.

The following constraints make the final judgement decision-oriented and leakage-safe:

• Evidence priority. Candidate directions supported by repeated actions, active searches, or recent dense interactions receive higher weight; those supported only by isolated or accidental behaviors are down-weighted.

• Transition bridge. The trace should explain the bridge from earlier evidence to later intent. Valid bridges include feedback, bottleneck, cognitive refinement, scenario continuation, parameter narrowing, or need completion; simple topical similarity is insufficient.

• Granularity calibration. The final judgement should be as specific as the evidence allows. If the evidence supports a concrete game, opera genre, function, product attribute, or content style, the trace should not stop at a coarse category; if the evidence is insufficient, the trace should avoid over-specific claims.

• Conflict resolution. When multiple directions are plausible, the trace compares their fit with the persona prior, recent behaviors, long-term interests, and target domain, then chooses the most likely direction.

• Leakage control. Although the target interaction is visible during data construction, the reasoning must be written as if the answer is unknown. It must not copy the target title, expose the target item id or itemic token, or use target-only entities as evidence.

A compact training trace in Table 7 shows how Interest Expansion keeps several grounded directions active, while Transition Inference commits to the strongest continuation.

Through Persona Abstraction, Interest Expansion, and Transition Inference, the synthesized CoT becomes compact, fine-grained, and decision-oriented. The first two stages denoise the behavior history and organize the hypothesis space, while the final stage compares candidate transitions by reusing R1 bridge reasoning and R2 evolution reasoning. This structure allows SFT to learn not only the final target itemic-token prediction, but also the behavioral logic that connects user evidence to recommendation decisions.

5.4.2 Quality Evaluation of Reasoning Traces↩︎

The quality of recommendation reasoning traces is evaluated along five complementary dimensions, each highlighting a different aspect of useful recommendation cognition: they assess whether the trace avoids direct answer leakage, aligns with the intended target, demonstrates logically transferable reasoning over user behavior, accurately reflects observed history, and provides actionable guidance for subsequent recommendations.

• Safety. Checks whether the CoT trace directly exposes target content, such as item id, itemic token, title, or any entity that could uniquely identify the target. Safe traces avoid direct answer leakage while remaining informative.

• Consistency. Evaluates whether the trace’s conclusions, preference direction, and behavioral explanations align with the intended recommendation target. A consistent trace supports correct downstream predictions.

• Logic. Measures whether the trace demonstrates transferable and generalizable reasoning over user behavior rather than surface-level concatenation, forced associations, or memory of a single instance.

• Factuality. Ensures that the trace accurately reflects the observed user history. It checks for fabricated behaviors, incorrect attributions, exaggerated trends, temporal confusions, or unsupported statements.

• Informativeness. Assesses whether the reasoning provides useful and specific recommendation guidance without leaking the target. It should summarize interest directions, scenarios, functionality, style, attributes, or exclusions that are actionable for recommendation.

Together, these dimensions provide a compact diagnostic view of trace quality. Safety constrains leakage, consistency checks target alignment, logic checks reasoning transferability, factuality checks history grounding, and informativeness checks whether the trace provides clear guidance for recommendations. The evaluation therefore distinguishes traces that are merely fluent from traces that express useful recommendation cognition. Figure 9 summarizes the resulting score distribution and mean-score profile across these five dimensions.

Representative unreasonable traces identified by this quality-evaluation strategy are shown in Appendix 16.3.2 (Table 25), where problematic statements in the generated CoT are marked in red.

5.5 Itemic Instruction Data↩︎

Itemic Instruction Data improves instruction-following behavior when itemic tokens appear explicitly in the input context. It complements the compression–reasoning backbone by ensuring that itemic-token-rich inputs remain instruction-controllable, rather than being automatically interpreted as recommendation-reasoning prompts. We observe that pretrained models often behave unstably in such settings: instead of following the user’s instruction, the model may ignore the requested task, explain the meaning of specific itemic tokens, or implicitly reinterpret the input as a user-interest analysis problem. Such behavior limits usability in practical recommendation-oriented interactions.

To address this issue, we construct a specialized instruction-tuning dataset centered on itemic-token-grounded task execution. Data generation begins with a predefined inventory of task tags, each corresponding to a representative instruction type in recommendation and content understanding scenarios. Rather than focusing only on itemic-token decoding, the tag space spans conversion, retrieval, matching, comparison, generation, editing, summarization, and explicit instruction-control tasks. For each tag, we generate suitable instructions and pair them with sampled user-side material, so that each example requires the model to complete a concrete task under inputs containing itemic tokens. Representative bilingual training cases are shown in Appendix 16.4.1. The main task groups are organized as follows:

• Conversion and Editing. This group teaches the model to convert between itemic tokens and natural language, rewrite text-token pairs, replace itemic tokens with textual descriptions, or reorder token sequences under instruction constraints. A representative instruction is: “Convert the following product itemic token into a short product introduction.”

• Retrieval and Selection. This group focuses on retrieving itemic tokens from structured user contexts according to time, behavior, attribute, or interaction-order constraints. A representative instruction is: “Find all video itemic tokens the user interacted with during a given time window.”

• Matching and Classification. This group trains the model to match natural-language descriptions with candidate itemic tokens, select the most suitable token-description pair, handle fuzzy matching, or classify the scene represented by itemic tokens. A representative instruction is: “Which itemic token best matches the description ‘noise-canceling Bluetooth earphones’? Output only the token.”

• Comparison and Aggregation. This group requires the model to compare itemic tokens or token groups, perform set-level operations, and summarize token sequences into compact natural-language descriptions. A representative instruction is: “Compare the functional differences between these two product itemic tokens in three sentences.”

• Generation and Verification. This group asks the model to generate descriptions, promotional copy, constrained summaries, or verification results based on itemic-token-linked content. A representative instruction is: “Write a 50-word promotional copy for the following product itemic token.”

• Instruction Control. This group explicitly trains the model to follow the user’s instruction even when itemic tokens appear as distracting context. It includes ignoring irrelevant tokens, conditional execution, text-preserving rewriting, and format-constrained response generation. A representative instruction is: “Ignore all itemic tokens below and answer: what are the main evaluation metrics for recommender systems?”

A key design principle is that itemic tokens are treated as grounding signals rather than as the final target of explanation. The objective is not to make the model interpret token semantics in isolation, but to train it to use itemic-token-linked context correctly while remaining faithful to the user’s instruction. This improves robustness in mixed natural-language and token-based inputs. Among the task groups above, the instruction-control cluster is especially important because it directly teaches the model to prioritize user intent even when itemic-token-rich context could otherwise distract or mislead generation.

To ensure data quality, generated instructions are evaluated for usability before large-scale expansion, and final samples are checked with rule-based consistency tests to verify that itemic-token references in the input and output match the associated material. Samples with unsupported token references, weak task grounding, or unclear intent are removed. The final Itemic Token Instruction dataset contains approximately 103.0K examples. Overall, this dataset serves as a behavior-alignment layer for itemic-token-aware interactions, improving the model’s ability to follow instructions accurately in recommendation scenarios involving structured content identifiers.

5.6 General-Domain Data↩︎

To preserve general instruction-following ability and mitigate over-specialization during recommendation-oriented SFT, we incorporate the publicly available Step-3.5-Flash-SFT dataset released by StepFun [38] as the general-domain data source. We apply conservative preprocessing to the raw dataset: samples containing tool-use traces are discarded to avoid introducing environment-interaction behaviors outside the scope of our SFT setting; only samples following the standard three-role dialogue schema, namely system, user, and assistant, are retained to ensure a homogeneous conversational format; and samples with malformed structures, missing fields, or corrupted formats are removed to further improve data quality. After preprocessing, the resulting corpus contains approximately 1.5 M high-quality SFT samples, which are mixed into the training data to maintain broad instruction-following capability and stabilize general-purpose response behavior under domain-specific fine-tuning. General-domain data therefore serves as a stabilizer around recommendation cognition, preventing the model from overfitting to itemic-token reasoning formats.

Overall, this SFT stage builds structured recommendation cognition on top of aligned itemic perception: R0 grounds itemic tokens, R1 supplies evidence-grounded derivation, R2 supplies temporal-evolution supervision, and R3 composes these abilities for next-interaction prediction. Because the R3 traces are still teacher-generated, they are not yet optimized by recommendation outcome feedback. The next stage closes this loop with recommendation-oriented RL: domain-specific RL first discovers stronger recommendation behaviors within each domain, and RFT/MOPD then consolidate these specialized policies into a unified four-domain recommendation foundation model.

6 RL Pipeline↩︎

After the SFT stage, the model has acquired general semantic understanding, instruction-following ability, and an initial capability for recommendation-oriented reasoning. However, SFT mainly enables the model to imitate teacher-generated reasoning trajectories, and the resulting performance is still largely bounded by the capability of the teacher model. Since the model has already been exposed to large-scale recommendation data and has developed strong recommendation capabilities, a natural next step is to examine whether the model can go beyond imitation and further improve its recommendation reasoning through self-exploration. Reinforcement learning (RL) has recently become a promising direction for further improving recommendation models beyond supervised training [14], [39], [40]. However, for a foundation recommendation model that supports diverse tasks across domains, directly applying RL to mixed-domain data may cause cross-domain interference, since different domains often involve distinct user intents, item semantics, and reward landscapes.

To mitigate this issue, we adopt a “specialize-then-unify” strategy. As illustrated in Figure 10, we first optimize the model separately on each recommendation domain through RL, resulting in four teacher models that specialize in domain-specific recommendation reasoning. We then investigate two approaches to consolidate these domain-specific capabilities into one unified model: rejection sampling fine-tuning (RFT), which refines the model on verified high-quality reasoning trajectories sampled from domain-specialized teachers; and Multi-Teacher On-Policy Distillation (MOPD), which distills multiple domain-specific policies into the student model on its own generated trajectories.

6.1 Recommendation-oriented Reinforcement Learning↩︎

We first optimize the model with GRPO [4] on each recommendation domain separately, where the model generates trajectories and receives outcome feedback based on the correctness of its prediction.

6.1.0.1 Recommendation-oriented GRPO.

For a user \(u\) with context (query) \(q\), the model takes it as input and samples a group of recommendation rollouts, where each rollout consists of a reasoning trace and generated itemic tokens, as illustrated in Figure 11. Formally, let \[\mathcal{G}_{u} = \{(\mathrm{CoT}_{u,i}, \mathbf{c}_{u,i})\}_{i=1}^{G}\] denote the group of \(G\) rollouts sampled for user \(u\), where \(\mathrm{CoT}_{u,i}\) is the generated reasoning trace and \(\mathbf{c}_{u,i}\) is the corresponding itemic tokens. Each rollout is evaluated by an outcome reward \(R_{u,i}\), which measures whether the generated itemic tokens match the target recommendation. GRPO then normalizes rewards within the same group to obtain the relative advantage: \[\hat{A}_{u,i} = \frac{ R_{u,i} - \mathrm{mean}\left(\{R_{u,k}\}_{k=1}^{G}\right) }{ \mathrm{std}\left(\{R_{u,k}\}_{k=1}^{G}\right)+\delta },\] where \(\delta\) is a small constant added for numerical stability. The model is optimized to increase the probability of high-advantage rollouts, where the generated reasoning trace leads to itemic tokens that match the ground-truth items.

6.1.0.2 Rollout Design.

While GRPO serves as a powerful tool to enhance the effectiveness of recommendation reasoning, directly applying it to recommendation tasks still faces practical challenges. The nature of recommendation tasks, where the model predicts user interests from a massive candidate space, leads to an inherently low hit rate and requires a sufficiently large rollout size to obtain useful reward signals. This is particularly costly for reasoning-augmented recommendation, where each recommendation is preceded by a reasoning trajectory.

To address this issue, we design a two-stage rollout strategy tailored to recommendation-oriented RL. As illustrated in Figure 11, the central idea is to amortize the cost of reasoning over multiple recommendations. For each user \(u\), we first sample \(N\) reasoning traces \(\{\mathrm{CoT}_{u,i}\}_{i=1}^{N}\). Conditioned on each reasoning trace \(\mathrm{CoT}_{u,i}\), the model then generates \(K\) itemic token sequences in parallel, \(\{\mathbf{c}_{u,i,j}\}_{j=1}^{K}\), where \[\mathbf{c}_{u,i,j} = [\langle\texttt{|domain\_begin|}\rangle, c^{(1)}_{u,i,j}, c^{(2)}_{u,i,j}, c^{(3)}_{u,i,j}].\] This produces \(N \times K\) effective recommendation rollouts while generating only \(N\) reasoning traces. Since the additional expansion is restricted to the short itemic tokens, the reward coverage is significantly improved with limited extra computation and memory overhead.

6.1.0.3 Reward Design.

Recommendation tasks focus on set-wise optimization, where the model should retrieve a set of relevant items rather than only optimize a single prediction. Since user interests are often multi-faceted, an ideal reasoning trace should cover diverse relevant items that satisfy user interests. Therefore, given the \(N \times K\) rollouts produced by the two-stage decoding procedure, we assign each rollout a mixed reward that considers both item-level accuracy and the diversity of recommendations induced by each reasoning trace. For each rollout \((\mathrm{CoT}_{u,i}, \mathbf{c}_{u,i,j})\), the corresponding reward is defined as \[R_{u,i,j} = R_{\mathrm{rule}}(\mathbf{c}_{u,i,j}) \cdot R_{\mathrm{div}}(\mathrm{CoT}_{u,i}),\] where \(R_{\mathrm{rule}}\) provides the main accuracy signal based on the predicted itemic tokens, while \(R_{\mathrm{div}}\) evaluates the diversity of the recommendations induced by the same reasoning trace. The rule-based reward evaluates whether the predicted itemic tokens hit the ground-truth set \(\mathcal{C}^{+}_{u}\): \[R_{\mathrm{rule}}(\mathbf{c}_{u,i,j}) = \mathbf{I}\left[\mathbf{c}_{u,i,j} \in \mathcal{C}^{+}_{u}\right].\]

Recommendation aims to generate a set of items for each user, whose interests may span multiple categories. Therefore, a desirable reasoning trace should guide the model toward diverse types of recommended items. We encourage such diversity by computing an additional reward over the \(K\) itemic token sequences generated from the same reasoning trace. Specifically, we focus on the first digit of the itemic tokens, since the first sub-token largely determines the subsequent decoding process and captures coarse-grained item categories. Let \(m_i^{(1)}\) denote the number of distinct first-digit values among \(\{c^{(1)}_{u,i,j}\}_{j=1}^{K}\). The diversity factor is defined as \[R_{\mathrm{div}}(\mathrm{CoT}_{u,i}) = \frac{\max(0, m_i^{(1)}-1)}{K-1}.\] Encouraging diversity at the first digit promotes broader category-level coverage, which naturally leads to more diverse item predictions. The final reward \(R_{u,i,j}\) thus assigns greater reward to trajectories that both match the target item and lead to better recommendation diversity. The diversity reward is defined at the reasoning-trace level, since all \(K\) itemic token sequences generated from the same reasoning trace share the same diversity factor \(R_{\mathrm{div}}\).

6.1.0.4 Optimization.

GRPO uses clipping to constrain the importance ratio between the updated policy and the behavior policy, which stabilizes policy updates. For each generated token \(o_t\), the importance ratio is defined as \[r_t(\theta) = \frac{ \pi_{\theta}(o_t \mid o_{<t}) }{ \pi_{\mathrm{old}}(o_t \mid o_{<t}) }.\] In reasoning-augmented recommendation, however, reasoning tokens and itemic tokens exhibit substantially different behaviors. Reasoning traces are long and mainly support exploration, whereas the final itemic token sequence is short but directly determines the recommendation reward. Using the same clip range for both stages can make the distribution of itemic tokens change too aggressively and cause entropy collapse. We therefore apply stage-wise clipping, with a looser clip range for reasoning tokens and a tighter clip range for itemic tokens, as illustrated in Figure 12 (a). Specifically, we use two stage-specific clipping ranges, \[\boldsymbol{\epsilon}_{\mathrm{CoT}} = (\epsilon_{\mathrm{CoT}}^{-}, \epsilon_{\mathrm{CoT}}^{+}), \qquad \boldsymbol{\epsilon}_{\mathrm{item}} = (\epsilon_{\mathrm{item}}^{-}, \epsilon_{\mathrm{item}}^{+}),\] where \(\boldsymbol{\epsilon}_{\mathrm{CoT}}\) is looser than \(\boldsymbol{\epsilon}_{\mathrm{item}}\). For each token \(o_t\), the clipping range is selected according to its stage: \[\bar{r}_t(\theta) = \mathrm{clip} \bigl(r_t(\theta), 1-\epsilon^{-}(t), 1+\epsilon^{+}(t)\bigr), \quad \boldsymbol{\epsilon}(t) = \begin{cases} \boldsymbol{\epsilon}_{\mathrm{CoT}}, & o_t \in \mathrm{CoT}, \\ \boldsymbol{\epsilon}_{\mathrm{item}}, & o_t \in \mathbf{c}, \end{cases}\] where \(\boldsymbol{\epsilon}(t)=(\epsilon^{-}(t),\epsilon^{+}(t))\). This preserves reasoning exploration while stabilizing updates on the final recommendation tokens.

To further stabilize GRPO under sparse recommendation rewards, a sample-level importance re-weighting scheme is applied to the actor loss, as illustrated in Figure 12 (b). Since only a small fraction of rollouts hit the ground-truth, most rollouts receive zero reward and contribute negative relative advantages. Without re-weighting, these numerous non-hit samples may dominate the aggregated gradient and push the policy toward overly conservative updates [41], [42]. After the group-relative advantage is computed, each rollout is assigned a scalar weight according to its hit status: \[w_{u,i,j} = \begin{cases} 1.0, & \text{if } R_{\mathrm{rule}}(\mathbf{c}_{u,i,j}) = 1, \\ \beta, & \text{otherwise}, \end{cases}\] where \(\beta < 1\) controls the contribution of non-hit rollouts. The weight is applied to the whole response-level actor loss of the rollout \((\mathrm{CoT}_{u,i}, \mathbf{c}_{u,i,j})\), while the advantage estimation remains unchanged. This preserves the full gradient contribution from successful rollouts and down-weights non-hit rollouts, reducing the dominance of negative-advantage samples without changing the GRPO objective form.

6.1.0.5 Ablation Study.

We first examine the effect of the two-stage rollout design by comparing GRPO with the full recommendation-oriented optimization against an ablated version that removes the two-stage rollout under the same effective rollout size. As shown in Figure 13, we evaluate both training efficiency and recommendation performance. The blue curves correspond to GRPO with full optimization, while the orange curves correspond to the ablated variant. For performance, we evaluate the model on the Cross-Live Recommendation task using Recall@1 and Recall@8 under both thinking and non-thinking inference modes.

The two-stage rollout substantially reduces per-step training time by reusing each generated reasoning trace across multiple itemic token sequences, avoiding repeated generation of long reasoning prefixes. Meanwhile, the performance results show consistent gains, with particularly clear improvements under the thinking mode. These results indicate that expanding multiple recommendations from the same reasoning trace provides denser reward feedback for each reasoning path, enabling GRPO to more effectively optimize recommendation-oriented reasoning.

We further evaluate the effect of the diversity reward using the same ablation setting, where the ablated version removes \(R_{\mathrm{div}}\) from the full reward design. The methods are evaluated on Cross-Live with Recall@1, Recall@8, and Recall@32 under both thinking and non-thinking inference modes. The blue curves denote the fully optimized method, and the orange curves denote the ablated version. Encouraging diversity among the subsequent itemic token sequences from the same reasoning trace helps the model retrieve a broader set of potential items. As a result, as shown in Figure 14, the diversity reward improves the effectiveness of reasoning, with more pronounced gains when Recall@\(K\) is evaluated at larger \(K\).

Finally, we analyze the two optimization-side stabilizers: stage-wise clipping and negative-sample down-weighting. For stage-wise clipping, the ablated version uses the same clipping range for reasoning tokens and itemic tokens. For negative-sample down-weighting, the ablated version removes the sample-level weight \(w_{u,i,j}\). Figure 15 shows the ablation results of stage-wise clipping, and Figure 16 presents the ablation of negative-sample down-weighting. Both designs contribute to more stable training and better performance. Removing stage-wise clipping weakens the recommendation performance, especially the reasoning effectiveness on Recall@8 and Recall@32, indicating that reasoning tokens and itemic tokens benefit from different trust regions during policy optimization. Removing negative-sample down-weighting makes GRPO optimization less stable under sparse recommendation rewards, as abundant non-hit rollouts are assigned the same weight as successful ones. As shown in Figure 16, the ablated model suffers from a higher risk of training collapse, as reflected by a higher tendency to generate invalid itemic tokens and the resulting degradation in recommendation performance.

GRPO sharpens reasoning online but suffers from low sample efficiency on rare-but-correct trajectories. Rejection sampling fine-tuning (Section 6.2) is a natural offline complement: it harvests the small set of self-discovered high-quality rollouts and re-injects them as dense supervision, consolidating broadly useful behaviors that GRPO alone tends to forget between updates.

6.2 Rejection Sampling Fine-tuning↩︎

We first explore rejection sampling fine-tuning (RFT) to consolidate the knowledge of domain-specialized teacher models. RFT transfers domain-specific reasoning ability by selecting verified successful trajectories from each teacher and continuing supervised training on the aggregated trajectory set.

6.2.0.1 RFT workflow.

While domain-specific GRPO improves the model through outcome-driven exploration, its policy optimization also sharpens the output distribution and makes the model concentrate on a small set of high-confidence items [43]. This can improve top-ranked predictions, but not fully aligned with the goal of recommendation, where the model is expected to predict a set of potential items that cover diverse user interests. As a result, RL optimization alone may provide limited improvement for the final recommendation task, especially when the model needs to retrieve a broader set of relevant items.

To complement GRPO, we introduce rejection sampling fine-tuning (RFT) as the consolidation method. Each domain-specialized GRPO model is used as a teacher to generate reasoning-augmented recommendation trajectories. For each user \(u\), we retain trajectories whose predicted item matches the ground-truth set \(\mathcal{C}^{+}_{u}\), filter out low-quality or inconsistent reasoning traces, and merge the remaining verified trajectories across the four domains. This yields an aggregated rejection-sampled dataset \[\mathcal{D}_{\mathrm{RFT}} = \{(x_u, \mathrm{CoT}_{u}, \mathbf{c}_{u})\},\] where \(x_u\) denotes the user context, \(\mathrm{CoT}_{u}\) is the verified reasoning trace, and \(\mathbf{c}_{u}\) is the corresponding itemic tokens.

Before RFT, we first obtain a Mix-RL checkpoint by applying GRPO to mixed data covering R2 evolution and R3 recommendation tasks from all domains until convergence. Initialized from this checkpoint, the unified model is further trained on \(\mathcal{D}_{\mathrm{RFT}}\) with the standard next-token prediction objective: \[\mathcal{L}_{\mathrm{RFT}} = - \mathbb{E}_{(x_u,\mathrm{CoT}_{u},\mathbf{c}_{u}) \sim \mathcal{D}_{\mathrm{RFT}}} \sum_{t=1}^{|y_u|} \log \pi_{\theta} \left( y_{u,t} \mid x_u, y_{u,<t} \right), \quad y_u=[\mathrm{CoT}_{u};\mathbf{c}_{u}].\] In this way, RFT transfers domain-specific reasoning patterns discovered by RL into a single model while maintaining a smoother training objective based on next-token prediction.

6.2.0.2 Performance Analysis.

To analyze the effectiveness of RFT, we compare the performance of RFT against mixed-domain RL as the baseline method across four recommendation domains. We report the relative improvement of RFT over Mix-RL under Recall@\(K\), where \(K \in \{1, 8, 16, 32, 64\}\). This evaluation investigates whether RFT improves only the top-ranked prediction or provides broader gains when the model is asked to retrieve a larger set of relevant items.

As shown in Figure 17, RFT does not always improve Recall@1, especially on Cross-Product and Cross-Live, where the relative improvements at small \(K\) are often negative or close to zero. However, as \(K\) increases, RFT consistently shows stronger advantages across domains. The improvement becomes particularly clear on most domains at larger \(K\), achieving large positive gains across all evaluated cutoffs. This trend suggests that RFT is less focused on sharpening a single top prediction and more effective at improving candidate coverage. Such behavior is better aligned with the goal of recommendation, where the model should retrieve a set of relevant items that can cover diverse user interests rather than only optimize the first prediction.

6.3 Multi-Teacher On-Policy Distillation↩︎

This section introduces multi-teacher on-policy distillation [19], [44]–[46] to integrate specialized capabilities from four domains into a unified student model in an on-policy manner. We adopt a Monte Carlo RL formulation [47], i.e., the log-probability ratio is evaluated only on the token sampled from the student itself at each step. This converts the optimization target into an expectation over sampled trajectories. The teacher is therefore only queried for a single-point log-probability at the sampled token, with no requirement to provide a full vocabulary distribution. The effectiveness of this RL-based formulation stems from the OneReason training pipeline, where the student model has already acquired foundational capabilities across all target domains. As a result, the student’s policy distribution does not exhibit significant deviation from the teacher’s policy. This distributional proximity naturally bounds the variance of the single-point log-probability evaluations. Therefore, we can circumvent the severe high-variance instability that typically plagues sparse RL updates, achieving significantly higher computational efficiency while maintaining stable training.

6.3.0.1 MOPD Objective.

Formally, let \(\mu_\theta\) denote the student’s behavior policy deployed in the inference engine for trajectory generation, and \(\pi_\theta\) denote the policy being actively optimized in the training engine. For a given prompt \(x\), we first sample a complete rollout \(y = (\mathbf{CoT}; \mathbf{c}) \sim \mu_\theta (\cdot \mid x)\). Based on the specific capability domain required by \(x\), we route the prompt to the corresponding domain-expert teacher, denoted as \(\pi_{\mathrm{domain}_i}\). At each timestep \(t\) of the auto-regressive two-stage rollout, we define the token-level distillation advantage under a reverse-KL objective as: \[\hat{A}_{\mathrm{MOPD},t} = \mathrm{sg}\!\left[ \log\pi_{\mathrm{domain}_i}(y_t \mid x, y_{<t})- \log\pi_\theta(y_t \mid x, y_{<t})\; \right], \label{eq:adv}\tag{3}\] Since the trajectories are generated by the behavior policy \(\mu_\theta\) but optimized under the target policy \(\pi_\theta\), we introduce truncated importance weighting \(w_t(\theta)\) to correct for this off-policy discrepancy: \[w_t(\theta) = \begin{cases} \mathrm{sg}\Bigl[ \dfrac{\pi_\theta(y_t \mid x, y_{<t})}{\mu_\theta(y_t \mid x, y_{<t})} \Bigr], & \varepsilon_{\mathrm{low}} \;\le\; \dfrac{\pi_\theta(y_t \mid x, y_{<t})}{\mu_\theta(y_t \mid x, y_{<t})} \;\le\; \varepsilon_{\mathrm{high}}, \\[8pt] 0, & \text{otherwise,} \end{cases} \label{eq:weight}\tag{4}\] where \(\mathrm{sg}[\cdot]\) denotes stop-gradient. We then define the surrogate loss of MOPD as: \[\mathcal{L}_{\mathrm{MOPD}}(\theta) = -\mathbb{E}_{x \sim \mathcal{D},\, y \sim \mu_\theta(\cdot \mid x)} \left[ \frac{1}{|y|} \sum_{t=1}^{|y|} w_t(\theta)\,\hat{A}_{\mathrm{MOPD},t}\, \log \pi_\theta(y_t \mid x, y_{<t}) \right]. \label{eq:mopd}\tag{5}\]

6.3.0.2 Optimization.

Generative recommendation inherently struggles with massive item candidate spaces and highly sparse user-interest signals. In on-policy training, this translates to an exceptionally low hit rate during trajectory rollouts. When applying MOPD to such environments, treating all sampled rollouts uniformly leads to a severe gradient-dilution problem. Specifically, the student model quickly aligns with the teachers on generic, popular “head” items, resulting in near-zero token-level advantages (\(|\hat{A}_{\mathrm{MOPD},t}| \approx 0\)). Consequently, the rare yet crucial domain-specific insights for “tail” items—where the specialized teachers’ expertise is most valuable (characterized by high \(|\hat{A}_{\mathrm{MOPD},t}|\))—are entirely overwhelmed by redundant gradients from already-aligned or noisy samples. To address this problem, we adopt an information-gain-aware trajectory filtering mechanism [48], as shown in Figure 18. Mathematically, the absolute advantage \(|\hat{A}_{\mathrm{MOPD},t}|\) quantifies the instantaneous information gain provided by the teachers. We dynamically discard low-information trajectories, which forces the student to focus on the most dissimilar and informative rollouts. It is crucial for preventing policy performance degradation in environments with inherently low hit rates.

Specifically, we utilize the token-level advantage gap as a label-free indicator of information gain. To quantify the overall deviation from the teacher, we compute the token-average absolute gap for each trajectory \(y_j\) as its informativeness score \(s(y_j)\): \[s(y_j) = \frac{1}{T_i} \sum_{t=1}^{T_i} |\hat{A}_{\mathrm{MOPD},j,t}|.\] This absolute scoring naturally captures the bilateral correction demand: it identifies both instances where the student is overly confident in an incorrect path (\(\hat{A}_{\mathrm{MOPD},j,t} \ll 0\)) and those where it fails to capture the teacher’s domain-specific insights (\(\hat{A}_{\mathrm{MOPD},j,t} \gg 0\)).

Given a training batch \(\mathcal{B}\) and a target information-gain ratio \(\rho\) (e.g., \(\rho = 0.8\)), we sort all sampled rollouts in descending order based on their informativeness scores, yielding the sequence \(x_{(1)}, x_{(2)}, \dots, x_{(|\mathcal{B}|)}\). To effectively filter out the redundant, already-aligned rollouts, we determine the smallest prefix length \(M\) that covers the target information-gain ratio \(\rho\): \[M = \min \left\{ m : \frac{\sum_{j=1}^m s(y_{(j)})}{\sum_{j=1}^{|\mathcal{B}|} s(y_{(j)})} \ge \rho \right\}.\] The active subset retained for optimization is then defined as \(\mathcal{S} = \{y_{(1)}, \dots, y_{(M)}\}\). By discarding the low-information rollouts, we ensure that the optimization budget is concentrated exclusively on the most challenging and informative instances. The final MOPD objective is subsequently computed solely over this filtered subset \(\mathcal{S}\).

6.3.0.3 Performance Analysis.

As illustrated in Figure 19 (a), the proposed training paradigm yields strictly positive performance gains across all evaluated domains. Notably, the relative improvement expands as \(K\) increases in almost all domains. This demonstrates that MOPD effectively revitalizes the student model’s long-tail ranking capability within massive candidate spaces. Furthermore, the thinking mode exhibits a steeper growth trajectory at larger \(K\) compared with the non-thinking mode in the Ad and Live domains. This suggests that the explicit reasoning process significantly broadens the search boundaries, enabling the retrieval of hard-to-find tail items that intuition alone (non-thinking) might miss. Figure 19 (b) shows that the student aligns perfectly with or surpasses the teachers when \(K \le 16\), but a gap remains at \(K > 16\). This remaining gap is a fundamental theoretical limit driven by the reverse-KL objective. Since the reverse-KL objective is inherently mode-seeking, it flawlessly captures the teacher’s primary probability peaks at \(K \le 16\). While our active filtering method maximizes the extraction of long-tail information from the teachers, perfectly replicating the entire distribution of the teachers remains challenging.

6.3.0.4 Ablation Study.

We first analyze the effect of the information-gain-aware trajectory filtering mechanism. Figure 21 illustrates the policy gradient (PG) loss. MOPD without filtering (blue) exhibits larger variance and a steep initial drop, indicating unstable optimization and overfitting to redundant “head” items. In contrast, MOPD with filtering (orange) significantly suppresses gradient noise, enabling a smoother and more stable convergence by exclusively focusing on high-information samples.

The relative Recall@\(K\) curves in Figure 20 provide a direct empirical validation of our core motivation, i.e., gradient budget reallocation based on trajectory-level information gain. The optimization budget is successfully concentrated on high-divergence, high-information samples (\(s(y_j) \gg 0\)). This focused gradient flow directly translates into the steep, upward performance trajectory starting at \(K \ge 8\) and culminating in positive gains at \(K=64\). By reallocating the training focus from redundant easy items to challenging long-tail items, our filtering mechanism effectively mitigates the gradient dilution bottleneck, allowing the unified student to capture the specialized long-tail capabilities of the expert teachers under a highly constrained parameter budget.

Further, we investigate the impact of different student selection, including SFT, SFT\(\rightarrow\)RFT, and SFT\(\rightarrow\)Mix-RL. As shown in Figure 22, all three students can benefit from MOPD training. When student and teacher distributions are roughly aligned, even with initial differences in student levels, MOPD can consistently improve student performance to a level near or even slightly surpassing that of the teachers. This indicates that the teacher’s upper bound limits the extent of improvement in MOPD. Specifically, even weaker students can catch up with the teacher, but it is difficult for them to surpass the teacher significantly.

6pt

6.4 Comparison and Discussions↩︎

In this section, we compare the recommendation accuracy of five optimization strategies: the SFT checkpoint, mixed-domain RL, domain-specific RL, RFT, and MOPD. The evaluation is conducted under the cross-domain recommendation setting, where we report Recall@K for the Cross-Video, Cross-Product, Cross-Ad, and Cross-Live tasks. This comparison allows us to examine whether the model learns better reasoning through self-exploration, whether the “specialize-then-unify” strategy alleviates cross-domain interference, and how different teacher-knowledge integration methods affect the final performance.

As shown in Table 8, all post-SFT optimization methods substantially improve over the SFT baseline on all domains and metrics, indicating that learning from self-exploration can further enhance recommendation performance beyond supervised imitation. However, directly mixing all domains during RL does not consistently achieve the best performance. Compared with domain-specific RL, mixed-domain RL generally yields weaker performance, suggesting that heterogeneous domains can introduce conflicting optimization signals. The two knowledge-integration methods then provide complementary benefits. RFT achieves strong and stable gains, especially on Cross-Video, showing that verified successful trajectories can effectively consolidate domain-specific reasoning patterns. MOPD performs competitively and obtains the best results in several settings, indicating that policy-level distillation can better preserve teacher preferences in some domains. Overall, these results support the effectiveness of the “specialize-then-unify” strategy: domain-specific RL first discovers effective reasoning behaviors, while subsequent knowledge integration transfers these domain-specialized capabilities into a unified model.

We further compare the impact of two integration paradigms, MOPD and RFT. We have several findings:

• MOPD and RFT exhibit domain-specific strengths. MOPD achieves superior performance in Product and Live domains, even significantly outperforming the Live teacher. Conversely, RFT consistently yields marginal and stable advantages over MOPD, particularly at larger \(K\) values in Video and Ad domains.

• RFT consistently guarantees that the thinking mode outperforms the non-thinking mode across all domains and \(K\) values. In contrast, the improvements of MOPD in the thinking and non-thinking modes are highly synchronized, with the non-thinking mode achieving competitive gains.

This divergence is driven by the extreme reward sparsity of recommendation tasks and the distinct sampling dynamics of the two paradigms:

• RFT: In a massive item candidate space, successful reasoning paths are extremely sparse. RFT bypasses this exploration bottleneck offline by executing multiple rollouts and strictly retaining only those that yield correct outcomes. This rejection-sampling process distills only “golden” reasoning paths in which the CoT is logically aligned with the correct recommendation, thereby securing a stable reasoning benefit (\(\textit{thinking} > \textit{non-thinking}\)).

• MOPD: Conversely, MOPD relies on on-policy distillation, continuously aligning the student’s generated distributions with the teachers across all rollouts (regardless of whether the CoT perfectly hits the target). Because the student processes these rollouts within a shared parameter space, this continuous distillation calibrates the foundational prompt-to-item semantic embeddings holistically. As a result, the nonthinking capability itself is massively enhanced. Therefore, MOPD produces a synchronized uplift: it improves the \(\textit{thinking}\) capability while simultaneously and profoundly strengthening the underlying “intuition” (\(\textit{non-thinking}\)). However, successful CoTs are extremely sparse. Without strict off-policy filtering of correct CoT, the on-policy process inevitably absorbs noisy or ungrounded CoT steps from the weak priors. This noise might prevent the thinking mode from fully unlocking its theoretical superiority to consistently eclipse the massively enhanced non-thinking baseline.

7 CoT Analysis Indicators↩︎

Beyond target accuracy, the practical utility of recommendation reasoning traces depends on whether the CoT genuinely contributes to the final itemic pattern prediction, remains faithful to the observed user history, respects the structural constraints of the itemic token space, and follows a coherent intent-evolution trajectory. Recent evidence suggests that free-form reasoning in itemic token-based recommendation foundation models may introduce a general-subspace prior, where textual inertia dominates inference and dilutes critical itemic pattern evidence [49]. Motivated by this observation, we design a four-criterion diagnostic framework to evaluate the quality of generated CoT traces. We organise them along two orthogonal axes that together cover the full diagnostic surface of a recommendation reasoning trace. The four criteria populate this \(2\times 2\) matrix exactly once each (Table 9).

• Symbolic vs.Probabilistic (what kind of check?). A symbolic check inspects the discrete set of itemic pattern referenced inside the CoT against a static reference set; it requires only string parsing and set operations, runs without a model forward pass and without access to \(y_{\mathrm{GT}}\). A probabilistic check inspects how the CoT shifts the conditional log-likelihood of the target \(y_{\mathrm{GT}}\); it requires both a model forward pass and the ground-truth label, and is therefore strictly costlier but directly measures predictive effect.

• Local vs.Global (against which reference scope?). A local check compares against a narrow, instance-bounded reference (the current user’s history, or the immediately preceding reasoning prefix). A global check compares against a wide, corpus-bounded or trace-bounded reference (the full item catalog, or the entire CoT versus the no-CoT baseline).

4pt

7.0.0.1 Criterion 1: CoT Likelihood Gain.

We first quantify whether the generated CoT contributes positively to the prediction of the ground-truth target. Inspired by the analysis of CoT-induced distributional shift in [49], we define the CoT likelihood gain as: \[\begin{align} \Delta{LL} = \log p\!\left(y_{\mathrm{GT}} \mid \mathbf{x}, c\right) - \log p\!\left(y_{\mathrm{GT}} \mid \mathbf{x}\right), \label{eq:cot95gain} \end{align}\tag{6}\] where \(\mathbf{x}\) denotes the input context, including the user profile and interaction history, \(c\) denotes the generated CoT, and \(y_{\mathrm{GT}}\) is the ground-truth target itemic pattern. A positive \(\Delta{LL}\) indicates that conditioning on the CoT increases the model’s likelihood of the correct target, whereas a negative value suggests that the CoT distracts the model from the history-grounded itemic pattern evidence.

As shown in Figure 23, for each model-domain pair, we rigorously compute \(\Delta{LL}\) by contrasting the target log-likelihood under the thinking mode, where prediction is conditioned on the generated CoT, with that under the non-thinking mode, where the target is predicted directly from the input context without CoT. We then report the average per-sample \(\Delta{LL}\) values of the SFT and RFT models across four domains. The SFT model consistently yields negative \(\Delta{LL}\) values in all domains, indicating that its generated CoT tends to distract the model from the ground-truth target prediction. In contrast, the RFT model achieves positive \(\Delta{LL}\) values across all four domains, demonstrating that the RFT stage significantly improves the ability of the generated CoT to contribute positively to the prediction of the ground-truth target.

7.0.0.2 Criterion 2: Log-Likelihood Progression Along the CoT.

A high-quality reasoning trace should progressively strengthen the model’s confidence in the ground-truth target as the reasoning process unfolds. To characterize this intent-evolution behavior, we examine how the target likelihood changes along the CoT.

To obtain intermediate reasoning units, we use DeepSeek [46] to segment the original CoT into a sequence of semantically coherent reasoning segments: \[\begin{align} c = \{c_1, c_2, \ldots, c_T\}. \end{align}\]

For each prefix of the segmented CoT, we compute the conditional log-likelihood of the ground-truth target: \[\begin{align} \ell_t = \log p\!\left( y_{\mathrm{GT}} \mid \mathbf{x}, c_1, \ldots, c_t \right), \quad t = 1,\ldots,T. \label{eq:ll95progression} \end{align}\tag{7}\]

As shown in Figure 24, in the thinking mode setting, progressively incorporating segmented CoT prefixes consistently improves the conditional log-likelihood of the ground-truth target for both the SFT and RFT models. Compared with the thinking mode prediction without CoT, the likelihood trajectories of all four domains rise substantially as more reasoning segments are added, indicating that the generated CoT provides incremental predictive evidence rather than serving as a merely post-hoc explanation. This trend is observed in both optimization stages: the SFT model already benefits from CoT prefixes, while the RFT model further exhibits stronger and more stable likelihood improvements across domains. Although a few domains show minor fluctuations at later prefixes, the overall upward progression demonstrates that, under the thinking mode inference setting, the current models can effectively exploit their generated CoT to strengthen confidence in the ground-truth target.

While both SFT and RFT benefit from progressively incorporating CoT prefixes, RFT exhibits a much earlier saturation behavior, reaching near-optimal likelihood after only a few reasoning segments. This suggests that not all generated reasoning tokens contribute equally to prediction, and that a substantial portion of the predictive gain can be achieved with a shortened CoT, leaving room for future exploration of reasoning compression or adaptive early-stopping mechanisms.

7.0.0.3 Criterion 3: Item Legality.

Every itemic pattern referenced in the CoT should also correspond to a valid identifier in the item corpus. Let \(\mathcal{V}_{\mathrm{item}}\) denote the complete item catalog. We define the item legality ratio as: \[\begin{align} \gamma_{\mathrm{legal}} = \frac{ \left| \mathcal{S}(c) \cap \mathcal{V}_{\mathrm{item}} \right| }{ \left| \mathcal{S}(c) \right| }, \label{eq:itemic95id95legality} \end{align}\tag{8}\] Invalid itemic patterns indicate that the reasoning trace contains structurally illegal item identifiers, which may introduce noise into subsequent itemic token prediction. As shown in Table 10, \(\gamma_{\mathrm{legal}}\) already saturates at \(1.00\) for both SFT and RFT across all four domains, providing a clean basis on which the conditional history-grounding measure of Criterion 4 can be evaluated.

7.0.0.4 Criterion 4: History Item Reference Validity (conditioned on item legality).

Since our prompt explicitly constrains the CoT to reason only based on the observed user history, every legal itemic pattern mentioned in the CoT should further correspond to an item that actually appears in the user’s interaction history. Differently from a raw history-grounding ratio over \(\mathcal{S}(c)\), we condition the measurement on item legality being satisfied: we first restrict the referenced set to its legal subset \(\mathcal{S}(c)\cap\mathcal{V}_{\mathrm{item}}\), and then measure the fraction of this subset that is supported by the user’s history \(\mathcal{S}(\mathbf{x}_{\mathrm{hist}})\). This explicitly disentangles the orthogonal failure mode of history-violating hallucination from the upstream failure of illegal-identifier generation captured by Criterion 3. Formally, \[\begin{align} \gamma_{\mathrm{hist}\mid\mathrm{legal}} = \frac{ \left| \big(\mathcal{S}(c)\cap\mathcal{V}_{\mathrm{item}}\big) \cap \mathcal{S}(\mathbf{x}_{\mathrm{hist}}) \right| }{ \left| \mathcal{S}(c)\cap\mathcal{V}_{\mathrm{item}} \right| }, \label{eq:history95itemic95id95validity} \end{align}\tag{9}\] where \(\mathcal{S}(c)\) denotes the set of itemic patterns extracted from the CoT and \(\mathcal{S}(\mathbf{x}_{\mathrm{hist}})\) the set of itemic patterns appearing in the interaction history. A low \(\gamma_{\mathrm{hist}\mid\mathrm{legal}}\) indicates that, even after illegal references have been filtered out, the CoT still introduces itemic patterns unsupported by the observed history, i.e.prompt-violating reasoning that hallucinates beyond the user’s actual behaviour.

5pt

7.0.0.5 Qualitative Illustration: SFT vs.RFT on the Same User.

To complement the aggregate diagnostics in Criterion 1–Criterion 4, we present a representative user for whom the SFT and RFT models produce markedly different reasoning traces over the same input context. The user is an 18–23 year-old male student whose recent interaction history is dominated by tactical-shooter livestreams, smartphone reviews, and snack purchases; the ground-truth next item is a video about equipment in Delta Force, a recently released tactical-shooter title that the user has only clicked once via an in-feed advertisement—i.e., a target that requires cross-IP generalisation rather than mere historical replay. Table 11 and Table 12 present the two CoT traces verbatim, organised along the same Persona Abstraction \(\rightarrow\) Interest Expansion \(\rightarrow\) Transition Inference structure for direct comparison.

5pt

In contrast, the RFT model, faced with the identical input context, produces a reasoning trace that opens with a catalogue-grounded quantitative prior and lifts the candidate space from a single IP to a latent category axis, as shown in Table 12. The critical gain comes from R1-derived interest evolution: instead of replaying Peace Elite or PUBG as surface names, RFT bridges them to the tactical-shooter category and then to Delta Force through a weak but history-supported ad-click signal.

Linking the case to the four criteria. This single example concretely instantiates all four quantitative findings. The SFT trace lands on the wrong IP family and would lower the target likelihood, whereas the RFT trace commits to Delta Force early in its candidate enumeration and merely defends the choice afterwards—mirroring the positive \(\Delta\mathrm{LL}\) in Criterion 1 and the earlier \(\ell_t\) saturation in Criterion 2. Moreover, the RFT trace anchors its reasoning to a catalogue-grounded statistic ([Gaming]\(=69.57\%\)) rather than free-form qualifiers, while both traces reference only history-supported items, consistent with the higher \(\gamma_{\mathrm{legal}}\) (Criterion 3) and saturated \(\gamma_{\mathrm{hist}}\) (Criterion 4) of RFT in Table 10.

5pt

Crucially, the difference between the two traces is not lexical polish but abstraction level: SFT reasons over surface IP names (Peace Elite \(\to\) more Peace Elite), whereas RFT reasons over a latent category axis (“tactical shooter”) and is therefore able to bridge from observed evidence (Peace Elite, PUBG comment, Delta Force ad click) to a target IP that has only been weakly exposed in history. This category-level generalisation is what the \(2\!\times\!2\) diagnostic framework in Table 9 is designed to detect, and it is what RFT systematically delivers.

8 Experiments↩︎

8.1 Performance Comparison↩︎

8.1.0.1 Baselines.

We compare OneReason with representative baselines on four cross-domain recommendation tasks. We group the evaluated models by how they represent items:

• ID-Based: Items are represented by conventional item IDs. This group includes standard sequential recommendation models, namely SASRec [50] and HSTU [51].

• Text-Based: Items are represented by natural-language item dense captions. This group evaluates general-purpose LLMs under a zero-shot protocol on all tasks, with thinking mode enabled where supported. For recommendation, the LLMs generate a potentially relevant item caption, which is then encoded by Qwen3-Embedding-8B [52] along with the candidate item captions, and recommendations are obtained through approximate nearest-neighbor (ANN) retrieval.

• Itemic Token-Based: Items are represented by itemic tokens. In addition to OneReason variants, we evaluate TIGER [53] and LC-Rec [54]. For LC-Rec, we report three variants: LC-Rec-SFT-Only-8B, LC-Rec-SFT-Only-14B, and LC-Rec-PT-SFT-8B (initialized from Qwen3-8B, Qwen3-14B [23], and our OneReason pre-training checkpoint). Following the original LC-Rec setting, its SFT data covers only recommendation and caption tasks.

8.1.0.2 Recommendation Performance.

Based on the evaluation results in Table 13, we highlight the primary reasons for the limited performance of ID-based and text-based baselines:

• Cold-Start Sensitivity: Traditional ID-based models struggle in cross-domain evaluation because 33.69% of target item IDs are unseen during training, causing severe cold-start issues; by contrast, only 11.55% of target itemic patterns are unseen, as reported in Appendix 14.2.

• Limits of Text-Based LLM Recommendation: More advanced general-purpose LLMs do not necessarily produce better recommendations, suggesting that recommendation ability is not reliably correlated with general intelligence or model scale. Their underperformance stems from the absence of collaborative signals and the errors introduced by ANN-based caption-to-item retrieval. In contrast, OneReason avoids this additional retrieval step by directly decoding itemic tokens. Pointwise scoring or better retrieval may yield stronger recommendations; we leave their study to the community.

• Effect of OneReason Pre-Training: The LC-Rec results show that our OneReason pre-training checkpoint provides a strong semantic foundation for itemic-token recommendation. Compared with the LC-Rec-SFT-Only variants, LC-Rec-PT-SFT-8B achieves a clear performance jump across all four domains, demonstrating the effectiveness of our OneReason pre-training strategy.

8.1.0.3 Non-Recommendation Performance.

Table 14 evaluates R0–R2 capabilities on OneReason-Bench. Two findings stand out:

• RFT thinking helps higher-level reasoning. RFT thinking lags non-thinking on R0, consistent with perception-task overthinking [55], but improves average R1–R2 performance. Together with the recommendation gains in Table 13, this suggests that our RL improves recommendation while strengthening higher-level reasoning.

• OneReason makes compact itemic tokens competitive. Text-based LLMs are given richer inputs, whereas OneReason uses compact itemic tokens. Even under this input-information disadvantage, OneReason surpasses several larger advanced LLMs on parts of the R2 suite. This suggests that OneReason can perform efficient and effective long-sequence user modeling.

4pt

8.1.0.4 General-Intelligence Sanity Check.

Table 15 shows that in thinking mode, OneReason preserves its Qwen3-8B backbone’s general reasoning and instruction-following abilities on these four representative benchmarks after recommendation-oriented training, providing preliminary evidence that recommendation-oriented training does not catastrophically degrade general capabilities. In contrast, LC-Rec variants suffer substantial degradation across all benchmarks.

6pt

8.2 Non-Thinking Gains from Thinking Supervision↩︎

Although the recommendation CoT data in Section 5.4.1 is constructed to provide compact, evidence-grounded recommendation reasoning rather than to directly optimize non-thinking decoding, we observe an important downstream phenomenon: thinking supervision can improve direct recommendation even when explicit reasoning traces are suppressed at inference time. We study this phenomenon by comparing CoT and unCoT recommendation supervision under controlled training budgets. For clarity, we use unCoT to denote recommendation samples without explicit reasoning traces, where the model directly predicts the target itemic tokens from the user context. In contrast, CoT samples contain a trace before the final target, generated by the three-stage compression–reasoning protocol in Section 5.4.1: persona abstraction, interest expansion, and transition inference.

We first conduct a controlled token-aligned experiment. We compare two settings: (i) continued SFT on 100K unCoT samples; and (ii) continued SFT on a mixture of 40K CoT samples and 50K unCoT samples. Since CoT samples are longer than unCoT samples, the latter two SFT settings are aligned to the same training token budget of 0.25B tokens. All models are evaluated using the same non-thinking decoding format, where the model directly predicts target itemic tokens without generating a reasoning trace.

7pt

Table 16 shows that, under the same token budget, replacing part of the unCoT data with CoT data improves non-thinking performance on Cross-Video, Cross-Product, and Cross-Live. For example, the mixed setting improves Pass@64 from 1.64% to 1.95% on Cross-Video, from 4.38% to 4.86% on Cross-Product, and from 18.12% to 20.32% on Cross-Live. Cross-Ad is the main exception, where the mixed setting is slightly worse than unCoT-only training. This suggests that the benefit of CoT supervision is not uniform across domains, and motivates a finer-grained analysis of the CoT/unCoT mixture ratio.

We then conduct a sample-count-controlled mixture sweep. Under a fixed budget of 100K recommendation samples, we vary the ratio between CoT and unCoT samples. Let \(\alpha\) denote the unCoT ratio: \[\begin{align} \alpha = \frac{N_{\mathrm{unCoT}}}{N_{\mathrm{CoT}} + N_{\mathrm{unCoT}}}, \qquad 1-\alpha = \frac{N_{\mathrm{CoT}}}{N_{\mathrm{CoT}} + N_{\mathrm{unCoT}}}. \end{align} \label{eq:exp-uncot-cot-ratio}\tag{10}\]

For each mixture ratio, we train a model from the same starting checkpoint and evaluate it with non-thinking decoding. Figure 25 reports the relative Pass@32 gain over the 100% unCoT baseline, defined as: \[\begin{align} G_d(\alpha) = \frac{ \mathrm{Pass@32}_d(\theta_{\alpha}) - \mathrm{Pass@32}_d(\theta_{1.0}) }{ \mathrm{Pass@32}_d(\theta_{1.0}) }, \end{align} \label{eq:exp-relative-pass32-gain}\tag{11}\] where \(d\) denotes the target domain, \(\theta_{\alpha}\) is the model trained with unCoT ratio \(\alpha\), and \(\theta_{1.0}\) is the model trained with 100% unCoT data.

Figure 25 shows that the response curve is not simply monotonic. Instead, most domains exhibit a clear intermediate optimum. Cross-Video reaches its best result near a balanced mixture, Cross-Product prefers a more CoT-heavy mixture, and Cross-Live also benefits from a balanced or moderately CoT-rich mixture. Cross-Ad, in contrast, shows a much flatter curve, and its best point lies closer to the unCoT side. These results support the conclusion from the token-aligned experiment: CoT supervision can improve non-thinking inference in most domains, but the best mixture depends on the domain.

We interpret this phenomenon as a balance between two types of supervision. unCoT data matches the non-thinking inference format and directly teaches the model to map user context to target itemic tokens. CoT data provides an additional training signal with two components: a compression signal, which teaches persona and trajectory abstraction from long behavior histories, and a reasoning signal, which teaches transition judgement from the compressed state and supporting evidence to target-domain decisions. During non-thinking decoding, the model does not explicitly generate the trace. A plausible hypothesis is that part of the compact user-state construction and evidence-selection bias learned from CoT supervision is still reflected in the model parameters. The current experiment supports this hypothesis at the behavioral level, but it does not identify the exact contribution of compression versus reasoning.

However, more CoT data is not always better. CoT traces are longer than unCoT answers, so excessive CoT training may weaken the density of final-target supervision. CoT traces may also contain noise or over-explanation, and the training format may become less aligned with non-thinking decoding. Therefore, the best mixture is obtained when the reasoning signal from CoT and the direct target signal from unCoT are properly balanced.

Formally, we use the following conceptual decomposition to describe the non-thinking gain in domain \(d\) under unCoT ratio \(\alpha\): \[\begin{align} G_d(\alpha) = B_d + A_d^{\mathrm{uncot}}(\alpha) + I_d^{\mathrm{cot}}(1-\alpha) - C_d^{\mathrm{trace}}(1-\alpha) - C_d^{\mathrm{format}}(\alpha,1-\alpha), \end{align} \label{eq:exp-nothink-gain-decomposition}\tag{12}\] where \(B_d\) denotes the base capability in domain \(d\), \(A_d^{\mathrm{uncot}}\) denotes the direct-answer alignment benefit from unCoT data, \(I_d^{\mathrm{cot}}\) denotes the signal absorbed from CoT data, \(C_d^{\mathrm{trace}}\) denotes the cost of noisy or over-long traces, and \(C_d^{\mathrm{format}}\) denotes the mismatch between CoT-format training and non-thinking decoding. Conceptually, \(I_d^{\mathrm{cot}}\) contains both a compression component, which teaches the model to form a compact user-interest state, and a reasoning component, which teaches the model to connect this state to target-domain decisions. We use this as a conceptual decomposition only, not as an identifiable additive estimate from the current experiments. The empirical optimum \(\hat{\alpha}_d^\star\) in Figure 25 can be understood as the point where the marginal benefit of adding more unCoT data balances the marginal loss of reducing CoT supervision: \[\begin{align} \frac{\partial G_d(\alpha)}{\partial \alpha} \bigg|_{\alpha=\hat{\alpha}_d^\star} \approx 0. \end{align} \label{eq:exp-mixture-stationary-point}\tag{13}\] This equation is only a conceptual explanation and does not assume that the entire curve follows a quadratic law. It simply states that the best mixture appears when direct-answer alignment and CoT-based supervision reach a domain-specific balance.

One hypothesis for the domain difference is that different tasks rely on different evidence sources. Cross-Video and Cross-Live may benefit from CoT because their user histories often contain diverse signals and multiple plausible intent directions, making evidence organization useful before prediction. Cross-Product may be more sensitive to CoT-heavy training because purchase intent often has to be inferred from content cues and behavior transitions. By contrast, Cross-Ad may depend more on short-term conversion signals and business exposure patterns that are only partially captured by natural-language reasoning traces, which could explain why it favors unCoT-heavy training and shows a flatter curve.

Overall, these experiments reveal a useful but domain-dependent effect of thinking supervision on non-thinking recommendation. High-quality thinking supervision can improve direct non-thinking recommendation in most domains under appropriate mixture ratios, but Cross-Ad shows that CoT is not universally beneficial and should not be used more aggressively by default. This makes CoT data valuable as part of a potential data flywheel for recommendation foundation models: CoT construction can strengthen the backbone, the improved non-thinking model can produce better candidates and filtering signals, and explicit thinking-mode inference can still be reserved for harder cohorts where trace generation is worth the extra latency.

9 Deployment↩︎

In the rapidly growing local-services advertising scenario of the Kuaishou App, we have successfully deployed OneReason. Under strict latency, strong baseline, and item-deliverability constraints, the system achieves stable online deployment and delivers the one of the most significant business uplifts in the Kuaishou local-services advertising scenario. This section focuses on the online deployment of OneReason, including Industrial Scenario Adaptation and Online Deployment Architecture, as well as a set of reusable methodologies distilled from the OneReason deployment.

9.1 Industrial Scenario Adaptation↩︎

Given a strong and high-performing OneReason foundation model, efficiently adapting it to a specific industrial scenario becomes a critical challenge. Notably, the Kuaishou life-service advertising scenario is not included in the OneReason training data. To address this, we propose a standardized and reusable continuous training pipeline that enables rapid domain adaptation and can be easily generalized to other industrial application scenarios. Further details are provided in Appendix 13.1.

9.2 Industrial Scenario Online Deployment↩︎

Due to the scale of LLMs and the limitations of inference systems, directly deploying OneReason for real-time recommendation still faces significant latency and computational cost challenges. In this section, we propose a new online architecture for OneReason, the “Fast-Slow Thinking” architecture, and further introduce an online incremental training strategy to ensure model performance.

“Fast-Slow Thinking” Architecture in the Online Deployment. This architecture avoids fully relying on real-time inference and instead introduces a Fast (Online) and Slow (Nearline) collaboration mechanism, continuously injecting OneReason’s knowledge and reasoning capabilities into the system while maintaining low latency and stable gains. The workflow is shown in Figure 26.

• Step 1: Pipeline Design. We build a decoupled nearline retrieval pipeline that does not participate in early-stage competition. Instead, it is integrated into the downstream ranking model for joint scoring with the real-time OneRec outputs. When OneReason retrieval results are unavailable, the system automatically falls back to the original OneRec pipeline to ensure stability and coverage.

• Step 2: Dataset Trigger. We periodically (daily or hourly) aggregate distributed data jobs to construct user behavior, user profile, and item content data. An online pipeline is then triggered for data fetching, cleaning, and feature processing, forming an end-to-end data flywheel.

• Step 3: Offline Inference. After dataset preparation, we load the latest OneReason checkpoint to predict the user’s most likely next itemic tokens offline. These tokens are then decoded into item IDs using our specialized decoding strategy for OneReason (as discussed in Appendix 13.4.2).

• Step 4: Online Serving. The decoded item IDs are written to Redis via offline inference jobs, forming a candidate pool for online serving. During inference, the nearline OneReason results and real-time OneRec retrieval results are jointly fed into the ranking model for unified fusion, enabling a Fast-Slow Thinking recommendation system.

Online Incremental Training Strategy. The online platform continuously introduces new items, while user interests and intents also evolve over time. Therefore, an incremental training mechanism is required to adapt OneReason to long-term business evolution while preserving its existing capabilities and ensuring stable online performance. The procedure is as follows:

• Pre-Training Incremental Training. We conduct periodic continual pre-training on newly introduced items within fixed time windows to keep pace with the latest content distribution. To prevent catastrophic forgetting and maintain the general reasoning capabilities of OneReason, we jointly train on a mixture of newly collected data and a sampled general-domain corpus.

• SFT Incremental Training. We construct daily incremental training data from user logs, using same-day user interactions as supervision signals for OneReason training, which models short-term interest dynamics and improves sensitivity to preference shifts.

Two Application Paradigms of OneReason. We design two application paradigms of OneReason under the “Fast–Slow Thinking” architecture in the online deployment, both yielding significant online gains and demonstrating the strong modeling and generalization capabilities of OneReason.

• Slow Pipeline: OneReason. This method directly employs OneReason for retrieval. Specifically, OneReason leverages user profile information and historical interaction sequences to predict the next itemic tokens that the user is most likely to engage with, which are then decoded into a candidate item list serving as the retrieval output of the Slow pipeline.

• Fast Pipeline: OneReason for OneRec. We leverage the outputs of OneReason to enhance recommendations, where the most relevant itemic tokens are transformed into embedding representations. In OneRec, we introduce a dedicated Thinking Token to incorporate these signals, which serves to distill knowledge from OneReason into the online OneRec within the Fast pipeline. The overall methodology is provided in Appendix 13.2.

9.3 Online Experiment↩︎

We conducted a 10-day online A/B experiment by deploying OneReason in a subpart of the local-services scenario of the Kuaishou App, using a 5% traffic allocation for both the treatment and control groups. Users in the treatment group were served by the “Fast-Slow Thinking” architecture of OneReason, whereas users in the control group remained on the existing recommendation system.

Table 17 shows that both directly using OneReason for retrieval and using it to enhance the real-time OneRec yield significant improvements in the online A/B experiment. The direct application in the slow pipeline improves Revenue, while enhancing OneRec in the fast pipeline further boosts performance. Combining both paradigms achieves the best results, with substantial gains in Revenue and Impressions, corresponding to hundreds of millions of RMB in annualized commercial revenue for the Kuaishou platform. Moreover, we compute the ratio between computational resource consumption and revenue, demonstrating that OneReason achieves an ROI \(>\) 5. More experimental analysis and discussion are provided in Appendix 13.3 and 13.4.

10 Related Works↩︎

With the rapid advancement of artificial intelligence, leveraging AI to reshape industrial systems has become a major direction in both industry and academia. Recommendation systems have increasingly adopted LLMs to improve user experience and business performance. Recent generative recommendation frameworks, such as the OneRec series, demonstrate strong modeling capacity, scalability, and system efficiency. However, most existing methods largely remain within a System-1 single-pass inference paradigm. Inspired by reasoning-oriented foundation models such as OpenAI O1 [9] and DeepSeek R1 [10], researchers are beginning to explore a Think-then-Generate paradigm. As recommendation environments become increasingly complex and dynamic, incorporating structured reasoning into generative foundation models (GFMs) has emerged as a promising research direction. In this section, we provide an overview of recommendation foundation models and reasoning-enhanced generative frameworks. Building upon these developments, we illustrate how the OneReason Think-then-Recommendation paradigm differs from existing GFMs.

Following the rise of LLMs, researchers began exploring their direct application to recommendation tasks, leveraging their rich world knowledge and strong instruction-following capabilities. Typical approaches formulate user profiles and interaction histories as prompts, allowing LLMs to reason about user preferences before generating recommendation results. Representative works include GPT4Rec [56], Chat-Rec [57], LLMRank [58], and LLM as Zero-Shot Ranker [59]. However, as research on LLM4Rec advances, it has become clear that general-purpose LLMs struggle to fully capture the characteristics of recommendation tasks, leading to performance bottlenecks. This has motivated two main directions for integrating LLMs with recommendation systems. The first follows an LLM-backbone paradigm to enhance existing recommendation models, represented by the OneRec series. The second aims to train recommendation foundation models that can directly perform recommendation.

In the first direction, TIGER [53] is an early industrial work on generative recommendation, introducing RQ-VAE-based itemic tokens and framing recommendation as an end-to-end generation task from user sequence itemic patterns to next-item representations. HSTU [51] further replaces traditional multi-stage pipelines with a Transformer-based backbone and explores scaling laws for generative recommendation. The OneRec series [13], [14], [60]–[63] then engineers this paradigm into a unified pre-train and post-train framework, demonstrating strong modeling and efficiency advantages. Subsequent work focuses on issues such as diversity control [64], end-to-end pipelines [65], [66], ultra-long user sequence modeling [67], and industrial scenario constraints [68]–[70].

In the second direction, research focuses on building recommendation foundation models by adapting LLMs to recommendation data, leveraging their world knowledge and reasoning ability. LC-Rec [20] shows that LLMs can understand recommendation semantics via itemic ID alignment and instruction tuning. RecGPT [71] and RecGPT-V2 [72] further use LLMs for user intent modeling in retrieval and interest mining, with small-scale online validation. However, these methods mainly focus on user intent modeling and do not achieve full end-to-end decision-making. OxygenREC [73] follows a similar idea to RecGPT, using fast–slow thinking to generate contextual instructions for downstream models. Nevertheless, these approaches remain LLM-augmented recommendation systems rather than true end-to-end generative foundation models. In contrast, our goal is to build an industrially deployable GFMs paradigm that enables direct reasoning-based recommendation decisions with measurable online impact. OpenOneRec [14] is an important precursor, proposing a novel Think-then-Recommendation paradigm. They also propose RecIF-Bench, large-scale datasets, and 1.7B/8B foundation models with multiple training strategies, including Text Alignment, Co-Pretraining, Multi-task SFT, and Rec-RL. However, it remains unclear whether its reasoning consistently translates into real recommendation performance gains, leaving room for further investigation. The most directly comparable diagnostic work is [49], which formally measures the non-thinking/thinking gap on OpenOneRec and attributes it to textual inertia from the general subspace: itemic token embeddings and general-text embeddings share latent dimensions but are misaligned, so a longer CoT lets the general-text prior dominate and dilute ID-grounded evidence. In OneReason, we address this issue at training time across elaborate training pipelines to guide more robust itemic perception and cognition CoT.

In traditional generative recommendation models, researchers have early on incorporated the reasoning capability of LLMs by introducing explicit or implicit reasoning mechanisms. Since generative recommendation operates within the recommendation space and lacks an explicit CoT paradigm, most existing methods adopt latent reasoning, injecting reasoning signals from LLM outputs or internal system signals. For example, ReaRec [74] introduces multi-step reasoning into generative recommendation, iteratively feeding high-dimensional reasoning results back to refine user representations. OnePiece [75] further extends this idea by integrating LLM-style context engineering and reasoning into industrial recommendation systems via a reasoning-block design, enabling progressive alignment between intermediate states and recommendation logic. In contrast, OneSearch-V2 [76] leverages LLMs with CoT to deeply understand complex user queries and distills such reasoning capability into recommendation model parameters via self-distillation. Meanwhile, REG4Rec [77] addresses reasoning diversity and reliability by constructing multiple item-level semantic representations to enable multi-path reasoning and introducing self-reflection to prune inconsistent reasoning paths.

11 Conclusion & Future Work↩︎

In this work, we propose OneReason, a reasoning foundation model that connects the large language model and the recommendation system into one single model, enabling recommendation with wisdom. Specifically, we conduct extensive modifications: (1) in the pre-training stage, we utilize a content-understanding task rather than contrastive supervision to obtain discrete itemic tokens, and use 578B tokens to align the itemic-token and text-token semantic spaces; (2) in SFT, we design a standardized coarse-to-fine, logically coherent CoT structure to ensure the quality of the thinking trace; and (3) in RL, we conduct a specialize-then-unify recipe to improve thinking-mode ability while balancing performance across multiple services.

Equipped with these techniques, to our knowledge, OneReason is the first work in which the thinking mode consistently outperforms the non-thinking mode on downstream recommendation benchmarks, suggesting that reasoning can be translated into real recommendation gains. More interestingly, we also find that replacing ordinary unCoT data with thinking CoT data improves non-thinking inference in several domains. This suggests that some benefits of CoT supervision can transfer to direct decoding, but a causal separation between compression and reasoning requires further ablation. Furthermore, we propose OneReason-Bench, which organizes reasoning-oriented benchmark tasks into a progressive hierarchy to guide our model iteration (e.g., Perception, Derivation, Evolution, and Recommendation). For industrial deployment, we propose a Fast-Slow thinking architecture that continuously injects the knowledge of OneReason into the recommendation pipeline through the collaboration of nearline slow thinking and online fast thinking, contributing significant business gains.

In the future, we will explore: (1) more stable online incremental-learning mechanisms that continuously adapt to new general-knowledge training corpora and user-interest drift while avoiding potential degradation of instruction-following and general capabilities; (2) more customized decoding and generation strategies tailored to business constraints, achieving a better balance among throughput, latency, quality, and business value; and (3) moving beyond “thinking-then-answer” toward an agentic recommendation foundation model with planning and tool-calling abilities. We believe that, with continued progress in model compression, inference infrastructure, and hardware efficiency, recommendation foundation models will become a core component of the recommendation chain, gradually driving the evolution toward an agentic-recommender architecture.

Acknowledgement↩︎

We thanks Gaoguo Sun, Peng Zhang, Lixing Zhao, Xinyu Zhang, Xinyue Zhang, Xun Zheng, Zheng Wang for their contributions to the data collection and insightful suggestions.

12 Author List↩︎

Core Contributors Biao Yang, Boyang Ding^*, Chenglong Chu, Dunju Zang, Fei Pan, Han Li, Hao Jiang, Honghui Bao, Huanjie Wang, Jian Liang, Jiangxia Cao, Jiao Ou, Jiaxin Deng, Jinghao Zhang, Kun Gai, Lu Ren, Peiru Du, Pengfei Zheng^*, Rongzhou Zhang, Ruiming Tang, Shiyao Wang^*, Siyang Mao, Siyuan Lou, Teng Shi^*, Wei Yuan, Wenlong Xu, Xingchen Liu, Xingmei Wang, Xinqi Jin, Yan Sun, Yan Wang^*, Yifei Hu, Yingzhi He, Yufei Ye, Yuhao Wang, Yunhao Zhou, Yuqin Dai, Zhao Liu, Zhipeng Wei, Zhixin Ling, Ziming Li, Zixing Zhang^*, Ziyuan Liu.

Contributors An Zhang, Changxin Lao, Chaoyi Ma, Chengru Song, Defu Lian, Fan Yang, Guowang Zhang, Hao Peng, Jiayao Shen, Jie Chen, Jun Xu, Junmin Chen, Kun Zhang, Kuo Cai, Mingxing Wen, Minmao Wang, Minxuan Lv, Qi Zhang, Qiang Luo, Sheng Yu, Shijie Li, Shijie Yi, Shuang Yang, Shugui Liu, Shuni Chen, Tinghai Zhang, Tingting Gao, Xiang Wang, Xiangyu Wu, Xiangyu Zhao, Xiao Lv, Xiaoyou Zhou, Xuming Wang, Yong Du, Zejian Zhang, Zhaojie Liu, Zhiyang Zhang, Zhuang Zhuang, Ziqi Wang, Ziyi Zhao.

All the authors listed alphabetically by first name.^*individuals who have departed from our team.

13 Deployment Details↩︎

13.1 Industrial Scenario Adaptation↩︎

Facing a new industrial scenario, how can OneReason be rapidly adapted? This setting presents two key challenges: understanding new item corpora and learning emerging user interest distributions, both of which are absent during OneReason training. To address these challenges, we propose a reusable deployment recipe called Industrial Scenario Adaptation.

Scenario-aware Continual Pre-Train. We start from the checkpoint of the final OneReason foundation model. For item understanding in new industrial scenarios, we adapt the R0: Perception 5.1 method for bidirectional alignment between itemic tokens and captions. For user understanding in new industrial scenarios, we adopt a User-Profile-Based Continual Pre-Training strategy. A large-scale LLM is first used to summarize user behaviors and extract preference signals, which are then combined with user profiles to form user portrait texts. These user portraits texts are used for continual pre-training, enabling the model to capture scenario-specific user characteristics.

Scenario-aware Continual Supervised Fine-Tuning. We further train OneReason for recommendation by conditioning on user portrait texts and historical interactions to predict the next itemic token. To improve robustness across users with different activity levels, we introduce a curriculum learning strategy that progresses from high-activity to low-activity users. This allows the model to first learn from dense behavioral signals and gradually adapt to sparse scenarios, while user portraits provide consistent semantic guidance for generalization.

13.2 The Overall Methodology of OneReason for OneRec↩︎

As reflected in the core design philosophy of the OneReason, Thinking-then-Generation have been demonstrated to be an important pathway in the evolution of LLMs. Prior work has also shown that introducing latent reasoning mechanisms into generative models can effectively enhance reasoning capabilities and further improve recommendation performance. Therefore, we attempt to leverage the outputs of OneReason to provide reasoning supervision, and we have obtained business uplift in the online fast pipeline, validating that OneReason’s reasoning capabilities and knowledge can be transferred to generative recommendation model via distillation.

The overall framework is illustrated in the Figure 27. Specifically, we first use OneReason to predict the next itemic token with the highest probability of user interaction, and then decode it into the embedding representation corresponding to the itemic token via a quantized model, serving as a supervision signal for the reasoning process. Subsequently, we introduce a Thinking Token into the generative recommendation model and use the hidden state at the decoder-side <BOS> position as the supervision target. We then apply an Alignment Network to impose representation-level constraints, thereby distilling OneReason’s knowledge and reasoning capabilities into the generative recommendation model within a high-dimensional semantic space.

On this basis, we further explore several variant designs. For example, we introduce a User Representation Decoder to compress the encoder outputs, align them with OneReason’s outputs, and further distill them into the Thinking Token. In addition, to address the uncontrollability of the reasoning process, we design a dual-branch architecture consisting of a Decoder with Reason and a Decoder without Reason, and apply mutual supervision to improve the stability of the reasoning process. Finally, considering the inherent misalignment between the recommendation space and the semantic space, we further propose a contrastive distillation method based on spatial residuals to enhance cross-space alignment.

13.3 Experimental Analysis↩︎

We conduct a detailed analysis of the above A/B test results. We decompose the overall effects from two perspectives: (1) the changes in efficiency brought by OneReason, and (2) the advantages of OneReason across different user groups.

Distribution and Efficiency Analysis. From Table 18, we observe that OneReason brings consistent system-level improvements under different deployment paradigms. In the slow pipeline, direct application of OneReason improves conversion and click performance by enhancing traffic quality through better semantic matching. In contrast, enhancing OneRec in the fast pipeline mainly improves system scale via expanded retrieval coverage, while per-impression metrics remain relatively stable. The combined strategy achieves the best overall performance with further increased coverage, demonstrating the complementarity between the two paradigms: the slow pipeline improves traffic efficiency, while the fast pipeline expands system scale.

User Level Analysis. To evaluate the user-level impact of OneReason, we conduct a stratified analysis across high-activity, medium-activity, and low-activity users. Table 19 shows that business revenue gains increase as user activity decreases, with the largest improvements observed in low-activity users. Compared with traditional recommendation models that rely heavily on users’ historical behaviors, OneReason enables reasoning-based interest completion by integrating user profiles, limited behaviors, and content semantics, enabling effective recommendations under sparse interactions. Overall, these results validate the value of its reasoning capability for low-activity users and demonstrate substantial information gain for the overall system.

13.4 Discussions in Industrial Deployment↩︎

We analyze the key challenges encountered during the online deployment of OneReason and discuss several important issues, along with future directions.

13.4.1 D1: Online Incremental Training and General Model Performance.↩︎

OneReason requires incremental updates to adapt to evolving item corpora and user interests. Without such updates, we observe significant performance degradation. However, the current approach primarily focuses on continual learning for recommendation objectives, while partially neglecting instruction-following capabilities and general capability retention. Future work should explore more stable incremental learning strategies that preserve foundational capabilities while adapting to evolving item corpora and shifting user-interest distributions.

13.4.2 D2: Generation Strategies of OneReason.↩︎

OneReason has higher inference cost, making large-scale beam search infeasible. We therefore design a hierarchical generation strategy for item ID decoding under small-scale beam search. The model first generates candidates at the top itemic token-level to ensure coverage, and then completes lower-level structures via greedy decoding, balancing diversity, accuracy, and efficiency under latency constraints. However, the current strategy still lacks consideration of business value and resource constraints. Future work may explore more customized decoding strategies to improve recommendation quality.

13.4.3 D3: Model Parameter Size and Real-time Applications.↩︎

In fact, the “Fast-Slow Thinking” architecture is an engineering trade-off. It preserves real-time system stability while incorporating information gains from OneReason via a nearline mechanism. However, it cannot fully replace real-time retrieval nor fully exploit the model’s capacity. A key future direction is model parameter size, i.e., exploring smaller models (e.g., 0.8B level) that maintain comparable performance while enabling true real-time retrieval, further improving system efficiency and integration.

13.4.4 D4: ROI of OneReason for Online Deployment.↩︎

We first note that ROI is not the primary objective of OneReason. Our main goal is to evaluate whether the model provides meaningful information gain in recommendation systems. However, from an engineering perspective, the system consumes approximately 600 flagship GPUs per day to serve full traffic across 400 million users in the Kuaishou App. We analyze A/B test experimental results and estimate an ROI > 5, indicating that system-level gains outweigh inference costs and yield a positive return. With advances in model compression, inference infrastructure, and hardware efficiency, OneReason is expected to become a core component of future recommendation systems, driving a shift toward a foundation-centric architecture.

14 Benchmark Details↩︎

14.1 Task Construction↩︎

We provide the construction details of the four reasoning layers in OneReason-Bench here.

14.1.0.1 R0: Perception.

We use multimodal LLMs to generate reference item captions from native multimodal signals across video, live-streaming, product, and advertising domains, followed by LLM-based and human quality checks. We next construct content-grounded QA instances from the verified captions and item metadata, and further filter them by answerability, difficulty, and human spot-checking.

14.1.0.2 R1: Derivation.

We extract item-to-item association pairs from content knowledge graphs. We further apply LLM-based difficulty filtering and human quality checks to retain samples that require semantic derivation rather than surface-level matching.

14.1.0.3 R2: Evolution.

We mine interest evolution chains with temporal progression and cognitive increments from full-domain user behavior timelines spanning short video, e-commerce, advertising, live-streaming, and additional search. Rule-based, LLM-based, and human quality checks are used to filter pseudo-logical chains, and the resulting chains are converted into the three task formats above.

14.1.0.4 R3: Recommendation.

We build all-domain history sequences from real user behavior logs and use users’ subsequent high-value interacted items as prediction targets, where high-value interaction is defined domain-specifically: clicks for Product, watch-time above the 75th percentile within the same duration bucket for Video, conversion actions (e.g., activation or payment) for Ad, and first gifting events for Live. Target items are further processed with abnormal-sample filtering, popularity downsampling, and category balancing to reduce head-item dominance.

14.2 Recommendation Data Statistics and Analysis↩︎

Table 20 presents the scale statistics of R3 across the four target domains.

Beyond the scale statistics, we further characterize train-evaluation overlap from two complementary perspectives: target-level visibility and transition-level memorization/generalization. For target-level visibility, 33.69% of target item origin IDs are unseen during training, whereas only 11.55% of target itemic patterns are unseen. This suggests that many item origin ID-level cold-start targets still support content-based generalization through seen itemic patterns.

Following [78], we then examine transition-level memorization and generalization at the itemic-pattern granularity. For an evaluation instance with history \((\text{item}_1, \text{item}_2, \ldots, \text{item}_n)\) and target set \(\mathcal{T}\), each pair \((\text{item}_n, t)\) for \(t \in \mathcal{T}\) is counted as a memorized pair if the same transition appears in training, and as a generalized pair otherwise. As shown in Table 21, Video and Product are dominated by generalized transitions, whereas Ad and Live are more memorization-heavy, allowing OneReason-Bench to cover both settings.

14.3 Comparison with Existing Benchmarks↩︎

Existing benchmarks have progressively expanded the evaluation scope of recommender systems. Traditional recommendation benchmarks, including Amazon [79], Yelp [80], PixelRec [81], NineRec [82], and KuaiSAR [83], mainly focus on outcome-level evaluation such as ranking accuracy, next-item prediction, and behavior prediction. Within recommendation foundation-model evaluation, RecIF-Bench provides the immediate basis for this work by establishing a holistic instruction-following benchmark.

OneReason-Bench continues this line of work by focusing on recommendation-specific reasoning diagnosis. Instead of only evaluating the final recommendation outcome or response-level quality, it introduces explicit diagnostic tasks for item-level relation derivation and temporal user-interest evolution as complementary probes of recommendation-specific reasoning, while retaining next-items prediction as a downstream recommendation task. Table 22 summarizes this positioning.

5pt

 supported  none

14.4 Evaluation Metrics↩︎

14.4.1 Item Understanding Evaluation↩︎

For the Item Understanding task, we reuse the LLM-as-a-Judge protocol introduced in OpenOneRec. The metric definition is as follows: generated descriptions are decomposed into weighted information points and matched against the corresponding ground-truth description. Each information point carries a predefined weight reflecting its semantic importance; the final score is the OpenOneRec double-weighted F1, which penalizes both hallucinated points (false positives) and omitted points (false negatives) in proportion to their weights. Meanwhile, same with OpenOneRec, the evaluation is conducted over all examples in the Item Understanding split and the average double-weighted F1 is used to reported as the task score.

14.4.2 Action–Logic Score↩︎

The Action–Logic Score evaluates two generative tasks: Evolution Topic Generation and Evolution Direct Generation. Both require the model to produce evolution chains, each a sequence of events \(e_k = (A_k, l_k)\), where \(A_k\) is an action group, i.e., a set of user actions characterizing a phase in the user’s interest-evolution process, and \(l_k\) is the corresponding logic statement. Let the ground-truth chain be \(\mathcal{E}^* = (e^*_1, \ldots, e^*_n)\) with \(e^*_k = (A^*_k, l^*_k)\), and the generated chain be \(\hat{\mathcal{E}} = (\hat{e}_1, \ldots, \hat{e}_m)\) with \(\hat{e}_j = (\hat{A}_j, \hat{l}_j)\). The metric combines action alignment and logic alignment quality into a single composite score.

14.4.2.1 Action Alignment.

For a ground-truth event \(e^*_k\) and a generated event \(\hat{e}_j\), the pairwise action similarity is defined as: \[m_{\mathrm{F1}}(A^*_k,\, \hat{A}_j) = \frac{2\,|A^*_k \cap \hat{A}_j|}{|A^*_k| + |\hat{A}_j|}.\]

The resulting similarity matrix is aligned via maximum-weight monotone matching, equivalent to a weighted longest-common-subsequence alignment: it selects a set of one-to-one pairs \(\mathcal{M}_a\) with strictly increasing ground-truth and generated indices that maximizes total action similarity.

The chain-level action alignment score aggregates pairwise similarities with a precision–recall F1 over the generated and ground-truth chains: \[\begin{align} P_a &= \frac{\sum_{(k,j)\in\mathcal{M}_a} m_{\mathrm{F1}}(A^*_k, \hat{A}_j)}{|\hat{\mathcal{E}}|}, \\ R_a &= \frac{\sum_{(k,j)\in\mathcal{M}_a} m_{\mathrm{F1}}(A^*_k, \hat{A}_j)}{|\mathcal{E}^*|}, \\ \text{Action Alignment} &= \frac{2P_aR_a}{P_a+R_a}. \end{align}\]

14.4.2.2 Logic Evaluation.

The logic alignment score reuses the matched pairs \(\mathcal{M}_a\) from Action Alignment. For each \((k,j)\in\mathcal{M}_a\), the mixed logic similarity is: \[s_{\mathrm{logic}}(l^*_k,\hat{l}_j) = 0.5\,\mathrm{Token}_{\mathrm{F1}}(l^*_k,\hat{l}_j) + 0.5\,\mathrm{ROUGE\text{-}L}_{\mathrm{F1}}(l^*_k,\hat{l}_j).\] Here, \(\mathrm{Token}_{\mathrm{F1}}\) is the token-overlap F1 between the ground-truth and generated logic statements, and \(\mathrm{ROUGE\text{-}L}_{\mathrm{F1}}\) is the F1 variant of ROUGE-L, derived from the longest common subsequence of the two statements. Defining the total logic similarity over matched pairs as: \[T = \sum_{(k,j)\in\mathcal{M}_a} s_{\mathrm{logic}}(l^*_k,\hat{l}_j),\] precision, recall, and the chain-level score are then: \[\begin{align} P_\ell &= \frac{T}{|\hat{\mathcal{E}}|}, \\ R_\ell &= \frac{T}{|\mathcal{E}^*|}, \\ \text{Logic Alignment} &= \frac{2P_\ell R_\ell}{P_\ell+R_\ell}. \end{align}\]

14.4.2.3 Action–Logic Score Definition.

The Action–Logic Score is the primary metric for generated evolution chains, defined as the equal-weight average of the two alignment sub-scores: \[\text{Action--Logic Score} = 0.5 \times \text{Action Alignment} + 0.5 \times \text{Logic Alignment}.\]

For Evolution Topic Generation, scores are averaged across generations for each sample and then across all samples; parse failures receive zero score and remain in the denominator.

14.4.2.4 Multi-Chain Action–Logic Score.

Evolution Direct Generation requires the model to produce a set of evolution chains \(\{\hat{\mathcal{E}}\}\) without topic guidance, compared against a ground-truth set \(\{\mathcal{E}^*\}\). The evaluator first computes a chain-level action score for every ground-truth–generated chain pair and applies the Hungarian algorithm to find the maximum-weight one-to-one assignment.

Each matched chain pair is then evaluated using the single-chain procedure above. Unmatched ground-truth chains receive zero score, and the Multi-Chain Action–Logic Score is averaged over the number of ground-truth chains. Extra generated chains do not directly enter this average, but they are penalized in the auxiliary chain-level F1 metrics through the precision denominator.

14.5 Task Formats↩︎

15 Pre-Training Details↩︎

15.1 Positive–Negative Similarity Margin Study↩︎

This appendix details the positive-negative similarity margin study summarized in Section  4.2. We examine whether the proposed pre-training corpora yield item representations that better separate semantically matched (positive) from unrelated (negative) captions.

15.1.0.1 Experimental Setup.

We compare two checkpoints under a controlled protocol: the reproduced OpenOneRec serves as the baseline, while ours replaces only the pre-training corpora, holding the token budget, optimization schedule, and architecture fixed, thus isolating the effect of corpus composition. For each item, we probe two complementary representations: (i) the mean-pooled output of the first embedding layer, reflecting lexical-level priors in the learned token embeddings, and (ii) the last output of the final hidden layer, capturing the contextualized representation consumed by downstream heads. This lets us examine whether the effect of our corpora appears at the input-side, the task-relevant representation, or both. All similarities use cosine similarity in a shared representation space.

15.1.0.2 Metric Definition.

Following common practice in metric learning, we summarize representational separation through the difference between matched and mismatched similarities rather than reporting them in isolation [26], [27]. We define the positive–negative similarity margin for each anchor item \(i\) as \[\mathrm{margin}(i) \;=\; \cos\bigl(e_i^{\text{item}},\, e_i^{\text{cap}}\bigr) \;-\; \cos\!\bigl(e_i^{\text{item}},\, e_j^{\text{cap}}\bigr), \qquad j \sim \mathrm{Uniform}\!\left(\mathcal{D}_d \setminus \{i\}\right), \label{eq:margin}\tag{14}\] where \(e_i^{\text{item}}\) is the mean-pooled embedding of item \(i\) at the probed layer, \(e_i^{\text{cap}}\) is its ground-truth caption embedding, and \(e_j^{\text{cap}}\) is a caption sampled uniformly from the same domain \(\mathcal{D}_d\). The definition is applied independently to both probes, with the negative term taken in expectation over \(j\), so the reported quantity is \(\mathbb{E}_j[\mathrm{margin}(i)]\). The first term measures how tightly an item couples to its true caption, the second the residual similarity to an unrelated one. A larger \(\mathrm{margin}(i)\) indicates the model pushes the matched caption closer while keeping unrelated captions sufficiently far.

15.1.0.3 Quantitative Summary.

Table 23 reports, for each domain and both probed layers, the mean positive and negative cosine similarities and the resulting margin \(\Delta = \mathbb{E}_i[\mathrm{margin}(i)]\) under the baseline and our model. At the first-layer probe, our model widens the margin across all four domains (roughly \(1.5\text{--}2\times\)), showing that the proposed corpora inject stronger item–caption alignment at the input side. At the final-layer probe, the margins shrink for both models—as deeper representations become more contextualized—yet our model still improves clearly on Live, Product, and Ad (\(\sim\!2.4\text{--}3.4\times\)). The only exception is Video (\(0.012\) vs.\(0.011\)), where the baseline is already well aligned at depth; this is consistent with the near-identical Video results in the Cross-Domain Reco block of Table 2.

15.2 Data Mixture for Pre-Training↩︎

Section 4.2 described the construction of our pre-training corpora. In this section, we summarize the overall data mixture used throughout pre-training, where Table [tab:pt-datamix-general] and Table [tab:pt-datamix-rec] report the token ratio of each dataset. Echoing the progressive multi-granularity modality-alignment principle of Section 4.2, the mixture comprises two complementary parts: recommendation corpora, which carry the dominant modality-alignment signal, and general-domain corpora, which preserve the model’s general competencies.

Recommendation Corpora. This part comprises the four-granularity corpora—token, item, relational, and user granularity—whose construction is detailed in Section 4.2. Their datasets and token ratios are listed in Table [tab:pt-datamix-rec].

General-Domain Corpora. As described in Section 4.2, this part consists of two subsets: general-domain text data, spanning mathematical reasoning, code, general reasoning, and medical corpora together with in-house text data, and multimodal data, which further comprises image generation and image editing data, in-house image captions, and in-house interleaved image-text corpus. All the publicly available datasets are downloadable from the HuggingFace repository (see footnotes). The corresponding data mixtures are listed in Table [tab:pt-datamix-general].

2pt

2pt

15.3 Four-Granularity Pre-Training Samples↩︎

The following are representative training samples from each of the four granularities, illustrating the data formats described in Section 4.2.

16 SFT Details↩︎

16.1 SFT Data and Itemic-Token Perception↩︎

16.1.1 R0 Item-Perception Examples↩︎

R0 trains the base model to map between itemic tokens and natural-language captions, answer content-grounded questions, and recover itemic tokens from descriptions. The examples below are sanitized bilingual cases that preserve the observed task formats while replacing raw identifiers with synthetic three-token examples. They cover short-video, product, live-streaming, and advertising domains, and include both CoT and unCoT formats.

16.1.2 SFT Data Composition↩︎

16.2 Cognitive-Reasoning Data Construction↩︎

16.2.1 R1 Explicit-Relevance Judgement Prompt↩︎

The first relation-quality stage in R1 uses a locally deployed flagship model to define the boundary between explicit relevance, explicit irrelevance, and uncertainty. The prompt is applied to both TagNex-derived and after-play-search item-to-item candidates, using the available item metadata and dense captions as evidence.

16.2.2 R1 Relation-Explanation Generation Prompt↩︎

After explicit relation judgement and bridge-variable extraction, R1 generates the final relation explanation used in recommendation SFT samples. The prompt below is applied with source-item evidence and abstract bridge variables, while the destination item is used only for consistency checking.

16.2.3 R1 Training Examples↩︎

16.2.4 R2 Logic-Chain Extraction Prompt↩︎

R2 begins by extracting candidate user-interest evolution chains from chronological multi-domain behavior timelines. We use a strong LLM to identify a small number of temporally ordered chains with clear progression, while avoiding shallow topical grouping or unsupported speculation. Below we provide the main extraction prompt used in this stage. The subsequent quality-control prompt follows a highly similar style, but is used as a second-pass LLM-as-a-Judge filter to remove pseudo-logical or weakly grounded chains produced during first-pass generation.

16.2.5 R2 Training Examples↩︎

The final R2 data contains selection, topic-generation, and direct-generation task types, aligned with the R2 benchmark taxonomy. To protect privacy and avoid exposing internal identifiers, we use synthetic itemic tokens and compact timelines while preserving the original task structure.

16.3 Recommendation CoT Construction↩︎

16.3.1 R3 Recommendation Reasoning Trace Construction Prompt↩︎

R3 uses the following prompt template, implemented as build_i2i_chain_prompt_cn, to synthesize recommendation reasoning traces. The prompt implements the three-stage protocol described in Section 5.4.1: persona abstraction, interest expansion, and transition inference. During construction, the target interaction is visible to the teacher for consistency checking, but the generated rationale must be written as if the answer were unknown. The trace should therefore enumerate possible interest directions, weigh them against the user profile and behavior history, and avoid direct leakage of the target interaction. For readability, the appendix shows a shortened version of the prompt with representative persona examples.

16.3.2 Low-Score Reasoning-Trace Cases↩︎

3pt

16.3.3 Recommendation CoT Training Cases↩︎

The final recommendation CoT data uses a three-turn message format: a short system instruction, a user message containing the user profile and multi-domain behavior history, and an assistant message that first produces a reasoning trace and then emits the target itemic token. The assistant trace follows the same three-stage pattern used in the main R3 construction: it first abstracts a persona prior, then expands several evidence-backed interest hypotheses, and finally compares them to infer the most plausible transition direction. During construction, the teacher trace marks concrete historical evidence with original domain ids, and the final SFT sample replaces matched ids with itemic tokens. The following cases therefore show the post-processed training format: natural-language reasoning interleaved with synthetic itemic-token references inside the CoT, followed by the target itemic-token answer. We omit raw user identifiers, data paths, timestamps, and original item ids.

16.4 Itemic Instruction Details↩︎

16.4.1 Itemic Token Instruction-Following Cases↩︎

Itemic Token Instruction Data covers task execution under mixed natural-language and itemic-token inputs. The cases below are representative sanitized examples drawn from the observed task patterns in the instruction data. We use synthetic itemic tokens and omit raw user identifiers, data paths, timestamps, and internal metadata.

References↩︎

---

1. For brevity, we denote short video as Video, advertising as Ad, e-commerce as Product, and live-streaming as Live.↩︎