Architecting LLM-Powered Recommendation Systems (2026)

Q: Should an LLM be the recommendation engine, or part of it?

Part of it — an LLM should be a reasoning layer on top of classical retrieval, not the whole recommender. Asking a model directly "what should this user buy?" fails on three hard constraints. It cannot consider a large catalogue per request, because fitting millions of items into context is impossible and the cost would explode. It is too slow and too expensive to run on the full funnel, where every impression for every user would invoke a frontier model. And it will recommend items that do not exist in your catalogue unless explicitly constrained, because generation is not selection. The architecture that works is a hybrid: a fast, cheap candidate-generation stage using collaborative filtering, embedding similarity, and business rules narrows the catalogue to a few hundred plausible items in milliseconds, and the LLM then reranks, personalises, handles cold-start, and explains over that small candidate set, where its cost and latency are affordable and its language understanding adds value classical scores cannot. In that role the LLM is one of the most powerful upgrades a recommender can get, because it weighs stated and inferred intent, session context, and nuanced attribute trade-offs that a dot-product similarity score simply cannot represent. The guiding principle is to let cheap systems do the wide pass over the catalogue and reserve the LLM for the narrow, high-value pass over a shortlist, putting its reasoning exactly where it lifts quality without blowing latency or cost.

Q: Why does using an LLM as the entire recommender fail?

It fails on scale, latency, cost, and correctness simultaneously. On scale, a real catalogue has thousands to millions of items, and an LLM cannot hold them all in context to choose from, so it physically cannot do candidate generation over the full catalogue the way classical retrieval can. On latency, invoking an LLM for every recommendation request adds seconds where users expect milliseconds, which is unacceptable on a product surface that must render instantly. On cost, running a capable model on every impression for every user is financially ruinous at any real traffic level, often many orders of magnitude more expensive than the classical system it replaces. On correctness, an unconstrained LLM asked to recommend will sometimes generate plausible-sounding items that are not actually in your catalogue, producing recommendations a user cannot buy and that erode trust. There is also a quality trap: teams often find a pure-LLM recommender underperforms the collaborative-filtering baseline it replaced, because classical methods are very good at the wide statistical pass over behavioural data, which is not where the LLM's strength lies. The resolution is not to abandon the LLM but to position it correctly: classical retrieval handles the wide pass at scale, speed, and low cost, and the LLM handles a narrow shortlist where its reasoning, cold-start handling, and explanation genuinely add value. Used as the whole system it disappoints on every axis; used as the reranking-and-reasoning stage it shines.

Q: How does candidate generation plus LLM reranking work?

It is a staged funnel that puts each technique where it is strongest. Candidate generation is the wide pass and stays classical because it must be fast and cheap: collaborative filtering, embedding similarity, and business rules narrow the catalogue from millions of items to a few hundred plausible candidates in tens of milliseconds, the same hybrid-retrieval approach that powers modern search. The LLM then performs the narrow pass by reranking that shortlist with reasoning a similarity score cannot express — it weighs the user's stated and inferred intent, the session context such as recognising that someone who just bought a tent wants complements rather than another tent, nuanced trade-offs between item attributes, and soft constraints, producing an ordering that classical scores miss. Two requirements are non-negotiable. First, constrained selection: the LLM must only ever choose from the real candidate IDs you supplied and return those IDs, validated against the catalogue, never free-generating item names, or it will recommend products that do not exist. Second, cost control: even reranking a few hundred items per request is expensive at scale, so you cache rerankings by user-segment and context where intent is stable, route low-stakes surfaces to a smaller and cheaper model, and reserve the frontier model for high-value moments. The result is a system that is fast and cheap where it must be, over the catalogue, and smart where it pays, over the shortlist, with the LLM earning its cost precisely because it runs only on the narrowed candidate set.

Q: How do LLMs help with the cold-start problem?

Cold-start is the classic weakness of collaborative filtering and a natural strength of LLMs, which is one of the strongest reasons to add an LLM to a recommender. Collaborative filtering works by finding patterns in interaction history, so a brand-new user with no clicks or a brand-new item with no purchases gives it nothing to work with, and the system either cannot recommend or falls back to generic popularity. An LLM does not depend on interaction history; it can reason from whatever text and attributes exist. For a new item, it can read the product description, category, and attributes and place it sensibly relative to other items so it can be recommended from day zero. For a new user, it can reason over stated preferences, profile attributes, or the first few clicks of a session to infer intent and make reasonable recommendations immediately, rather than waiting for enough history to accumulate. The clean design is to let the LLM carry cold-start cases — reasoning over text and attributes when behavioural signal is absent — and then hand back to collaborative filtering as interaction signal accumulates and becomes the stronger predictor. This blends the LLM's content-and-language understanding, which is strong exactly when data is sparse, with collaborative filtering's statistical power, which is strong exactly when data is dense, so the system serves good recommendations across the whole lifecycle of a user or item rather than failing at the beginning when there is no history.

Q: How do you control the cost of an LLM in a recommender?

