GenRec: Inside Netflix’s Shift to LLM-Native Recommendation Systems

For years, the “holy grail” of recommendation systems (RecSys) was the perfect feature engineering pipeline. If you’ve worked on production-scale recommendation engines, you know the drill: you spend 80% of your time manually crafting features, normalizing tabular data, and building specialized embedding layers for every new signal—whether it’s a “thumbs up,” a search query, or the percentage of a show watched.

But at Netflix, the paradigm is shifting. The traditional approach of feeding structured tables into Wide & Deep models or Gradient Boosted Decision Trees (GBDTs) is hitting a ceiling. Enter GenRec, Netflix’s transition to an LLM-native recommendation architecture. Instead of treating recommendation as a classification problem over tabular features, GenRec treats it as a sequence modeling problem over natural language.

The core realization behind GenRec is that Large Language Models (LLMs) are already world-class reasoners about sequence and context. By moving from manual feature engineering to verbalization—the process of converting user history into a narrative context—Netflix is simplifying its stack while simultaneously improving performance. This isn’t just about adding a chatbot to the UI; it’s a fundamental rewrite of the ranking logic that powers the world’s largest streaming service.

The Death of the Feature Engineering Pipeline

Traditional recommendation systems are essentially massive bookkeeping exercises. You have a “User” table, an “Item” table, and an “Interaction” table. To make a prediction, you must manually define how to represent a user’s last ten movies. Do you average their embeddings? Do you use a Transformer-based sequence encoder? Every time a new product feature is launched—like “Netflix Games” or “Live Events”—engineers must design new schemas, retrain embedding layers, and ensure the feature distribution remains stable.

GenRec replaces this manual labor with a unified text interface. In this new world, the “feature” is a prompt. By representing user history as a string of text (e.g., “User watched ‘Stranger Things’ and ‘Wednesday’, then searched for ‘dark fantasy’…“), Netflix leverages the pre-existing semantic knowledge of a language model.

This shift moves the focus from Feature Engineering to Context Engineering. It allows the system to ingest heterogeneous signals—like a user’s search history, their preferred audio language, and the time of day—without requiring a custom architecture for each signal. The result is a system that is more flexible, easier to maintain, and significantly more accurate at capturing the “vibe” of a user’s session.

Verbalization: Turning User History into Narrative Context

The most critical component of GenRec is Verbalization. This is the process of taking raw, structured data from a data warehouse and transforming it into a high-density natural language prompt that an LLM can digest.

In a traditional system, “The Queen’s Gambit” might be represented by ID 10293 with a category vector [0.1, 0.9, 0.2]. In GenRec, it is verbalized. The model sees the title, the genre, the synopsis, and perhaps even the user’s specific interaction with it.

The Anatomy of a Verbalized Prompt

A typical GenRec prompt might look like this internally:

“The user has a history of watching high-stakes dramas. They recently finished ‘The Crown’ (Season 4) and ‘Succession’. They skipped ‘The Office’ after 2 minutes. Current time is Friday evening. Based on this history, rank the following items…”

This approach solves the “cold start” problem for items more effectively than IDs ever could. If a new movie is added to the catalog, the LLM can use its internal knowledge about the actors, director, and plot summary to place it in context before a single user has watched it.

From Tabular Signals to Unified Context

The beauty of verbalization lies in its ability to handle “messy” signals. Consider the difference between a “Watch” event and a “Search” event. In a standard RecSys, these are two different data types requiring different normalization techniques. In GenRec, they are both just text.

This unified interface is a massive win for context engineering. By treating the recommendation problem as a “dialogue” between the user’s history and the catalog, Netflix can inject nuances—like the fact that a user only watches horror movies in October—simply by adding that fact to the prompt.

The Two-Phase Training Framework

Netflix doesn’t just take a vanilla Llama or Mistral model and ask it to recommend movies. General-purpose LLMs are great at poetry, but they don’t know the specifics of the Netflix catalog or the subtle nuances of user behavior on the platform. To bridge this gap, GenRec employs a sophisticated two-phase training framework.

Phase 1: Domain Adaptation (LLM-DA)

The first step is Domain Adaptation. In this phase, a base LLM (ranging from 1B to 10B parameters) is fine-tuned on a massive corpus of Netflix-specific data. This includes movie synopses, user reviews (where available), and anonymized interaction sequences.

The goal of LLM-DA is to shift the model’s internal probability distribution toward the “Netflix domain.” By the end of this phase, the model should understand that “The Witcher” is more semantically related to “Shadow and Bone” than it is to “The Great British Baking Show.” Netflix researchers found that this domain adaptation phase alone provides a 10-20% boost in Mean Reciprocal Rank (MRR) compared to using a base open-source model.

Phase 2: Ranking and Alignment (LLM-RA)

Once the model “understands” the catalog, it needs to learn how to rank. This is the Ranking and Alignment phase. Here, the model is trained on specific recommendation tasks using two primary loss functions:

1. Cross-Entropy Loss: The standard objective for predicting the “next” item in a sequence.
2. Reward-Weighted Loss: This is where Netflix aligns the model with actual business outcomes. If a user watched a recommended movie to completion, that interaction is given a higher “reward” weight than a mere click.

One of the most staggering findings from the GenRec research is data efficiency. GenRec requires 40x fewer labeled examples in Phase 2 compared to traditional deep learning models to achieve the same (or better) performance. Because the model already has a foundational understanding of language and the Netflix domain, it doesn’t need to see millions of examples to understand that “if a user likes X, they might like Y.”

Architectural Deep Dive: The Catalog-Aware Scoring Head

