GenRec: Towards LLM-Native Recommendation at Netflix

Why Netflix is Rethinking Its Recommendation Stack

Recommendation is the backbone of the Netflix experience. Production models today depend on thousands of hand-crafted features spanning users, items, and interactions, with specialized architectures handling sequence modeling, feature interactions, and multi-task objectives. That stack has been refined over years to serve movies, series, games, live content, and podcasts across multiple surfaces. But the cost of that complexity shows up whenever something new needs to be added: onboarding a new content type or surface demands substantial feature engineering, architectural changes, infrastructure work, and experimentation.

Large language models offer a different path. Recent research such as PLUM, GLIDE, and OneRec-Think suggests that LLMs can represent user histories and item metadata directly as text, capture relationships in a shared semantic space, and accept steering through natural-language prompts. In practice, though, off-the-shelf LLMs fall short as recommenders: they tend to over-recommend globally popular titles, hallucinate items that are not in the catalog, ignore business constraints, and personalize poorly.

Netflix's answer is GenRec, an LLM-backed recommendation ranker that post-trains an internal foundation LLM on Netflix-specific data and objectives. The system demonstrates that an LLM-based ranker can match or outperform a mature production system while depending on far fewer labeled examples and input signals.

At a high level, GenRec:

• Verbalizes user histories, item metadata, and context as text.
• Post-trains a Netflix-adapted foundation LLM for ranking.
• Adds a catalog-aware scoring head over Netflix titles.
• Uses reward signals to align with long-term member value and business goals.
• Runs in prefill-only mode on Netflix's LLM serving stack for cost efficiency.

In a large-scale A/B test against a well-tuned production ranker, GenRec delivered statistically significant improvements in both short-term and long-term online metrics while using only a fraction of the Phase-2 labeled data and input signals. The approach reduces reliance on hand-engineered features, shifting the focus from feature engineering to context engineering.

The Ranking Problem

GenRec targets full-catalog ranking, or top-K ranking when a candidate set is provided. Given a user, their interaction history, and current context (device, surface, locale, time), the model scores each item and produces a personalized ordering that can power recommendations directly or feed downstream personalization systems.

Formally, a request — user, context, time, and history — maps to a ranking over the catalog. The optimization target is expected long-term member utility, a proxy for satisfaction and retention, not just short-term engagement.

From Foundation Model to Ranker

GenRec uses a two-phase training framework.

Phase 1 — Netflix-Adapted Foundation LLM

The process starts with an open-source LLM, adapted on proprietary Netflix corpora so it learns:

• Netflix content understanding
• Member behavior and preference patterns
• General language understanding and generation

Phase 1 runs relatively infrequently and serves as a shared, Netflix-aware backbone across applications.

Phase 2 — GenRec

The foundation model is then post-trained into a high-quality ranker:

• Focused on ranking quality and steering
• Incorporates multiple reward signals via reward-weighted losses
• Refreshed more often to reflect new content and evolving tastes
• Explicitly optimized under serving cost constraints

Conversational Training Data

Netflix members generate hundreds of billions of interaction events across surfaces: views, plays, durations, thumbs up/down, add-to-list, abandons. These logs are converted into single- or multi-turn "conversations" between a user and a recommender. Each turn includes:

• User message: verbalized context, profile, history, item metadata, and task (e.g., recommend what the user will watch or thumb next).
• Assistant message: the member's actual engagement — which titles were played, for how long, what feedback was given.

Phase-2 training teaches the LLM how assistant messages depend on user messages. This enables expressing rich recommendation signals as text, jointly supporting language-modeling and ranking objectives.

At inference time, only the verbalized context is fed in; a catalog-aware scoring head ranks items. The model does not decode assistant messages. The conversational format primarily serves training, supporting the LM objective and preserving language understanding over verbalized text.

Verbalization and Context Engineering

Traditional recommenders operate on dense features and embeddings. GenRec instead verbalizes user histories and context as natural language, encoding raw interaction signals directly in the LLM's semantic space. The model is expected to discover higher-level patterns — item relationships, evolving interests — rather than relying on manual feature engineering.

