Recommender systems have become critical infrastructure in commerce. Their role is not only to surface relevant items but also to shape how users explore, compare, and decide. Improvements in recommendation translate directly into superior business outcomes: higher engagement, more conversions, stronger loyalty, and more efficient allocation of marketing budgets.

Over the last couple of years, Deep Performance-tuned Recommenders have dominated. These systems are designed to be performant: they rely on large-scale user modelling combined with objectives such as ranking accuracy, value prediction, or policy learning. While measuring the true causal impact on performance remains challenging, these systems are today the best in class at driving key KPIs such as ROI, conversion rate, and lifetime value, performing better than any alternative, including LLMs. They are scalable, and they come with guarantees: given sufficient data, they reliably improve business metrics on average, even if they cannot explain why particular recommendations work.

At Criteo, advancing deep performance recommenders has been our focus for more than a decade — from early embedding models like MetaProd2Vec (2016), to the release of the Criteo 1TB click logs dataset, to the roll-out of our award-winning deep recommendation system DeepKNN (SBR Technology Excellence Awards 2024), and most recently to our award-winning work on Performance Alignment for RecSys (NeurIPS 2024). Alongside these technical contributions, we have also shaped the research agenda by co-organizing REVEAL (2018–2022), the first workshop on performance recommendation and its successor, CONSEQUENCES (2022–present). These milestones underscore Criteo’s leadership in advancing recommender systems that both push technical boundaries and deliver measurable business value.

In parallel, the rise of LLMs has introduced a new paradigm. With explicit reasoning, tool use, and conversational abilities, LLMs are increasingly capable of acting as agents in the recommendation loop. They can parse complex constraints, ask clarifying questions, and generate natural-language justifications for their choices. While today’s LLMs are not yet fully grounded in shopping data or performance objectives, they are quickly evolving into what we call Reco Agents — systems that do not merely predict but plan, act, and explain. This trajectory suggests that LLM-based agents are poised to become the dominant way of doing recommendation in the years ahead.

Each paradigm contributes a critical dimension: modern RecSys are Performant, while LLM-based agents are increasingly Explainable and on a path toward becoming Autonomous. What is missing is their integration into systems that offer the best of both worlds.

In this 2-part article, we will take a closer look at the technical foundations behind “The Future of Commerce Recommendation: Why Hybrid Systems Will Win.” We explore how a hybrid architecture can combine the scalability and performance guarantees of modern recommender systems with the reasoning, constraint handling, and conversational explainability of large language models. We call these systems Hybrid Reco Agents — recommendation agents that can do both: optimize simultaneously for business performance and user utility while providing transparent, intelligible explanations. In doing so, they become truly trustworthy partners in commerce.

---

PART I. From Sequence Models to Hybrid Agents

At first glance, recommender systems and large language models seem worlds apart — one predicts the next product you’ll buy, the other the next word you’ll say. Yet both share the same foundation: they are sequence models trained on massive logs of human behaviour.

Both systems rely on a simple but powerful idea: embeddings. This means that each word or product can be represented as a point in space. Items that are similar — words used in the same contexts, or products often bought together — end up close to each other. This gives us a natural way to talk about similarity and difference in language or commerce, and it is the basis of how both LLMs and RecSys learn to make predictions.

They also follow the same two building phases:

• Phase 1: Pre-training a sequence model. The model learns broad patterns from large-scale logs — predicting the next word in text, or the next product in a shopping journey.
• Phase 2: Fine-tuning for alignment. The model is then adapted to its ultimate objective. In LLMs, this means aligning with explicit relevance labels such as human preference judgments. In RecSys, this means aligning with implicit performance labels such as clicks, conversions, or purchases.

Pre-training explains why the two look so similar, while fine-tuning highlights their different goals: LLMs optimize for perceived relevance, RecSys for measurable performance. Understanding this two-phase pipeline is the key to designing hybrid agents that can do both.

---

Phase 1: Pre-training a Good Sequence Model

Before speaking about AI, let’s reason about human intelligence.

Imagine a 3-year old child and their parent walking by a toy shop. The parent says “What car would you like? Maybe you’ll get it for your…” and the child instantly yells “birthday!”.

To get that right, the child has to understand family routines, emotions, and the idea of delayed reward. This mirrors how early cognitive development builds predictive models of context, as described by Jean Piaget’s sensorimotor and preoperational stages — phases where children begin to link perception, memory, and expectation to anticipate outcomes (Piaget, 1952). In other words, human prediction reflects not surface pattern matching but deep understanding of relationships.

