🤖 AI

Self-EvolveRec: Self-Evolving Recommender Systems with LLM-based Directional Feedback

The paper proposes Self-EvolveRec, a novel framework that overcomes the limitations of fixed search spaces and scalar metrics in traditional recommender system design by integrating a User Simulator and Model Diagnosis Tool to create a self-evolving, directional feedback loop that dynamically adapts evaluation criteria and significantly outperforms existing NAS and LLM-driven baselines.

Original authors: Sein Kim, Sangwu Park, Hongseok Kang, Wonjoong Kim, Jimin Seo, Yeonjun In, Kanghoon Yoon, Hyunsik Jeon, Chanyoung Park

Published 2026-07-10

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Sein Kim, Sangwu Park, Hongseok Kang, Wonjoong Kim, Jimin Seo, Yeonjun In, Kanghoon Yoon, Hyunsik Jeon, Chanyoung Park

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you're trying to teach a robot to be the ultimate shopping assistant. For years, the standard way to do this was like playing "Mad Libs" with a very strict rulebook. You'd give the robot a fixed list of Lego bricks (pre-defined math operators) and say, "Build the best recommendation engine using only these bricks." This is called Neural Architecture Search (NAS). The problem? The robot can only build things that fit inside the box of bricks you gave it. It can't invent a new type of brick, and it can't fix the instructions on how to use them if the instructions are wrong.

Then, a new trend arrived: LLM-driven code evolution. This was like handing the robot a blank canvas and a magic pen, telling it, "Write your own code!" The robot could now invent new bricks. But there was a catch. The robot was still being graded on a single, boring number, like a test score. If the score went down, the robot would just guess, "Maybe I should change this number?" and try again. It was a game of blindfolded darts. It didn't know why it missed the target. Was the recommendation too popular? Did it ignore the user's weird taste for vintage socks? The robot just knew the score dropped and panicked.

Enter Self-EvolveRec, a new framework that acts like a super-smart coach with two special assistants.

The Two Assistants: The Critic and The Doctor

Instead of just looking at a test score, Self-EvolveRec uses a User Simulator (let's call her "The Critic") and a Model Diagnosis Tool (let's call him "The Doctor").

The Critic is a team of virtual shoppers with distinct personalities. One might be a budget-conscious student who hates expensive electronics; another might be a trend-chaser who wants the latest gadgets. When the robot makes a recommendation, The Critic doesn't just say, "Score: 4/5." She says, "I'm bored! You gave me three gaming consoles in a row. I need variety!" or "This item is way too expensive for my budget." This gives the robot directional feedback: a clear map of what is wrong and why.

The Doctor is a mechanic who looks under the hood. While The Critic complains about the user experience, The Doctor checks the engine's internal health. He might spot something invisible to the user, like "Embedding Collapse." Imagine if all the robot's ideas for "shoes" and "sandals" got squished into the same tiny corner of its brain, making it think they are the exact same thing. The Doctor measures this mathematically and says, "Hey, your brain is getting confused; your ideas are too similar."

The Magic Loop: Co-Evolution

Here is where it gets really cool. Usually, if the robot learns a new trick (like a new way to process prices), the old Doctor might not know how to check it. He'd be like, "I don't have a tool for this new engine part!"

Self-EvolveRec solves this with Diagnosis Tool - Model Co-Evolution. As the robot evolves and learns new tricks, the Doctor evolves right along with him. If the robot invents a new "Price Encoder," the Doctor automatically invents a new "Price Check" tool to measure it. If The Critic complains about "lack of diversity," the Doctor invents a new math formula to measure diversity and verify if the robot actually fixed it. They grow together, ensuring the robot is always being checked by the right tools.

The Results: Not Just a Guess

The authors tested this on real-world data from Amazon (CDs, Electronics, Office supplies) and MovieLens. They compared Self-EvolveRec against the old "Lego brick" methods and the "blindfolded dart" code-evolution methods.

The results showed that Self-EvolveRec consistently outperformed the others. In the CDs dataset, for example, starting with a basic model, Self-EvolveRec boosted the NDCG@5 (a measure of how good the top recommendations are) to 0.3865, while the best "blindfolded" competitor only reached 0.3610. On HR@5 (Hit Ratio), Self-EvolveRec hit 0.5274, beating the competition's 0.4870.

But the real win wasn't just the numbers. When they asked independent AI judges to evaluate the quality of the code the robot wrote, Self-EvolveRec scored highest in Creativity (8.04 vs. 7.50 for the next best) and Insight (8.16 vs. 7.40). This suggests the robot wasn't just guessing; it was actually understanding the problems and inventing clever solutions, like adding "Category-Aware Hard Negatives" to stop recommending the same boring stuff over and over.

They also ran a "user satisfaction" simulation. In a test where virtual users decided whether to keep browsing or quit, Self-EvolveRec kept them engaged longer. The Depth (how many pages they looked at) reached 2.048 on the CDs dataset, compared to 1.952 for the next best method. This suggests the recommendations felt more human and less robotic.

What It's Not

It's important to note what this paper doesn't claim. The authors are careful to say that while their "User Simulator" is very good at mimicking human behavior, it is still a simulation. They explicitly state that fully validating these improvements for real-world users would require actual A/B testing with real people, which they leave for future work. They also found that if you remove the "Critic" (The User Simulator) and only use the "Doctor" (The Diagnosis Tool), the robot still improves, but not as much. The combination of both is what makes the magic work.