One of the biggest hurdles to using LLMs in a high-traffic environment like Netflix is latency. If you use a standard LLM to generate recommendations autoregressively (generating one token at a time), it would take seconds to generate a list of 10 movies. For a UI that needs to load in milliseconds, that’s unacceptable.

To solve this, Netflix replaced the standard LLM “head” with a Catalog-Aware Scoring Head.

Moving Beyond Autoregression

Instead of asking the model to “write” the name of the next movie, GenRec uses the LLM as a sophisticated feature extractor. The process looks like this:

1. The verbalized user history is passed through the Transformer backbone.
2. Instead of decoding tokens, the system takes the pooled hidden states from the final layer.
3. These hidden states are then projected into a scoring space.
4. A dot product is calculated between the user’s hidden state and the pre-computed item embeddings for everything in the Netflix catalog.

# Conceptual representation of the Scoring Head
def get_recommendations(user_context_string, item_embeddings):
    # 1. Encode the text context into a latent vector
    # We use the last hidden state of the 'prefill' pass
    hidden_states = llm_backbone.encode(user_context_string)
    user_vector = pool_strategy(hidden_states) 
    
    # 2. Calculate scores for all items in the catalog
    # Efficient matrix multiplication vs. token generation
    scores = torch.matmul(user_vector, item_embeddings.T)
    
    # 3. Return top-K items
    return torch.topk(scores, k=10)

By using this scoring head, Netflix avoids the “token-by-token” bottleneck entirely. They are effectively using the LLM for its “understanding” capabilities while retaining the speed of a traditional vector-search architecture.

Optimization with vLLM and Prefix Caching

To further optimize this, Netflix utilizes vLLM and prefix caching. Since many users might share the same “prefix” in their prompts (e.g., the same introductory context or metadata descriptions), prefix caching allows the system to skip redundant computations. This is a similar efficiency gain to what we’ve seen in DeepSeek’s architecture, where clever compute management allows for high performance on limited hardware.

Prefill-Only Inference: Efficiency at Netflix Scale

The cost of running a 10B parameter model for every user interaction is astronomical. To make GenRec viable, Netflix engineers focused on Prefill-Only Inference.

In LLM terminology, the “prefill” phase is when the model processes the input prompt, and the “decode” phase is when it generates new tokens. Prefill is highly parallelizable and much faster than the sequential decode phase. By using the scoring head mentioned above, GenRec stays entirely within the prefill phase.

The 1B vs. 10B Trade-off

Netflix experimented with different model sizes. While a 10B model offers the highest accuracy, the 1B parameter backbone proved to be the “sweet spot” for many ranking tasks. It provides enough reasoning capability to handle verbalized context while being small enough to fit into existing GPU clusters with high throughput.

This tiered approach to model size mirrors the routing architectures used by companies like Microsoft. By routing simpler recommendation requests to a 1B model and reserving the 10B model for complex, high-value “long-tail” discovery, Netflix can balance cost and performance effectively.

“The goal wasn’t just to build the best model, but the most deployable one. Prefill-only inference turns the LLM into a high-speed encoder rather than a slow generator.”

Quantifying the Impact: MRR and Data Efficiency

The results of the GenRec implementation are a powerful validation of the LLM-native approach. In head-to-head tests against Netflix’s previous state-of-the-art (SOTA) models, GenRec delivered a +1.6% improvement in Mean Reciprocal Rank (MRR).

While 1.6% might sound small to an outsider, at Netflix’s scale, this translates to millions of additional hours of watch time and significantly higher user retention. But the real win isn’t just the accuracy—it’s the operational efficiency.

Key Empirical Wins:

• 40x Reduction in Labeled Data: As mentioned, the Phase 2 training requires a fraction of the data previously needed. This allows Netflix to iterate on new ranking strategies in days rather than months.
• Simplified Onboarding: When Netflix introduced “Live Sports,” they didn’t need to build a new embedding pipeline for sports-specific features. They simply updated the verbalization logic to include sports metadata, and the LLM-DA backbone handled the rest.
• Reduced Engineering Overhead: By moving away from manual feature engineering, the data science teams can focus on higher-level context engineering and alignment strategies rather than data cleaning and normalization.

Future Outlook: RL, GRPO, and Explainable Recommendations

GenRec is just the beginning. As Netflix continues to refine this architecture, several exciting frontiers are opening up.

Group Relative Policy Optimization (GRPO)

The next step for GenRec is moving beyond simple cross-entropy loss toward Reinforcement Learning (RL). Netflix is exploring GRPO (Group Relative Policy Optimization)—an RL-style alignment method that doesn’t require a separate critic model. This could allow the system to optimize directly for long-term user satisfaction (like “did the user stay subscribed for another month?”) rather than short-term clicks.

Explainability: The “Why” Behind the Recommendation

One of the most requested features in RecSys is explainability. Why am I seeing “The Umbrella Academy”? Because GenRec is an LLM at its core, it can be prompted to generate natural language explanations.

Imagine a “Because you watched…” row that doesn’t just list a movie title, but explains: “Since you enjoy fast-paced heist movies with a comedic twist like ‘Red Notice’, we think you’ll love ‘Lupin’ for its clever puzzles and charismatic lead.”

The Convergence of Agents and RecSys

Finally, we are seeing a convergence between recommendation systems and agentic reasoning loops. In the future, the recommendation engine might act more like a personal concierge, capable of “reasoning” through a user’s ambiguous requests (e.g., “I want something that won’t make me too sad but isn’t a mindless comedy”).

GenRec proves that LLMs are not just for chat—they are the new foundation for the most critical discovery engines on the planet. By shifting from tabular features to natural language context, Netflix has set a new standard for how we build systems that understand not just what we watch, but why we watch it.