This analogy sets the stage for our first stage of AI models building: Pre-training. Just as humans learn to anticipate events by internalizing patterns of cause and effect, pre-training is the stage where a model learns to build a space of representation — an internal model of the world that captures not only what things are, but how they relate and what tends to happen next. Through the simple act of predicting the next step in a sequence — the next word or the next product — the model gradually learns to encode concepts, relations, and behaviours within a shared embedding space.

The Next-Item Prediction Task (LLMs and RecSys)

Both in language and in commerce, pre-training begins with the same question: “What comes next?”

• In language, the model reads a sentence such as the quick brown fox … and learns to predict the next word (jumps) (as shown in Figure 1).
• In recommendation, the model observes a user’s browsing or purchase sequence and predicts the next likely product (as shown in Figure 2).

Although their inputs differ — text tokens versus product IDs — their learning objective and underlying transformer architecture are strikingly similar.

These tasks force the model to infer context, intent, and continuity from large-scale logs: the English corpus for language, and product-interaction data for commerce. As it gets better at prediction, it starts to internalise structure — what words or products typically co-occur, and in which order.

The Resulting Representation Space and Its Qualities

From these training tasks emerges an embedding space — a geometric map where similar words or products occupy nearby regions.

• In language, “king” and “queen” end up close because the model infers their shared royal and gendered semantics.
• In recommendation, users and products are positioned according to patterns of preference and interaction.

For example, if a shopper buys running shoes and then browses a tech reseller, the model learns that wireless earbuds are likely the next purchase. Running shoes and earbuds become neighbours, revealing a shared intent — a learned commerce model of the world.

These entity embeddings are already powerful: they enable similarity comparisons (“people who bought this also bought that”) or word-analogy reasoning (king — man + woman ≈ queen). Yet pre-training goes far beyond entity-level similarities. Prediction across long sequences of entities can capture fine-grained, context-sensitive patterns that can shift abruptly with even the smallest change in input; when models reach high predictive accuracy, a single token or a small behaviour update can dramatically alter the geometry of what comes next:

• In language, changing the phrase from 3-year-old to 33-year-old switches the most probable continuation from toy cars to real cars (Figure 3).
• In commerce, completing the purchase of a Google Pixel shifts the model’s focus from recommending other smartphones to predicting complementary accessories like chargers and earbuds (Figure 4).

By predicting the next word in a sentence or the next product in a shopping journey, the model gradually learns a map of the world: a vector space where distances reflect meaning, preference, and behavior.

We see how pre-training, whether in language or recommendation, is ultimately about building a rich map of the world. In language, this map organizes words and sentences by meaning; in recommendation, it organizes users and products by behavior. Once this representation space exist and the model is able to embed any new sequence in it, it becomes possible to do much more than prediction: we can reason about similarities, find analogies, and generalize to new situations. In other words, pre-training provides the backbone knowledge — a structured space where later fine-tuning can inject either human notions of relevance (LLMs) or business notions of performance (RecSys). In both cases, the backbone is the same: a transformer trained on billions of sequences.

At Criteo, we have been developing transformer-style recommenders years before ChatGPT made them mainstream in text. Research projects such as MetaProd2Vec, Content2Vec, ContextualRNN, and CausalEmbeddings, along with our production system DeepKNN, have long captured user–product dynamics at scale. These models built the embedding spaces that powered our performance advertising platform, demonstrating that large-scale sequence modelling has been central for many years.

---

Phase 2: Fine-tuning for Alignment

Pre-training builds a representation space — a map where the model connects sentences to words, users to products and their positions capture their meaning or behavior. But this model is raw power, an engine waiting to be steered through alignment with what people actually want.

Alignment in LLMs

For Large Language Models, alignment has become a defining innovation. When OpenAI trained the original ChatGPT (Nov 2022 release), they used supervised fine-tuning on human-written demonstration conversations. Text annotators were asked to play both roles: the user and the ideal assistant. These dialogues became the supervised dataset: conversation history → assistant reply. This was the first Supervied Fine-Tuning (SFT) task ChatGPT was trained on — essentially instruction-following in dialogue format.

• Supervised Fine-Tuning (SFT): The model is trained on curated examples of inputs and “ideal” outputs (e.g., a question and a good answer). This teaches the model to follow instructions and stay on task.