In short, Self-EvolveRec suggests that to build a truly great recommendation system, you can't just look at the score. You need a coach who can tell you why you failed, a mechanic who can check your internal gears, and a system where both of them learn and grow as you do. It turns the chaotic process of "guess and check" into a guided journey of discovery.

Technical Summary: Self-EvolveRec

Problem Definition

Traditional automated design of recommender systems, particularly Neural Architecture Search (NAS), is constrained by fixed search spaces defined by human priors. These methods limit innovation to pre-defined operators and often fail to jointly optimize non-architectural components such as loss functions and data processing pipelines. Furthermore, recent LLM-driven code evolution frameworks, while capable of open-ended program space exploration, rely primarily on scalar metrics (e.g., NDCG, Hit Ratio) for guidance. These scalar metrics lack diagnostic insight; they quantify performance degradation but fail to explain the root causes (e.g., popularity bias, insufficient category diversity, or embedding collapse) or provide qualitative direction for improvement. Consequently, evolution in these systems often devolves into undirected trial-and-error searches.

Methodology

The authors propose Self-EvolveRec, a novel LLM-driven code evolution framework designed to establish a directional feedback loop for automating recommender system design. The framework operates through three core mechanisms:

1. Directional Feedback Generation

Instead of relying solely on scalar scores, Self-EvolveRec integrates two complementary feedback sources to provide actionable insights:

User Simulator (SIM): An agentic system that simulates diverse user personas (characterized by traits like Activity, Conformity, and Diversity) to evaluate recommendation lists. The SIM generates qualitative natural language critiques (e.g., "I seek low-cost accessories, not expensive electronics") that explain why a recommendation fails, addressing semantic misalignments that scalar metrics miss.
Model Diagnosis Tool (DIAG): A computational probing module that performs quantitative verification of the model's internal structural properties. It detects hidden issues invisible to user perception, such as embedding collapse (via cosine similarity analysis) and ranking margin deficiencies.

2. Evolution Pipeline

The framework employs a population-based exploration strategy where an LLM agent iteratively refines the codebase through a four-phase workflow:

Multi-faceted Evaluation: The current codebase is evaluated to generate scalar scores, user feedback reports ( $R_{SIM}$ ), and diagnosis reports ( $R_{DIAG}$ ).
Feedback-Aware Planning & Retrieval: The LLM acts as a planner, formulating specific research queries based on the directional feedback to retrieve relevant academic literature (RAG). This shifts the focus from general knowledge gathering to targeted failure resolution.
Code Evolution: Guided by a structured development report derived from the feedback and retrieved literature, the LLM implements precise code-level modifications to evolve the recommendation pipeline.
Diagnosis Tool - Model Co-Evolution: As the recommendation architecture evolves (e.g., introducing new encoders or loss functions), a static diagnosis tool becomes obsolete. Self-EvolveRec introduces a co-evolution strategy where the DIAG tool itself is updated. The LLM analyzes structural shifts and user critiques to dynamically generate new metrics and probes capable of verifying the new components and translating qualitative feedback into measurable signals.

3. Efficient Variant

To address computational costs, the authors propose an efficient variant using zero-cost proxies. This approach estimates pipeline potential via a single forward-backward pass on a mini-batch, utilizing signals like effective rank and gradient norms, allowing for scalable deployment with up to a 12× speedup.

Key Contributions

Directional Feedback Loop: The integration of qualitative user simulation and quantitative model diagnosis to guide code evolution, moving beyond scalar metric optimization.
Diagnosis Tool - Model Co-Evolution: A novel strategy ensuring that evaluation criteria dynamically adapt to structural changes in the codebase, maintaining the validity of the feedback loop throughout the evolutionary process.
Open-Ended Optimization: Demonstrating that shifting from closed operator pools to open-ended program spaces, guided by directional feedback, allows for the invention of novel components beyond pre-defined design spaces.

Experimental Results

Extensive experiments were conducted on four datasets (Amazon CDs, Electronics, Office, and MovieLens) comparing Self-EvolveRec against state-of-the-art NAS baselines (AutoFIS, NASRec, etc.) and LLM-driven evolution frameworks (AlphaEvolve, DeepEvolve).

Recommendation Performance: Self-EvolveRec consistently outperformed all baselines in standard metrics (NDCG@5, HR@5) across all datasets and seed architectures (NCF, NGCF, SASRec, MoRec). Notably, it achieved peak performance in fewer iterations (8–11) compared to baselines (13–19) or failed to improve.
User Satisfaction: Evaluated using agentic simulators (Agent4Rec and PUB) with distinct persona schemes, Self-EvolveRec demonstrated superior performance in user-centric metrics (View, Satisfy, Depth), indicating that the evolved models better align with complex user needs and retention behaviors.
Codebase Quality: An LLM-as-a-Judge evaluation revealed that Self-EvolveRec produced code with higher scores in Creativity, Explicitness, Insight, and Personalization compared to baselines.
Robustness: The framework showed strong adaptability in extreme initialization scenarios, successfully evolving from random recommenders to competitive pipelines and refining complex ensemble models where scalar-only baselines failed.

Significance

The paper claims that Self-EvolveRec addresses the critical limitation of existing automated design methods: the lack of diagnostic insight in optimization. By establishing a directional feedback loop that combines qualitative user critiques with quantitative structural verification, the framework enables targeted, root-cause-driven evolution. The introduction of the Diagnosis Tool - Model Co-Evolution strategy ensures that the evaluation mechanism remains relevant as the system evolves, preventing the feedback loop from becoming obsolete. The results suggest that this approach not only improves recommendation accuracy but also enhances the technical quality and user-centricity of the generated algorithms, offering a robust path toward fully autonomous recommender system design.