RecLoop: Closed-Loop Recommender Simulation

• RecLoop is a closed-loop simulation framework that models the co-evolution of recommender systems and LLM-powered user feedback over repeated interaction cycles.
• It compares traditional sequential recommenders with generative ones by evaluating both exposure-level metrics and internal code-space dynamics.
• Empirical studies on Amazon review datasets reveal that while generative methods may reduce exposure narrowing, they also exhibit a new form of internal cocooning.

Searching arXiv for the RecLoop paper and closely related recommendation-feedback-loop work. RecLoop is a closed-loop simulation framework for analyzing how recommender systems and user feedback co-evolve over repeated interaction cycles, with a specific focus on whether generative recommenders deepen information cocoons (Yang et al., 16 Jun 2026). In the framework, recommendation is not treated as a one-shot offline prediction problem: a recommender produces exposure lists, LLM-powered user agents select from those lists, the resulting interactions are appended to user histories, and the recommender is retrained on the updated data. This repeated feedback protocol is used to compare traditional sequential recommenders and generative recommenders under identical long-term conditions, and to measure both conventional exposure-level concentration and a model-internal phenomenon termed Code-Space Structural Cocoon (Yang et al., 16 Jun 2026).

1. Problem setting and conceptual scope

RecLoop is designed around the claim that static offline evaluation cannot capture feedback-loop effects in recommender systems, because recommendations affect what users click and those interactions then retrain the model (Yang et al., 16 Jun 2026). Its central research question is whether generative recommenders, which replace atomic item IDs with Semantic ID sequences, alter the dynamics of information cocoon formation relative to traditional sequential recommenders (Yang et al., 16 Jun 2026).

The framework studies two recommendation paradigms. The first is the traditional sequential paradigm, represented by SASRec and Mamba4Rec, which use atomic item IDs and embedding-based next-item scoring. The second is the generative paradigm, represented by TIGER and OneRec, in which recommendation proceeds through generated discrete code sequences rather than direct scoring over atomic IDs (Yang et al., 16 Jun 2026). This distinction matters because the paper argues that cocooning in generative systems may emerge not only in exposed items, but also inside the generated code space itself (Yang et al., 16 Jun 2026).

A key conceptual contribution is therefore the shift from observing only visible recommendation lists to also analyzing internal representational concentration. This suggests that recommender feedback loops should be treated as dynamics over both user exposure and model-internal generation structure, rather than as a purely ranking-level phenomenon (Yang et al., 16 Jun 2026).

2. Closed-loop simulation dynamics

For each user $u$, the simulation begins from an initial history $\mathcal{S}_u^0$. At cycle $t$, the recommender $f_\theta^t$ consumes the accumulated history and outputs a top-$K$ exposure list,

$\mathcal{E}_u^t = f_\theta^t(\mathcal{S}_u^t).$

A user agent then selects one item $i_u^t$, after which the interaction history is updated as

$$\mathcal{S}_u^{t+1} = \mathcal{S}_u^t \oplus i_u^t.$$

After all users respond in a cycle, the recommender is retrained on the updated data, and the procedure repeats for 15 feedback cycles (Yang et al., 16 Jun 2026).

This formulation makes cocoon formation an emergent property of repeated recommendation-training coupling rather than a static property of a trained model. The protocol uses a top-$K=5$ exposure list at each cycle, deterministic user feedback with temperature $=0$, and retraining after every cycle (Yang et al., 16 Jun 2026).

The closed-loop design is intended to emulate the endogenous reinforcement process often absent from offline benchmarks. A plausible implication is that RecLoop functions as a controlled testbed for separating short-term recommendation quality from long-term distributional effects, although the paper frames this point through the repeated recommendation-selection-retraining protocol rather than as a general formal theory (Yang et al., 16 Jun 2026).

3. LLM-powered user simulators

Each simulated user is represented by an LLM agent with four components: a dynamic user profile, dual memory, periodic reflection, and an action or decision module (Yang et al., 16 Jun 2026). The base profile $\mathcal{S}_u^0$0 is constructed offline from the user’s pre-simulation history by prompting an LLM to write a first-person consumer persona. The stage-wise profile is initialized by

$\mathcal{S}_u^0$1

and is refreshed every $\mathcal{S}_u^0$2 cycles through reflection (Yang et al., 16 Jun 2026).