You control cost by being deliberate about where, when, and with which model the LLM runs, since the naive approach of invoking a frontier model on every impression is financially ruinous. The foundational move is architectural: the LLM never touches the full catalogue, only a shortlist of a few hundred candidates produced by cheap classical retrieval, which bounds the work per request. On top of that, several levers compound. Cache rerankings by user-segment and context wherever intent is stable, so repeated similar requests reuse a computed ranking rather than re-invoking the model. Route by stakes: send low-value or high-volume surfaces to a smaller, cheaper model whose quality is sufficient there, and reserve the frontier model for high-value moments such as a logged-in user on a key purchase surface, exactly the cost-quality-latency routing pattern used elsewhere in LLM systems. Limit the work the LLM does — rerank a few hundred items, not a few thousand, and generate explanations only on surfaces where they pay rather than for every item. Track cost per recommendation as a first-class guardrail metric alongside latency, so a change that improves quality but breaches the cost budget is caught before it ships. The principle is that the LLM earns its cost on the shortlist where its reasoning lifts conversion, and would bankrupt you on the catalogue, so every design decision pushes LLM invocation toward the narrow, high-value pass and away from the wide, high-volume one.

Q: How should you evaluate an LLM-powered recommender?

Evaluate on two levels, because offline metrics and online reality are different things. Offline, gate every model or prompt change against a held-out dataset using ranking metrics such as NDCG, recall at k, and mean reciprocal rank, so a change that regresses ranking quality is caught before it reaches users — this is evaluation-driven development applied to ranking, and it makes ranking quality a tracked number that gates releases rather than a hope. But offline metrics only approximate real behaviour, so online is the truth: run the LLM-reranked variant as an A/B test against the incumbent recommender and judge it on the business metrics that actually matter — click-through rate, conversion, revenue per session, and crucially long-term engagement and retention, not merely immediate clicks. The long-term lens matters because an LLM optimising for click-bait can lift click-through while quietly hurting retention, which a short-horizon metric would reward and a longer one would expose. Watch guardrail metrics throughout: latency, cost per recommendation, the rate of constrained-selection violations or empty result sets, and fairness across user and item segments. Promote the LLM variant only when it wins on the core business metric without breaching the latency, cost, and quality guardrails, and keep the incumbent system as an instant fallback so a regression can be rolled back immediately. The discipline is that no recommendation change ships on intuition or on a slick demo; it ships on a measured online win, with offline metrics as the fast pre-filter and the A/B test as the decision.

Q: What are the common anti-patterns in LLM recommendation systems?

Eight recur. Using the LLM as the whole recommender, when it cannot scan the catalogue and is slow, costly, and prone to hallucinating items — retrieve first and let the LLM rerank the shortlist. Free-generating recommendations, so the model invents products that do not exist — constrain it to select from real candidate IDs validated against the catalogue. Running a frontier model on every impression, which makes cost explode — cache by context, route cheap models for low-stakes surfaces, and reserve the frontier model for high-value moments. Ignoring cold-start by defaulting to collaborative filtering, which leaves new users and items unserved — use the LLM's text and attribute reasoning until behavioural signal accumulates. Relying on batch-only profiles, which miss in-session intent and recommend yesterday's user — feed real-time session signals into both retrieval and reranking. Fabricating explanations, where a plausible but false reason erodes trust — ground explanations in the actual signals or omit them. Shipping without an A/B test, trusting offline metrics that are not reality — prove the win online on business metrics before promoting. And optimising click-through alone, since click-bait lifts clicks while hurting retention — gate on long-term engagement and revenue, not just immediate clicks. Each anti-pattern maps to a concrete control, and together they convert an LLM recommender from an expensive experiment that underperforms the classical baseline into a hybrid system where LLM reasoning measurably lifts conversion without blowing latency or cost.

Q: How do we mature an LLM recommender from experiment to production?

Use a five-stage ladder. Stage 0 is LLM-as-everything: you ask a model to recommend directly from the catalogue, and it is slow, costly, hallucinates items, and typically underperforms the classical collaborative-filtering baseline it was meant to improve. Stage 1 is the hybrid funnel: classical candidate generation narrows the catalogue to a shortlist, and the LLM reranks only that shortlist while selecting validated catalogue IDs, so the system is fast where it must be over the catalogue and smart where it pays over the shortlist. Stage 2 is cost-controlled: rerankings are cached by context, low-stakes surfaces are routed to cheaper models, the frontier model is reserved for high-value moments, and latency and cost per recommendation are tracked as guardrails. Stage 3 is cold-start and real-time: the LLM handles new users and items by reasoning over text and attributes when collaborative filtering has no signal, live session signals feed both retrieval and reranking so in-session intent is captured, and grounded explanations are generated where they lift conversion. Stage 4 is measured and attested: offline ranking metrics gate every change, online A/B tests on business and long-term-engagement metrics decide promotion, guardrails for latency, cost, hallucination, and fairness are enforced, and the incumbent recommender remains an instant fallback. Track NDCG and recall at k offline, conversion and long-term engagement online, and cost and latency per recommendation as the headline metrics, and treat the progression from a pure-LLM experiment to a measured hybrid as the difference between a recommender that costs a fortune and underperforms and one whose LLM reasoning demonstrably lifts conversion within budget.