This was followed by better methods of alignment, such as RLHF and DPO:

• Reinforcement Learning from Human Feedback (RLHF): Humans compare two possible outputs; a reward model is trained to prefer the better one. The base model is then fine-tuned with reinforcement learning (commonly PPO), so that it generates outputs that score higher with humans.
• Direct Preference Optimization (DPO): A more efficient method introduced in 2023 that skips the reinforcement loop and directly optimizes on preference pairs (“this answer preferred over that one”).

These steps align the model with explicit judgments of relevance: what people say they prefer when asked to compare outputs.

Alignment in RecSys

For Recommender Systems, alignment has been about extracting signal from implicit behavior at massive scale — and fine-tuning RecSys so that they drive more outcomes: clicks, sales, watch time, or long-term value. Here are some of the performance fine-tuning approaches for Recommendation:

• Supervised prediction of clicks or purchases: The most basic form of alignment, analogous to SFT, trains models to predict whether a given item will be chosen.
• Bayesian Personalized Ranking (BPR): Introduced in 2009 and adopted at Criteo in 2019, BPR optimizes from pairwise preferences such as “clicked vs. not clicked” or “purchased vs. not purchased post an ad click”. It has been a core objective in DeepKNN and remains a cornerstone of performance fine-tuning in our production recommenders.
• Reinforcement Learning from Implicit Human Feedback: Users are shown items by the current system; most impressions receive no response, but a small fraction generate positive signals such as clicks or purchases. A model is trained to assign higher scores to the items that elicited engagement over those that did not. Because the data comes from a deployed policy, training is typically off-policy, and counterfactual methods (e.g. IPS, DR) are needed to adjust for logging bias.

Across both domains, the guiding principle is the same:

1. Start from a pre-trained sequence model.

2. Fine-tune it with preference signals so that it aligns with what humans (or users) actually value.

3. Use feedback — explicit for LLMs, implicit for RecSys — to close the loop.

As you can see, many of the techniques celebrated today in the LLM world — preference optimisation, reward modelling, off-policy correction — are repurposing methods that RecSys researchers have been refining for over a decade. The similarity is no accident: both LLMs and RecSys face the same fundamental problem of turning a general-purpose sequence model into a system that reliably reflects human value.

Key Differences: Why Performance Alignment in RecSys Is Harder

While LLMs align to explicit human judgments mainly collected through editorial processes, recommender systems must align to implicit behavioral feedback emerging from live user interactions. This makes data scarcer, noisier, and more biased. Four key challenges illustrate why performance alignment in RecSys is inherently harder:

1. Vocabulary scale and churn. LLMs operate over a relatively small and stable vocabulary — tens of thousands of tokens that change little over time. Recommender systems, by contrast, deal with catalogs of hundreds of millions of products that constantly evolve as new items appear and old ones disappear. This continual churn makes it difficult to maintain a consistent embedding space and to keep models aligned with current inventory.
2. Missing feedback and exposure bias. Outcomes are only observed for the items that were actually recommended — not for the many alternatives that could have been shown. Evaluating new models therefore requires answering counterfactual questions such as “What if the system had shown Product B instead of A?” Because data comes from a deployed policy, it is Missing Not At Random (MNAR). RecSys must rely on off-policy correction techniques such as inverse propensity scoring (IPS) and doubly robust (DR) estimators to learn unbiasedly from logged interactions.
3. Sparse and implicit signals. Even when feedback is observed, its meaning is ambiguous. Most impressions receive no click — yet a non-click might indicate disinterest, poor timing, or lack of visibility. Positive signals such as clicks or purchases are rare, and the absence of action carries uncertain value. In contrast, LLM alignment methods rely mostly on explicit human judgments where every data point has a clear label.
4. Delayed feedback and long-term value. In commerce, true reward often unfolds over time: conversions, subscriptions, or loyalty effects may appear days or weeks after an exposure. This delay complicates credit assignment and makes reinforcement learning more challenging. LLM fine-tuning, by contrast, receives immediate feedback at the granularity of each output (though in more recent agentic / tool-use settings, feedback can also become sparse, implicit and delayed, closer to recommendation dynamics).

This distinction is why we typically separate the two kinds of signals in the RecSys community:

• 🗣️ Explicit feedback: human-judgment-based relevance signals (used in LLM fine-tuning).
• 🛒 Implicit feedback: human-choice signals that emerge from real behavior (clicks, purchases) when users are presented with multiple alternatives.

