What happens when you let AI agents autonomously run research on recommender models that take days to train? This paper finds out. Auto-RecSys: Harnessing Autonomous Research Agents for Industry-Scale Recommender Systems ❓ Why aren't existing autonomous research agents enough? 💡 Prior systems assume feedback loops of minutes to hours. Industry-scale recommender models take days per training run and involve thousands of lines of configuration, so serial iteration breaks down and you need a fundamentally different design that runs many ideas in parallel across distributed servers and recovers from failure. ❓ How does it juggle parallel experiments and recover from crashes? 💡 Each idea keeps its own independent state file moving through ideating, implementing, validating, training, and analyzing. When a session restarts, it rereads a global registry and trajectory logs on shared storage, letting work resume seamlessly across servers. ❓ Does the system actually get better over time? 💡 Experiment trajectories are distilled into model-specific playbooks that record dead ends as "do not" rules. Across 31 iterations, major fixes needed per iteration dropped from 4.0 to 0.5, with 83% of iterations completing with zero fixes. ❓ How autonomous is it in practice? 💡 One session executed 970 consecutive log entries with zero human intervention, and the system even switched its own training workflow after repeated publish failures. #AIAgents# #MachineLearning#

In generative recommendation, everyone has assumed they know what makes a "good" semantic ID design. So what happens when you actually put that assumption to a large, controlled reproducibility test? 🔍 Generative recommenders turn items into discrete token sequences called semantic IDs, then generate the next item autoregressively. Designs like RQ-VAE, OPQ, and RQ-Kmeans have proliferated, but prior comparisons used different datasets and backbones, so nobody could say which design actually wins. So the authors reran 12 methods side by side under the exact same data splits and evaluation protocol, and the assumptions started falling apart. No single SID design dominates across datasets. Codebook utilization balance barely correlates with recommendation quality. Longer codes don't always help, and bigger backbones can even hurt performance. And when you measure how well an SID preserves an item's local semantic neighborhood, the winning method flips depending on whether you use Jaccard or RBO. The lesson from What Makes a Good Semantic ID for Generative Recommendation? A Reproducibility Study is that good SID design isn't about chasing one metric, it's about balancing several at once. URL: #RecSys# #Reproducibility#

What if you could leave your recommendation retriever completely untouched and just bolt on one lightweight "verifier" to significantly boost recall? A team at Meta just showed exactly that. Title: Recommendation Retrievers Need Verifiers: Universal Generative Reranking for Sequential Recommendations URL: The idea is a "drafter-verifier" pipeline: freeze the existing retrieval model (the drafter) entirely, and add a lightweight verifier that generatively scores candidate items via their identifier tokens. 🌐 Highlight 1: It scales with catalog size On the YaMBDa music recommendation dataset, gains grew larger as the catalog got bigger — at the largest scale (4.65B interactions), Recall@10 improved by up to 29.8%. 🧩 Highlight 2: Works across wildly different drafters The same training recipe worked on 4 architecturally distinct drafters: attention-based SASRec, recurrent GRU4Rec, convolutional NextItNet, and even the LLM-based MiniOneRec. 🔬 Highlight 3: The gain really comes from generative verification Injecting content embeddings directly into the drafter actually hurt standalone performance, but adding the verifier on top recovered it — proving the improvement comes from the output-side generative verification process itself, not simple feature injection. The fact that it bolts on without touching the retrieval index feels like a big deal for adopting this in large-scale production. #RecSys# #MachineLearning#

The Underpriced Truth: Agentic AI Is a Paradigm Shift Centered on Memory 1/ The market will slowly realize: Agentic AI is memory-centric, not compute-centric. The new hardware stack is: ① Memory — HBM / DRAM / NAND ② Parallel compute — GPU / ASIC ③ Coordinator — CPU CPUs stopped doing the heavy lifting a long time ago. This isn't a cycle. It's a paradigm. 🧵👇 2/ First principles Humanity's ultimate pursuit of intelligence has always been two things: Infinite memory + infinite compute. When we say someone is smart, we mean two things: "good memory" + "fast thinking." Machine intelligence is walking the exact same path. 3/ The story the market already understands: HBM LLM inference's decode stage is a textbook memory-bound workload. Every token generated → drag the entire KV cache across memory. Bandwidth too low → expensive GPUs sit idle. That's why every new GPU generation ships with more HBM bandwidth and capacity. 4/ The story the market is missing The "1M context" you keep hearing about? It is not assembled inside the GPU inference cluster. So where is it actually built? 5/ It's built on the traditional servers running the agentic system Those CPU + huge-DRAM servers are quietly doing the heaviest lifting: • loading user long-term & short-term memory • loading the agent's system spec / prompt • loading skill / tool / subagent definitions • compressing the context once it overflows 1M tokens All of this lives in DRAM, not HBM. 6/ Compare this to the previous era In the web / mobile era, we barely stored any user context at all. Only search / recsys / ads kept a small user profile — maybe 1/20, even 1/100 of the data volume an agentic system needs today. That asymmetry is the real overlooked inflection point. 7/ The supply chain is already telling this story Server CPU : DRAM ratio is climbing fast: • Web / Mobile era: 1 core : 4 GB • Agentic AI today: 1 core : 16 GB • Deep agentic future: 1 core : 64 GB and beyond 8/ And it's NOT just "4x more memory" Under agentic workloads, a single CPU serves a fraction of the users it used to. When the entire IT stack migrates to agentic: • CPU count grows several-fold to ~10x • DRAM total grows tens-fold to ~100x That's the part nobody is pricing in. 9/ The conclusion Agentic AI is a paradigm shift centered on storage + parallel compute. The software paradigm changed. The hardware paradigm changed with it. Only those who deeply understand the technology will see it: This isn't a memory cycle. It's a memory paradigm. 10/ Time horizon Given how early we still are on: • user adoption rate • depth of usage per user We are at least 5 years away from the cyclical top of this memory wave. (Zoom out far enough and everything is a cycle — but this one is nowhere near peak.) $MU $DRAM $SNDK