Naively verbalizing every interaction would blow past token budgets and become too expensive at Netflix scale. The context window becomes the new "feature budget," so GenRec applies context engineering:

• Retain in full: high-signal engagements (long plays, thumbs-up) with richer detail
• Omit: low-signal events (very short plays, quick hovers)
• Summarize or compress: repetitive behaviors such as binge-watching
• Elaborate selectively: important or cold-start items like new releases

Within a fixed budget, recent high-signal history is prioritized; older history is compressed or dropped. The prompt is structured to maximize shared prefixes for better prefix caching, producing a compact but information-dense prompt that preserves ranking quality without prohibitive cost.

Training Objectives

GenRec is trained with a multi-objective loss combining a ranking objective, language modeling objectives, and reward-weighted alignment.

1. Catalog-Aware Ranking

The core objective teaches the model to score items by engagement quality. Positives are labeled using high-value engagements (sufficiently long plays, strong explicit feedback), with thresholds and denoising logic. A cross-entropy loss over the catalog or candidate set assigns higher scores to positives given the verbalized context.

2. Language Modeling

A language modeling objective is retained over verbalized inputs and outputs. This preserves general language understanding, improves interpretation of natural-language histories and item metadata, and leaves room for text-generation use cases such as recommendation explanations.

3. Reward-Weighted Alignment

Raw ranking accuracy is not enough. GenRec must respect business requirements — balancing movies, series, games, live, and podcasts — and optimize for long-term member satisfaction rather than immediate clicks or plays.

Training only on raw interaction sequences risks undesirable behaviors: over-favoring binge-watching, or over-focusing on a single content type. To counter this, the ranking loss is weighted using signals from separate reward models. Each training example gets a scalar weight from two signal types:

• Long-term satisfaction proxies: estimates of how much a short-term engagement contributes to return behavior, catalog exploration, or sustained engagement.
• Behavior rebalancing: adjustments across content types and launch stages (games vs. movies, new releases vs. evergreen titles) to match business goals.

The example's ranking loss is scaled by this weight — high-value engagements are weighted up, low-value ones down. This reward-weighted approach is simpler and more cost-efficient than full reinforcement learning while providing effective alignment. RL-style methods such as GRPO have shown additional gains but remain future work due to their higher cost.

Architecture and Serving Strategy

GenRec is built on a decoder-only Transformer backbone trained with next-token-prediction objectives and augmented with a catalog-aware ranking head that only scores items present in the Netflix catalog. The scoring pipeline follows three steps:

1. Verbalization: A verbalizer V serializes user history H, context 𝜏, and relevant item metadata into a single text sequence x.
2. Pooled representation: The LLM processes x and extracts a pooled hidden state h summarizing the user's preferences and context.
3. Catalog-aware scoring: Each catalog item i has a learned embedding eᵢ. A scoring head ϕ combines h and eᵢ (via dot product or a small MLP) to produce a score sᵢ. A softmax over all scores yields a probability distribution converted into a ranking π.

The backbone, scoring head, and item embeddings are all trained jointly. For large catalogs, sampled softmax or candidate sets keep training and inference tractable, while the architecture itself guarantees that recommendations stay within catalog boundaries.

Serving runs on Netflix's internal LLM stack using vLLM, where cost is driven primarily by model size, context length, and inference mode (prefill vs. autoregressive decoding). Three strategies control expense:

• Smaller/distilled models: Training on smaller or distilled foundation models, often with larger or more targeted datasets, captures most of the quality of larger models at reduced serving cost.
• Aggressive context compaction: Context engineering minimizes token usage while preserving ranking quality.
• Prefill-only inference: Instead of token-by-token decoding over large candidate sets, the model consumes the prompt once and scores the full candidate set in a single forward pass.

Together, these choices make GenRec feasible for high-volume workloads within compute budgets.

Evaluation Results

GenRec was benchmarked against a mature production ranker tuned over several years. That baseline relies on thousands of engineered dense and embedding features plus custom architectures for interaction and sequence modeling. Evaluation covered offline metrics and a large-scale online A/B test.

Offline and Online Performance