Put simply, classical LLM alignment is built on what people say they prefer, while RecSys alignment is built on what people actually choose. Both forms of feedback are valuable, but implicit signals are far scarcer (relative to the size of product catalogs), noisier (since non-actions are ambiguous), biased (available only on the item that the past RecSys decided to show) and often delayed (as with conversions or long-term value) but in the same time they reveal what actually people are willing to buy and at what price, making them the default signal for performance optimization. These signal-based differences make performance alignment in RecSys a fundamentally more challenging problem than relevance alignment in LLMs.

This set of challenges has led to the emergence of a specialized research field known as Counterfactual Learning from Bandit/Implicit Feedback (Swaminathan & Joachims, 2015) which investigates how to learn optimal recommendation policies from biased, incomplete, and delayed user interactions. Criteo has been a driving force in this area from its inception, pioneering off-policy evaluation (Gilotte A et al., WSDM 2018), introducing causal embeddings (Bonner & Vasile RecSys 2018), and advancing counterfactual learning for recommendation (Jeunen O et al, KDD 2020).

Building on this foundation, we have continued to push the frontier with contributions such as distributionally robust counterfactual risk minimization (Faury et al., AAAI 2020), fast offline policy optimization for large-scale recommendation (Sakhi et al., AAAI 2022), offline contextual bandits with guarantees (Sakhi et al., ICML 2023, Aouali et al., ICML 2023), and, most recently, pessimistic off-policy methods like logarithmic smoothing (Sakhi et al., NeurIPS 2024). Together, this line of work has positioned Criteo as a leader in robust and theoretically grounded off-policy learning for recommendation — bridging the gap between principled evaluation and real-world scalability.

We’ve also shaped the global research agenda through long-running workshops like REVEAL (2018–2022) and CONSEQUENCES (2022-present), advancing methods in causality, counterfactual evaluation, sequential decision-making, and long-term value modeling in recommender systems.

---

Part II. How Can We Have the Best of RecSys and LLMs?

🚫 Why Direct Fine-tuning of LLMs on RecSys Tasks is Difficult

As discussed in Phase 2, the alignment challenge in recommendation is fundamentally harder than in language. LLMs align to explicit judgments of relevance collected through supervised datasets and preference comparisons. In contrast, RecSys must align to implicit behavioral feedback that emerges only in live commerce environments, where users reveal their preferences by choosing one product over another. This makes data collection slower, noisier, and entirely dependent on large-scale user traffic. However, without taking into account user-interaction data, LLMs cannot hope to match the performance of Deep Performance RecSys, as repeatedly shown in the recent literature (Can LLMs Recommend as well as Modern RecSys?), pure or zero-shot LLM recommenders consistently underperform specialized recommender models by 15–60% in offline ranking metrics on various user feedback datasets.

Note: As mentioned before, a similar challenge is now appearing in LLM tool-use setting, where success signals are also implicit and delayed, resembling recommendation feedback rather than static supervision.

🚫 Why LLMs Are Not The Right Tool For High-Scale RecSys

In addition to this data gap, two practical scale-related barriers prevent LLMs from being directly used as large-scale recommender systems:

• Vocabulary scale and churn: Natural language models operate with a fixed vocabulary of tens of thousands of word tokens, which is relatively stable over time. By contrast, product catalogs may contain +100M items, with constant churn as new products appear and old ones are retired. No static tokenization scheme can keep pace with such dynamics, and retraining/fine-turning foundation models continuously to reflect catalog updates would be a very costly endeavour.
• Serving constraints: Even if product IDs could be injected into an LLM’s vocabulary, generating recommendations by doing real-time inference with LLMs is computationally prohibitive. Real-time recommender systems must respect strict latency budgets measured in milliseconds. This is why RecSys have evolved large embedding tables combined with approximate nearest-neighbour retrieval — architectures that LLMs, in their current form, cannot replicate efficiently at production scale.

Taken together, these barriers make clear that simply fine-tuning LLMs on RecSys objectives is not a deployable solution today for very large-scale / low-latency applications such as performance advertising. What is needed instead is a hybrid architecture: a system that combines the scalability and performance guarantees of modern RecSys with the reasoning, constraint handling, and natural-language explanations of LLMs.

