How much context length can sequential recommenders handle before steering degrades?
This reads the question as asking where the limits are when you steer a sequential recommender with natural language — but the corpus is honest here: it has rich material on *how* steering works, and little on the *context-length-vs-degradation* curve specifically.
This explores how far you can push a sequential recommender with steering input before it stops behaving — and the most direct match in the collection is Mender, which conditions a recommender on natural-language preferences pulled from reviews so users can redirect results at inference time without retraining Can users steer recommendations with natural language at inference?. The key insight there isn't about a token budget at all: steering works because preferences are treated as *runtime inputs* rather than baked-in training targets. That reframes your question — the bottleneck for steering isn't necessarily how long the context window is, but whether the model was built to read preferences as live instructions instead of historical patterns. Traditional recommenders fail the steering test not because they run out of room, but because they have no slot for a preference that wasn't in the training data.
Where the corpus does touch length and scale, it does so from a different angle. The P5 line of work folds all user-item history and metadata into natural-language text fed through a single encoder-decoder, which means the recommender's 'context' is literally how much interaction text you can serialize before efficiency suffers — the note frames this explicitly as trading efficiency for composability Can one text encoder unify all recommendation tasks?. So one real answer to 'how much context' is structural: the more you express recommendation as a language task, the more the cost curves of language models (long-sequence efficiency) become your recommender's cost curves.
There's a second, sneakier failure mode the collection surfaces: degradation from *thin* input rather than too much of it. ERRA shows that when a user's history is sparse, embedded methods lose signal, and the fix is retrieval augmentation plus aspect selection to keep explanations anchored to the actual user Can retrieval enhancement fix explainable recommendations for sparse users?. Read alongside Mender, this suggests steering degrades at both ends — too little user context starves it, and the interesting open question (which this corpus doesn't resolve) is whether long histories eventually drown the steering signal the same way.
For the catalog side of scale, RecLLM is worth a look: it catalogs four retrieval strategies for when the item corpus is too big to fit in any prompt — dual-encoder, direct LLM search, concept-based, and search-API lookup — each tuned to a different size and latency budget How should LLM-based recommenders retrieve from massive item corpora?. That's the corpus's honest answer to 'what happens when context can't hold everything': you stop trying to stuff it in and you retrieve instead. Rec-R1 pushes this further, showing a model can steer toward good recommendations without the catalog in context at all, learning catalog awareness indirectly through reward feedback Can LLMs recommend products without ever seeing the catalog?.
The straight answer: this collection doesn't have a paper that measures a steering-degradation-vs-context-length curve directly. What it gives you instead is the more useful reframing — steering survives on *architecture* (treating preferences as runtime inputs) and *retrieval* (not relying on context to hold everything), and it breaks down from sparse signal as readily as from overload.
Sources 5 notes
Mender conditions sequential recommenders on natural-language preferences extracted from reviews, enabling users to steer recommendations at inference without fine-tuning. This approach succeeds on preference-following tasks where traditional recommenders fail because preferences are runtime inputs, not training targets.
P5 converts user-item interactions and metadata into natural language and trains a single encoder-decoder across five recommendation task families, matching task-specific models while achieving zero-shot transfer to new items and domains. Unification trades efficiency for composability.
ERRA combines model-agnostic review retrieval with personalized aspect selection to address data sparsity that embedded methods cannot solve. Retrieval augmentation provides richer signal when user history is sparse, while aspect personalization ensures explanations match user context rather than generic defaults.
RecLLM identifies four retrieval patterns—dual-encoder, direct LLM search, concept-based, and search-API lookup—each optimized for different corpus sizes, latency budgets, and training constraints. Hybrid approaches mixing multiple strategies likely work best for real systems.
Rec-R1 experiments show that LLMs trained via RL with recommender metrics as rewards can generate effective product search queries without catalog access. The model learns query refinement indirectly through system feedback, paralleling how humans search without knowing platform inventory.