Offline, GenRec outperformed the production ranker on ranking metrics despite far fewer input signals and labeled examples. With roughly 40× fewer Phase-2 labeled training examples, GenRec achieved about +1.6% improvement in Mean Reciprocal Rank (MRR). Additional Phase-2 data and enriched input signals pushed offline metrics further.

Online, a large A/B test on batch-compute recommendation surfaces covered ~10% of Netflix traffic over ~4 weeks. In a low-data, low-signal configuration, GenRec delivered statistically significant gains over the production baseline on both short-term and long-term online metrics.

Ablation Findings

Ablation studies revealed where GenRec's gains originate.

Data and model scaling. For both ~1B and ~10B parameter backbones, offline MRR improves as Phase-2 post-training data grows. Larger models achieve higher absolute MRR but follow a similar scaling curve.

Under a fixed training budget with backbones ranging from ~1B to ~10B parameters, larger models consistently achieved higher offline MRR than smaller ones.

Phase contributions. Using the Phase-1 Netflix-adapted foundation LLM as the base model improves offline ranking metrics by roughly 10–20% over starting from an off-the-shelf LLM. Phase-2 post-training adds another 35–50% gain when evaluated near the Phase-1 training cutoff. As Phase-1 becomes stale with new content and shifting tastes, the relative benefit of Phase-2 grows to about 80% after two weeks.

Data efficiency. Starting from a strong Phase-1 model, GenRec matches or exceeds the production ranker using 10–40× fewer Phase-2 labeled examples, depending on configuration. This matters particularly because Phase-2 refreshes far more often than Phase-1.

Context Length Optimization

Context length affects both quality and cost: longer verbalizations expose more behavior but increase training and serving expense. The optimization followed three steps:

1. Clean and compress events: Drop low-signal engagements and compress repetitive behavior into a cleaned sequence.
2. Find the "elbow point": Vary the number of historical events included and plot MRR against event count to identify where additional context yields diminishing returns.
3. Optimize verbosity: For retained events, test different levels of detail and simplified wording, measuring MRR each time.

Experiments showed context tokens could be reduced to roughly one-third of the original budget with negligible degradation in offline ranking metrics. Since serving cost scales approximately with context length, serving cost fell correspondingly.

Implications for Recommendation Systems

GenRec represents more than a direct model swap. It signals a broader shift toward LLM-native recommendation with several notable changes.

From Feature Engineering to Context Engineering

Conventional RecSys stacks depend on extensive feature sets and heavy feature infrastructure. LLM-centric systems instead construct rich textual contexts from raw logs, metadata, and tools, making the prompt effectively the new feature vector. Modeling effort moves from designing features to deciding which signals to include, how far back in time to look, and how to compress history within a token budget.

From Custom Architectures to Foundation Backbones

Recommendation tasks historically required bespoke architectures such as two-tower models, DLRM-style networks, and specialized attention blocks. In an LLM-centric approach, multiple tasks share a common foundation backbone, with differentiation coming from data and verbalization strategies, post-training objectives, and inference optimization. GenRec reuses the same backbone as Netflix's foundation LLM rather than building a new architecture from scratch, which simplifies sharing learnings across applications and opens possibilities for natural-language steering.

Scaling Laws as Design Guides

Traditional RecSys can hit diminishing returns from sparse IDs, heavy engineering objectives, and task-specific architectures. An LLM-backed backbone gives recommendation systems clearer data and model scaling behavior: within cost limits, more data and larger models consistently improve quality. This aligns RecSys design more closely with the broader LLM paradigm.

Infrastructure Convergence

LLM-backed recommenders push toward GPU-accelerated, vLLM/Triton-based infrastructure with careful batching and caching. Over time, recommendation serving infrastructure converges with general LLM infrastructure rather than classic RecSys stacks built on MLPs or factorization models.

Conclusion

GenRec adapts an internal foundation LLM for large-scale personalization at Netflix. By verbalizing user histories, context, and item metadata; adding a catalog-aware ranking head; using reward-weighted objectives aligned with long-term satisfaction; and serving efficiently on LLM infrastructure, it improves on a strong production ranker while using far fewer Phase-2 labels and input signals. The results indicate that, given attention to cost, infrastructure, and alignment, LLM-backed recommenders can take a central role in large-scale personalization.