Note on Semantic IDs for Recommendation: There is a promising line of research in Generative Recommender Systems that attempts to sidestep the catalog size and churn problem by introducing semantic identifiers. Instead of treating each product as a unique ID, items are represented by a sequence of descriptive tokens that can be reused across products. For example, rather than learning an embedding for every individual Nerf Gun SKU, a product might be represented by a compositional signature such as <Toy-Gun, Spring-Powered, Foam-Bullets>. This approach compresses the catalog into a manageable semantic vocabulary, making generative modelling of recommendations more feasible. While still an emerging idea, it highlights a potential long-term path for closing the gap between LLM tokenization and RecSys item representation.

The Scalable Solution: Retrieval-Augmented Generation for RecSys

Given the current structural barriers to training and deploying LLMs as standalone recommender systems, the most practical and production-ready solution today is Retrieval-Augmented Generation (RAG), introduced by Lewis et al. (2020), which layers a retrieval engine over a generative model to ground outputs in relevant external data.

In the context of commerce recommendation, this architecture (shown in Figure 9) can be viewed through an agentic lens: the LLM acts as an intelligent agent that uses the performance-based recommender as a tool. The principle is simple:

• The RecSys backbone handles large-scale retrieval, surfacing a set of high-quality candidates that are already optimized for performance metrics such as CTR, ROI, or LTV.
• The LLM layer then takes these candidates as input and does what it excels at: reasoning over the set, applying user-defined constraints, asking clarifying questions if needed, and generating natural-language explanations that make the recommendations transparent.

This separation of concerns yields the best of both worlds:

• From RecSys, we inherit scalability and freshness, with embedding tables and approximate nearest-neighbor retrieval ensuring that large and dynamic product catalogs can be handled in real time.
• From LLMs, we add adaptivity and transparency, with the ability to reason about user queries, balance trade-offs, and provide faithful explanations in natural language.

Therefore, RAG architectures act as the glue between RecSys and LLMs, allowing us to keep the performance guarantees of industrial-scale recommendation while introducing the agentic capabilities that build user trust. This design is at the core of our proposal, namely Hybrid Recommendation Agents, detailed in Figure 10 below.

The Hybrid System in Practice

The hybrid system architecture is powerful: it combines the scalability of RecSys with the reasoning abilities of LLMs in a three-stage pipeline:

• Stage 1: Understanding the user need. The LLM interprets the query (and optionally the user’s shopping history) and translates it into structured product queries.
• Stage 2: Candidate retrieval. The RecSys backbone retrieves a set of performance-optimized candidates using embedding-based search and ranking.
• Stage 3: Reasoning and explanation. The LLM reasons over the retrieved set, applies user constraints, and can ask clarifying questions. It then generates natural-language explanations that increase transparency and user trust.

This mirrors how Criteo’s production systems already work today: scalable retrieval and ranking ensure performance at scale, while lightweight LLM components add reasoning, constraint handling, and explanation.

The 3-Stage Hybrid Agent Loop

🧩 Stage 1: Understanding the user need

The LLM’s first role is to interpret the user conversation (and optionally contextual signals such as profile data or shopping history) and convert them into product-level queries for the RecSys.

This is also the first opportunity for performance optimization: by training the LLM to learn how to decompose user intent into high-quality queries, we can directly increase the performance of the entire hybrid pipeline.

• Training data. These signals can be represented as pairs of <user intent, list of queries>, where queries are labelled positive if they led to a sale and negative otherwise.
• Data collection. Such training data requires a working recommendation agent deployed in live traffic with real retailer integration — further emphasizing the importance of production-scale experimentation.

Example:

User need: A gift for a 13-year-old boy under $50.

Generated product queries:

• Best NERF guns under $50
• Best LEGO sets under $50
• Trendiest toys for boys under $50

By teaching the LLM to generate effective queries of this kind, we align its reasoning ability with the RecSys’ strength in retrieval and ranking.

🧩 Stage 2: Finding the best performing products

Once the LLM has decomposed the user intent into structured queries, the RecSys backbone takes over. It executes these queries against the product catalog, surfacing a set of candidate products already optimized for measurable objectives such as ROI, margin, and long-term customer value.

This is the modern RecSys stage: embedding-based retrieval followed by ranking, guided by performance-oriented training objectives such as click-through rate, conversion rate, or uplift. Crucially, this step illustrates the reusable core of the hybrid architecture. Decades of investment in scalable retrieval, caching, and performance optimization do not need to be reinvented for LLMs; they remain the backbone of recommendation.