The memory system is split into short-term and long-term components. Short-term memory $\mathcal{S}_u^0$3 is a sliding window over the most recent $\mathcal{S}_u^0$4 cycles, while long-term memory is the full interaction history $\mathcal{S}_u^0$5. In the reported experiments, $\mathcal{S}_u^0$6 and the reflection interval is $\mathcal{S}_u^0$7 (Yang et al., 16 Jun 2026). Reflection summarizes the accumulated interaction history into an updated profile and is intended to capture evolving interests without overreacting to an isolated action (Yang et al., 16 Jun 2026).

The action module receives a structured prompt consisting of the stage-wise profile, recent memory, the current exposure list, and a constraint layer listing the exact valid item IDs. Its structured output is

$\mathcal{S}_u^0$8

where $\mathcal{S}_u^0$9 is the selected item and $t$0 is the reason (Yang et al., 16 Jun 2026). The constraint layer is specifically used to ensure that the LLM chooses only from exposed candidates and does not hallucinate item IDs (Yang et al., 16 Jun 2026).

In the simulation protocol, the user simulator is Qwen3-8B (Yang et al., 16 Jun 2026). This places RecLoop in the class of agent-based evaluation frameworks, but here the agent architecture is tightly coupled to recommendation feedback and retraining dynamics rather than being used only for standalone behavioral emulation.

4. Experimental configuration

The experiments use two Amazon review datasets with hierarchical categories and 5-core preprocessing under chronological ordering of user histories (Yang et al., 16 Jun 2026).

Dataset	Users / Items / Interactions	Additional details
Office Products	4,905 / 2,420 / 53,258	Avg. length: 10.86; Categories: $t$1
Toys and Games	19,412 / 11,924 / 167,597	Avg. length: 8.63; Categories: $t$2

Four recommender models are evaluated under a common simulation protocol. The traditional sequential baselines are SASRec and Mamba4Rec. The generative recommenders are TIGER and OneRec, with OneRec evaluated at scales 0.5B, 1.5B, and 3B. For comparability, the implementation uses the MiniOneRec codebase with supervised fine-tuning only (Yang et al., 16 Jun 2026).

For generative recommenders, the study compares two tokenization strategies. Semantic IDs (SID) are obtained by training RQ-VAE on text embeddings from titles and descriptions, whereas Collaborative IDs (CID) are obtained by training RQ-VAE on SASRec item embeddings. The architecture, code depth, codebook size, and hyperparameters are held fixed; only the input representation differs (Yang et al., 16 Jun 2026).

The simulation uses 15 cycles, top-$t$3 exposures, user history initialization capped at length 50, short-term memory window $t$4, reflection interval $t$5, and NVIDIA A800 80GB hardware (Yang et al., 16 Jun 2026). These design choices ensure that paradigm differences are studied under a common feedback regime.

5. Metrics and the Code-Space Structural Cocoon

RecLoop evaluates cocoon formation with four standard exposure-level metrics and one new code-space metric family (Yang et al., 16 Jun 2026). The exposure-level metrics are intra-user diversity, inter-user homogenization, system-level coverage, and exposure concentration.

Intra-user diversity is measured by category entropy. For user $t$6, cycle $t$7, and category level $t$8,

$t$9

where $f_\theta^t$0 is the fraction of items in user $f_\theta^t$1’s exposure list belonging to category $f_\theta^t$2. Lower entropy indicates narrower exposure (Yang et al., 16 Jun 2026).

Inter-user homogenization is measured by average pairwise Jaccard similarity,

$f_\theta^t$3

with higher values indicating that users receive more similar recommendation lists (Yang et al., 16 Jun 2026).

System-level exploration is measured through item coverage,

$f_\theta^t$4

and category coverage,

$f_\theta^t$5

Exposure concentration is measured by a collective Gini coefficient. With item exposure counts

$f_\theta^t$6

the paper defines

$f_\theta^t$7

where $f_\theta^t$8 is the mean exposure count. Higher Gini implies stronger head-item concentration (Yang et al., 16 Jun 2026).

The paper’s main methodological novelty is Code-Space Structural Cocoon, introduced for generative recommenders whose outputs are mediated by multi-layer discrete code sequences (Yang et al., 16 Jun 2026). Layer-wise code entropy is defined as

$f_\theta^t$9

with normalized form

$K$0

Top-$K$1 code concentration is

$K$2

and relative entropy reduction across the simulation is summarized by

$K$3

These metrics quantify structural narrowing in the code hierarchy, particularly whether a few coarse routing codes come to dominate generation (Yang et al., 16 Jun 2026).