Example:

Input query: Best NERF guns under $50

Retrieved results:

• Nerf N-Series Pinpoint
• Nerf N-Strike Elite Quadrant Blaster
• Nerf Zombie Strike Flipfury

These candidates are performant in the RecSys sense: they are surfaced because similar items have historically driven strong engagement and sales outcomes. The role of the LLM in the next stage will be to reason over these results, apply constraints, and explain the trade-offs back to the user.

🧩 Stage 3: Selecting and explaining the choices back to the user

In the final stage, the LLM layer reasons over the retrieved candidates, applies additional constraints, and generates natural-language explanations. This is where the system moves beyond being merely performant to becoming trustworthy: the user not only receives good recommendations but also understands why they were chosen.

Unlike modern RecSys, which return ranked lists without context, the LLM can articulate transparent trade-offs — for example, highlighting which option is compact and affordable versus which is long-range and precise. These explanations serve a dual purpose:

They increase user trust by making the decision process intelligible.

They provide engagement hooks, allowing users to refine or clarify their preferences interactively.

Example:

Input: Candidate product results from RecSys retrieval

Output: Final products with explanations

• Nerf N-Series Pinpoint: A bolt-action blaster renowned for its precision and long-range performance — features highlighted in GamesRadar+ for its accuracy in backyard battles. Priced around €17, it offers excellent value for serious players.
• Nerf N-Strike Elite Quadrant Blaster: A compact, single-fire revolver-style blaster holding 4 darts. Great for tactical gameplay or surprise attacks, and very wallet-friendly (~$12) for everyday skirmishes.
• Nerf Zombie Strike Flipfury: A fun and quirky dual-barrel “Flip” blaster from the Zombie Strike line — priced under €18. Offers a unique flipping mechanism and thematic zombie flair.

At this stage, the RecSys ensures performance grounding (the items are strong candidates from a KPI perspective), while the LLM ensures reasoning and explainability (the items are intelligibly justified to the user). Together, this closes the loop: recommendations that both work and make sense.

Taken together, these three stages define the essence of Hybrid Reco Agents. The LLM interprets the user’s intent and translates it into queries (Stage 1), the RecSys backbone retrieves performance-optimized candidates (Stage 2), and the LLM reasons over these results to select and explain the best options (Stage 3). This division of labour is not accidental: it reflects the complementary strengths of the two paradigms. The RecSys provides scalability, freshness, and KPI optimization, while the LLM provides adaptivity, constraint handling, and transparency.

This is what we call a Hybrid Reco Agent: a system that can do both — remain grounded in measurable business and user utility while reasoning in natural language and earning trust through faithful explanations. Rather than attempting to replace one paradigm with the other, the hybrid architecture shows that the path forward is convergence: building recommendation agents that are at once performant and explainable, and therefore genuinely trustworthy.

---

🏁 Conclusion

Recommender systems and large language models may appear to come from different worlds, but at their core, they share the same foundation: sequence models trained at scale. Their divergence lies not in architecture but in alignment: LLMs are tuned on explicit judgments of relevance, while RecSys are tuned on implicit signals of performance. Each excels on one axis — LLMs at reasoning and explanation, RecSys at scalability and KPI optimization — but neither is sufficient on its own.

Directly fine-tuning LLMs to act as recommender systems faces structural barriers of vocabulary scale, catalog churn, data availability, and serving constraints. The more viable and powerful approach is hybrid architectures: systems where RecSys provide the performant backbone for retrieval and ranking, and LLMs add reasoning, constraint handling, and natural-language explanation.

We have described this hybrid design as a three-stage agent loop:

1. The LLM interprets the user’s intent and translates it into queries.
2. The RecSys backbone retrieves performance-optimized candidates.
3. The LLM reasons over the candidates, applies constraints, and explains the final results back to the user.

This approach brings together the best of both worlds: scalability and performance grounding from RecSys, and adaptivity and transparency from LLMs. It is the practical path toward what we call Hybrid Reco Agents — intelligent systems that optimize for measurable business and user value while earning genuine trust.

At Criteo, we are building every stage of this loop. From performance-grounded retrieval to LLM-based reasoning and explanation, our teams are advancing the hybrid architecture behind Hybrid Reco Agents. Upcoming publications on LLM reasoning and alignment with recommendation objectives will mark the next step in our mission to make recommender systems not just performant or transparent, but truly trustworthy.