6. Empirical results

The principal empirical conclusion is that all evaluated recommenders exhibit cocooning under closed-loop feedback, but generative recommenders are generally less prone to exposure-level cocoon formation than traditional sequential baselines (Yang et al., 16 Jun 2026). The paper reports that generative models slow category-level entropy loss, preserve broader coverage, and reduce cross-user homogenization, while still showing rising Gini coefficients that indicate increasing head-item concentration (Yang et al., 16 Jun 2026).

On Office Products, the final Jaccard similarities are reported as 0.223 for SASRec, 0.138 for Mamba4Rec, 0.108 for TIGER, and 0.064 for OneRec (Yang et al., 16 Jun 2026). The steepest early entropy drops are observed for SASRec and Mamba4Rec, whereas TIGER and OneRec decline more slowly and irregularly (Yang et al., 16 Jun 2026). On Toys and Games, the paper states that generative models are less monotonic, but generally still lower than traditional models in homogenization-related behavior (Yang et al., 16 Jun 2026).

The code-space analysis reveals what the paper calls a structural cocoon. The concentration emerges primarily in coarse code layers, while fine layers remain relatively diverse (Yang et al., 16 Jun 2026). On Office Products, TIGER shows entropy reduction of 53.6% at Layer 0, 40.4% at Layer 1, and 13.4% at Layer 2. OneRec shows 18.4%, 18.9%, and 13.4% at the corresponding layers (Yang et al., 16 Jun 2026). For TIGER, first-token entropy drops from 0.895 to 0.451, while top-10 coarse-code concentration rises from 27.0% to 86.6% (Yang et al., 16 Jun 2026). The paper interprets the first generated codes as routing decisions, after which later codes can still vary locally (Yang et al., 16 Jun 2026).

Tokenization strategy strongly affects these dynamics. The paper reports that on Office Products, CID amplifies code-space collapse, especially for TIGER, and more strongly reduces the number of unique fine-layer prefixes than SID (Yang et al., 16 Jun 2026). OneRec is reported as more robust, with SID and CID closer to one another (Yang et al., 16 Jun 2026). On Toys and Games, some effects reverse, so SID is not always safer and CID is not always more cocoon-prone (Yang et al., 16 Jun 2026). The paper associates CID with imported popularity and co-occurrence bias, while also noting dataset-, taxonomy-, and architecture-dependence (Yang et al., 16 Jun 2026).

Model scale further moderates structural cocooning. On Toys and Games at Cycle 15, OneRec-3B achieves layer-wise entropies $K$4, compared with $K$5 for 1.5B and $K$6 for 0.5B (Yang et al., 16 Jun 2026). Active code counts at Cycle 15 are $K$7 for 3B and $K$8 for 0.5B (Yang et al., 16 Jun 2026). This indicates that larger models keep more of the 256-code vocabulary reachable, especially in fine layers (Yang et al., 16 Jun 2026).

7. Significance, interpretation, and terminological boundaries

RecLoop’s main significance lies in reframing the study of recommender feedback loops as a joint problem of exposure dynamics and representational dynamics (Yang et al., 16 Jun 2026). The framework concludes that generative recommenders do not eliminate information cocoons, but they do appear to reduce exposure-level cocoon symptoms relative to traditional sequential recommenders, while simultaneously introducing a new internal form of concentration in code space (Yang et al., 16 Jun 2026). This implies that item-level evaluation alone is insufficient for generative recommendation.

The paper therefore argues that cocoon analysis should simultaneously consider visible exposure narrowing, cross-user homogenization, catalog concentration, and internal code-space collapse (Yang et al., 16 Jun 2026). A plausible implication is that future recommender auditing may need to inspect discrete generation pathways and tokenization schemes alongside conventional ranking metrics. The paper also identifies tokenization strategy and model capacity as major control variables in these long-term dynamics (Yang et al., 16 Jun 2026).

The term “RecLoop” is specific in this context. Other papers in unrelated domains describe loop-based or recursive mechanisms, but do not use “RecLoop” as the formal system name. For example, “Relayed-Loop Optically Amplified Deflection” is named ReLOAD rather than RecLoop (Jayakumar et al., 22 Sep 2025), and “SemanticLoop” is an object-based loop-closure method rather than a framework named RecLoop (Yu et al., 2022). This suggests that, in current arXiv usage, “RecLoop” most directly denotes the closed-loop simulation framework for studying information cocoons in generative recommendation (Yang et al., 16 Jun 2026).