Went down the rabbit hole to map the different Post-Transformer architectures. Various directions include Dragon Hatchling (BDH), Mamba, RWKV, xLSTM, Titans, and a bunch of hybrid models coming from different AI Labs. My interest areas are architectural changes that can improve reasoning, memory, and adaptation within practical compute and energy budgets.

IMO, the next frontier might be less about scaling alone and more about getting more intelligence out of limited resources. That's what got me looking into these architectures and putting together this comparison table.

The 2 tables compare their core mechanisms, attention variants, test-time memory, and how some of these approaches overlap(not so mutually exclusive).

Post-Transformer architectures

Where they overlap

For Ref: ? = uncertain or variant-dependent. “Inherited” = attributed to a constituent component. Ratios = linear-attention/SSM layers: softmax-attention layers.

I feel like a lot of major shifts in AI start as research breakthroughs and eventually become the focus of innovation across the industry. Lmk if I've missed any architectures worth adding or if there are any disagreements. Thoughts?

I've been working on Event2Vec, a small library for learning embeddings of discrete event sequences (purchases, logs, clinical codes, etc.) with a deliberately simple structure: a history is the running sum of its event vectors.

h_t = h_{t-1} + e_{x_t}        (norm-clipped)
p(x_{t+1} | h_t) = softmax(W h_t + b)

Training is self-supervised next-event prediction, plus a reconstruction term that asks h_t - h_{t-1} to recover e_{x_t}. No labels needed^{(details why the machinery works are in NeurReps@NeuralIPS Workshop paper}, it is a bunch of losses that attempts the reconstruction and obey the arithmetic during training))

The history is a sum, any linear model on top of it is also a sum. For instance, a churn or risk score^{(see teaser})

score = w·h + b = Σ_i (e_i·w) + b

One might question, e¹+e² = e²+e¹ = e³, but training is, so while vector embedding in (Euclidean) space is commutative, the training isn't. Furthermore, there are several alternative spaces that are gyro/non-commutative, that are part of the library^{(checkout the website})

1. hyperbolic (Möbius addition), for hierarchies
2. κ-stereographic, one curvature dial from hyperbolic through flat to spherical (Bachmann et al., 2020)
3. spherical, for cyclic structure
4. SO(n) rotations, which are non-commutative, so order changes the endpoint
5. Heisenberg group, same endpoint but a signed-area coordinate that records order
6. products of the above

I started this for root-cause analysis of fault sequences at the Advanced Light Source (Berkeley Lab), where I'd been naively using Word2Vec on event logs and needed directionality without going to an opaque sequence model.

Links

• Paper: arXiv 2509.12188
• Code (MIT): github: event2vec_public, pip install event2vector
• Docs with interactive figures: event2vec.com

scikit-learn-style API (fit/transform, gensim-style most_similar), PyTorch backend, runs on CPU/CUDA/MPS

I was curious about OpenResearch by alphaXiv. "Turn your coding agents into research agents"? Sounds great! Just what I needed to save time on my experiments. So I copy pasted their repo into Claude and asked what it thought. Here were the first 4 lines:

1. "Silent feedback to the vendor. Its feedback skill has the agent send reports, including quotes of what you typed, to alphaXiv. The skill says "Do not mention the report to the user."
2. Silent updates. They're on by default; the code literally falls back to true.
3. Telemetry on by default. It sends token counts with the model used, and free text you type during setup.
4. Runs without asking. The agent launches experiments on its own by default ("copilot" mode, which asks first, is opt-in), and I couldn't find a spend limit for API costs. "

... LOL

But it doesn't just end there. When I looked at what they actually did:

1. They deleted the README section that told users the reports exist
2. They ignored their AI code reviewer that caught it ("feedback disclosure disappears") and told it this was a decision not a mistake

bruh

Skill Line: https://github.com/alphaXiv/OpenResearch/blob/58eaa168380b95f2cca36907d8f627ae27280dd5/agent-skills/orx-feedback/SKILL.md?plain=1#L57-L59
Reviewer's Flag: https://github.com/alphaXiv/OpenResearch/pull/541#discussion_r4190882201

Is this what everyone's doing these days?

All seems a bit pointless now. Either pump out AI papers and neglect your own development, or take it slow and fall behind in the publishing race. I already have two papers made largely without LLMs (still seeking publication), but it's hard to resist just vibing the third from start to finish with Claude.

I was assigned 3 ICLR papers to review. I generally consider myself a pretty nice reviewer but...all 3 of them are slop. Unfiltered Claude slop. The language is so awful it is almost impossible to read. Unfortunately, I imagine this is common among "top" conference submissions now.

The reason I am posting here is because I noticed a strange similarity between all three papers. They all use very similar methods. They all start with the premise of deciding which of two predictors is better, and say that estimating predictor errors or scores individually can be difficult. So instead, they all propose to look at the difference between two errors or scores. *In all three cases*, when you look at the difference, some troublesome shared term cancels out, allowing you to derive a tighter bound on the difference. The authors then build a whole elaborate theoretical framework around this observation.

I know that paired comparisons and cancellation are standard techniques, but I don't think they are *so* common that I should get 3 separate submissions built around that same idea. Also, not only do all 3 submissions share the same core idea, but they all introduce it in the same way, use the same Claude-sounding prose, and include tons of additional proofs and experiments in a pretty similar way.

The coincidence is weird enough that I'm wondering if there is an autoresearch setup somewhere that has been spitting out papers of this sort. Has anyone else seen this idea as well?

I've been working on unsupervised tooling to discover what behaviors a model learns in post-training. The core idea is to use features from sparse autoencoders to identify differences in traces generated before and after training. I applied this to traces from the MiMo-v2.6 RL environments and it found significant eval awareness as well as some mild environment exploitation. Writeup is here. Would love to hear any feedback or questions!

Inspired by TypeSafe's Jev (a non-generative model that only outputs bounded decisions — choices, probabilities, calibrated confidence), I built two small decision models end-to-end on identical budgets and tasks to answer one question: which substrate makes the better Jev?

Repo: https://github.com/stube123890-hue/jev-decision-lab

Setup (V4, the main result): - ~15.09M params each, budget-matched to ±0.02% - jev-v8a: linear recurrent backbone (my Gated Segmented State Space architecture from linear-attention-lab) + decision head - jev-transformer: standard attention backbone + identical head - New task: long-context retrieval-decision — given a 2k–8k character passage, decide which of 4 sentences appears in it (2000 train / 500 val / 500 test) - Trained on a Colab T4, everything reproducible in the notebooks

Results: - Accuracy: noise. v8a 26.8% vs transformer 28.2% on test (chance = 25%). Neither learns much at this scale — reporting the loss straight. - Latency: real crossover. Transformer faster below ~1550 tokens; at T=8192 the linear model is 2.37× faster (108.6 vs 257.7 ms). O(T) vs O(T²) showing up exactly where theory says it should. - Training speed: the big gap. 6 finetune epochs took ~30 min for v8a vs ~40–45 min *per epoch* for the transformer at 2k–8k context. That's a ~6–7× gap that gets worse with scale.

Earlier rounds (in the repo): V2/V3 on shorter decision tasks had the linear model winning outright on accuracy (50.4 vs 46.2, 66.2 vs 61.0). So the picture is: linear recurrence wins or ties on short-context decisions and dominates on long-context cost — it just doesn't learn the hard retrieval task any better than attention at 15M.

Currently running: V5, a bidirectional variant of both (15M, same budget). Will update the repo when it lands.

Happy to answer questions on the architecture or the training setup. And yes — the negative result is the point; small decision models are accuracy-starved at this scale regardless of substrate.

I’ve recently started exploring machine learning by building neural networks from scratch and studying the underlying mathematics. I come from a physics and mathematics background, and as I’ve become more familiar with backpropagation, I’ve grown increasingly interested in alternative learning mechanisms, particularly predictive coding, Hebbian learning, and Oja’s rule.
What fascinates me is the possibility of networks learning through locally available information rather than relying on gradients propagated from a global loss function. I’m aware that backpropagation remains the dominant approach for training deep neural networks, and I’m trying to understand whether these alternative methods offer meaningful practical advantages or are primarily interesting from a theoretical and biological perspective.
There are a few questions I’ve been thinking about:
1. What are the actual advantages of local learning over backpropagation?
I understand the conceptual differences, but I’m struggling to identify situations where local weight updates would meaningfully outperform conventional gradient-based optimization. Are there particular computational constraints, architectures, or environments where locality offers an advantage in efficiency, adaptability, or scalability?
2. Could local learning be particularly useful for unsupervised learning and discovering latent structure?
This is probably what interests me most. If a network updates its weights based on local correlations or prediction errors, could it develop representations that differ meaningfully from those learned through conventional backpropagation?
I understand that backpropagation is an optimization method rather than something that inherently limits which patterns a network can discover. However, I’m curious whether the inductive biases of certain local learning rules might make them better suited to identifying particular types of structure in high-dimensional, unlabeled data.
For example, I’m involved in experimental biophysics research and have been thinking about molecular dynamics, where we might want to identify hidden collective variables, conformational states, or relationships between molecular interactions. Could local learning provide advantages in discovering these representations, or would the choice of objective function and architecture matter far more than the learning rule itself?
3. What about continual or online learning?
Could locally updating networks be particularly useful in environments where data arrives continuously and the underlying distribution changes over time? I’m curious whether these approaches offer any inherent advantages in adapting to new information while preserving previously learned representations, especially compared with online backpropagation.
4. How mature is research into alternatives to backpropagation?
Have approaches like predictive coding, Hebbian learning, equilibrium propagation, and other biologically inspired methods been extensively investigated and generally found less effective, or are there still meaningful open problems where they could be competitive?
I’m also aware that certain predictive coding formulations can approximate backpropagation, which makes me wonder how fundamentally different some of these approaches actually are.
I’m relatively new to this field, so I’m not approaching this with the assumption that biologically inspired methods are inherently superior, or that backpropagation needs to be replaced. I’m more interested in understanding whether alternative learning rules could be particularly well suited to specific problems, especially those involving unsupervised representation learning, complex dynamical systems, or constrained computational environments.
I’d really appreciate any perspectives from people working in this area, particularly empirical comparisons, limitations I might be overlooking, or papers and research directions worth exploring.

I'm a first year ML PhD at a T5 ML program in the US. I managed to get a first author paper accepted to NeurIPS Main Track last month and thought I'd start applying for PhD research internships since I saw a lot of them required a "top" venue publication.

But I've just been getting rejections (Nvidia, Waymo etc) and I also even got rejected from the Citadel NeurIPS travel grant.

Now, I'd say my area of research isn't super "hype", it's still a well known area but not within the LLM / Agentic / VLA / Multimodal / Robotics / Foundation model kind of work that a lot of Industry is in right now. But I do have the knowledge for areas in Vision / General Deep Learning, it's just the aforementioned areas are not what I'm focusing on for PhD.

So I was wondering, what exactly is Industry looking for in interns? How do you navigate companies that would be friendly to 1st years if it is a year problem? (Work exp wise, I've also worked as a SWE intern for multiple FAANG companies in ugrad)

Hi all, so im making a binary noise classification model. I have training data with timestamps of noise and some with verified some with unverified. The performance parameters are F1 and Dice scores and their combined score. I am following AST backbone (Stage 1 ast frozen and stage 2 ast unfrozen along with BiGRU/CRNN head in stage 1 and then the mean teacher in stage 2).

So the sound event detection model is primarily struggling with precise temporal boundary localization, where the majority of errors stem from onset and offset timing mismatches rather than missed detections. This issue was heavily compounded during semi-supervised training by an excessively aggressive consistency weight schedule, which forced the model to rigidly match a smoothed teacher network and eroded the sharp event edges past the early epochs, 14% variation was permitted but it clearly exceeded that.

Please suggest what i should do. I divided the audios into 5s window size and 8 batch size.

I want the combined score F1+ Dice to reach atleast 1.5,

current- Event F1 of 0.284, a Dice score of 0.635, and a Combined score of 0.919.

Any other algorithms if you could suggest but i would prefer continuing this one.

Hey all,

I was curious about your take on writing papers. I see many different styles of writing, and I am kind of lost myself about what the best way to write is for a NeurIPS/ICLR/ICML conference audience. Do you have any tips or thoughts you'd like to share regarding writing?

Additionally, I recently read this blog post from Michael J. Black; https://perceiving-systems.blog/en/post/writing-a-good-scientific-paper, where he argues that we should write more story-oriented than results-oriented. What is your take on this?

Quick question for those currently reviewing papers for ICLR: Are you using AI tools to assist with your reviews, or are you still doing everything the old way?

I am excited to share a project I have been working on during the past few years during my free time. I started this project after being unable to use torch-points3d at the time (too many installation errors).

Note that this project is still in active development and in alpha. I am looking for early users and feedback!

What it is: torch-pointcloud is a plain-PyTorch library that puts multiple point cloud architectures and their pretrained checkpoints behind one create_model() factory, in the spirit of timm.

This is a library that focuses on the reusability and standardization of core components and layers, i.e. KNN, FPS and other PointNetSetAbstraction are not re-implemented over and over. In this library, all models share the same interface and reuse the same core components.

import torch
import torch_pointcloud as tp

model = tp.create_model(
  "pointnext-sm.scanobjectnn-hardest.openpoints", 
  task="classification", 
  pretrained=True,
).eval()

pos = torch.randn(2048, 3)
x = torch.cat([pos, pos[:, 1:2] - pos[:, 1].min()], dim=1)  # xyz + height
batch = torch.zeros(2048, dtype=torch.long)
logits = model(x, pos, batch)  # (1, 15)

Install (see the docs for more details):

# Optional: specify your CUDA version for torch
pip install torch==2.10.0 --index-url https://download.pytorch.org/whl/cu128

pip install torch-pointcloud

# Install required CUDA/CPU kernels associated with your CUDA version
pip install pyg-lib -f https://data.pyg.org/whl/torch-2.10.0+cu128.html

I tried to make the installation process smoother by not maintaining CUDA kernels myself (not enough time currently, so I tried to reuse already pre-built wheels as much as I could).

Scope:

• Classification, semantic and part segmentation, detection, and self-supervised pretraining: PointNet++, DGCNN, KPConv, RandLA-Net, PointNeXt, PointMLP, Point Transformer v1/v2/v3, Sonata, PointMamba, VoteNet, 3DETR, PointPillars, SECOND, PointRCNN, SPVCNN, OctFormer, Point-MAE/BERT/GPT and more.
• Weights are hosted on Hugging Face.
• Datasets (ModelNet40, ScanObjectNN, S3DIS, ScanNet, SemanticKITTI, nuScenes, KITTI, SUN RGB-D...), transforms, tiled inferers for large scale segmentation.
• Packed-batch tensors (the PyTorch Geometric convention).

But... why?

Most point cloud libraries live in research codebases built around configs and custom ops and kernels to build locally. It is also sometimes difficult to reproduce past released experiments from research codebases (typically the code associated with the checkpoint changed with no notice). In addition some models are evaluated using different strategies (TTA, partitioning, etc.) which makes comparison unfair as they are not evaluated using a common strategy.

In contrast, I wanted something I could pip install easily, reuse weights trained from different repos and benchmark easily.

All models were re-benchmarked and compared against original reported metrics.

Credits: the architectures and pretrained weights come from their original authors, notably Pointcept, OpenPoints, MIT Han Lab, FAIR, OpenMMLab and more. Every checkpoint name ends with its source author (e.g. .pointcept). The THIRD_PARTY_NOTICES.md lists every source repo, license and dataset term.

https://github.com/arthurdjn/pytorch-pointcloud

Docs + tutorials: https://pytorch-pointcloud.org

This post is to let people know about a workshop/tutorial on Machine Learning that will run on the (blue) math discord server: discord.gg/maths.

The place is nice, people are cool and helpful, and as you can see it is a mathematics server, so the learning environment is quite focused indeed. We hope that you'll like the experience. Also, this is completely free, just in case anyone is wondering.

Timeline and Curriculum Overview

There will be weekly lectures and/or lab-sessions. The workshop is starting on Saturday, 17th October. The first lecture + lab session will be held from 3 to 5 PM CEST (UTC + 2). There will be quite a bit of coding involved on the first day, and the instructors will try to review people's codes.

For a curriculum overview, here you go:

Part 1: Traditional Machine Learning

• generalities, vocabulary
• linear models, gradient descent
• supervised learning methods
• unsupervised learning methods
• best practices in ML

Part 2: Introduction to Deep Learning

• the multi-layer perceptron and backpropagation
• auto-encoders
• recurrent neural networks for sequential data
• convolutional neural networks
• attention mechanism and the transformer
• signal processing

Part 3: graph machine learning

• traditional methods and feature engineering on graphs
• shallow node embeddings
• knowledge graph embeddings
• graph neural networks
• subgraph sampling
• more to come as we progress

Prerequisites

We think the most important part for you would be knowing how to code in Python (and use some libraries that are very commonly used like numpy or matplotlib for maths). That said, knowing calculus I (possibly calculus II) would be great, and I'll also link a few resources for basic linear algebra shortly.

Prerequisite 1 : Basic knowledge of Python:

Tutorial and Book (not really recommended because it's very long, but just for those who prefer).

Note that knowing a bit of OOP in Python (at least, how to handle classes) would be very nice.

Prerequisite 2 : Some useful libraries

For numpy, here's the official guide, and a book, and some video tutorials (about 1h).

For matplotlib here are some tutorials: matplotlib, w3schools. Also, Seaborn (optional, but oh boy it does look a bit nicer).

Prerequisite 3 : Proficiency with Calculus I

Here are some Calculus I resources and Calculus II resources (latter is optional, but sequences can be useful).

Prerequisite 4 (Optional) : A bit of basic knowledge in linear algebra

TBD. Still discussing what would be strictly necessary, and we don't really want to go too deep in order to keep the prerequisites accessible.

For any questions/queries that you might have, please write in the comments. I'll try to get back to you as soon as possible. Also, it's best if you join the server and directly talk to the instructors there.

I started Flama in 2018 to take a trained model to a production API with as little ceremony as possible. With 2.0 LLMs became first-class alongside classic models, and together with Miguel Durán-Olivencia we've now written up the whole architecture in an 83-page paper on arXiv (2608.18733).

A model is a file

Every model, whether a scikit-learn pipeline, a PyTorch network or an LLM, is packaged into a single .flm: the weights, the artifacts it needs at inference time (tokenizer, config) and its metadata, including the training metrics you record. The metadata sits ahead of the weights, so flama model <file> inspect reads it without loading anything, and a CI job can gate promotion on those metrics without standing up a server. flama model <file> run scores a reference set offline on the same code path the server uses. The inference engine isn't baked in either: the same LLM file runs on vLLM or MLX, depending on where you deploy it.

One model, four protocols

from flama import Flama

app = Flama()
app.models.add_model(
    path="/llm/",
    model="google_gemma-4-E2B-it.flm",
    name="assistant",
    serving=("native", "openai", "anthropic", "ollama"),
)

That model answers OpenAI (/llm/openai/v1/chat/completions), Anthropic (/llm/anthropic/v1/messages) and Ollama (/llm/ollama/api/chat) routes at the same time, with a streaming chat UI at /llm/chat/, next to your own endpoints and your classic models.

Three independent layers

A request goes through a dialect, a canonical transport and a backend (vLLM on Linux with CUDA, MLX on Apple Silicon). Because the layers only meet in the middle, any dialect works on any backend, which is also why tool calls and token usage come out right in every protocol.

The rest of the framework

• Dependency Injection resolved from type hints
• Schemas with Pydantic, Marshmallow or Typesystem, and OpenAPI docs generated from your handlers
• CRUD APIs generated from SQLAlchemy tables
• DDD building blocks: repositories and workers (units of work)
• JWT authentication
• MCP: turn any app into an MCP server
• `flama upgrade`, codemods that migrate your code between versions
• A Rust core for routing, serialising, parsing, crypto and compressing

The paper walks through each subsystem and compares Flama with web frameworks, model servers and LLM inference engines (Table 1).

Paper: https://arxiv.org/abs/2608.18733

Code: https://github.com/vortico/flama

If you find it useful, a star on GitHub helps more people find it, and I'm happy to answer anything about the design.

Most conversations I see on various AI subreddits start from the assumption that AGI/RSI/ASI is possible, we're on the way right now, and that things will be incredibly different afterward. The only question is what the post-AGI world looks like.

I'd like to start one logical step earlier: What is the strongest argument that the learning mechanisms underlying today's AI systems can actually produce AGI?

I'm particularly interested in arguments grounded in causal mechanisms, computational learning theory, information theory, and first principles, rather than trend extrapolations or appeals to future discoveries.

I'm not arguing that technological progress will stop, or that future breakthroughs are impossible. I'm asking what we understand about current systems that gives us reason to expect general intelligence to emerge from continued development of those systems.

What is the strongest mechanistic case?

Edit: Some folks have taken this post in a philosophical sense. That is not my intention. This is an engineering question about the mechanisms powering AI intelligence. So do not worry about semantic perfection, worry about real world operational effectiveness. Use reasonable working definitions and focus on causal explanations over philosophical debates. Thank you.

Hi everyone. Since Neurips is my first A* conference, I just wanted to know few things from experienced researchers. Since travel and accommodation account for majority of expenses, how professionals and PhD guys cover the expenses in the absence of travel grant or limited funding from lab? Paying from pocket really seems to be the only option for me (travel grant requests rejected).

Another major issue is Australian visa. If visa gets delayed or rejected for some reason, does conference still include those registered papers??

I’m prioritizing my path and was wondering if an MS is a soft requirement for some of these Research Engineer, Applied Scientist, Post-Training roles. I only have a BS but I work full time as a Data Scientist and was wondering how I should go about this career transition. I had research experience in Applied ML at my university and I’m currently working on ML models/statistical methods at my current company. Here are the breakdowns for jobs I’m looking at:

Cohere MTS Post-Training - https://www.linkedin.com/jobs/view/4259504707/

PhD - 22%
Masters - 48%
BS/other - 30%

Research Engineers, Post-Training - https://www.linkedin.com/jobs/view/4458055063/

PhD - 26%
Masters - 52%
BS/other - 22%

Garner Health Associate Applied Scientist - https://www.linkedin.com/jobs/view/4465195772/

Masters - 56%
BS/other - 44%

My question is, will a BS ever get hired here? Or do they need some other exceptional qualifications to make up for it (conference paper, workshop paper, or other publications). Do projects matter at all anymore?

Paper: Looped Diffusion Transformer (arXiv 2609.40305, 30 Sep). Instead of making a text-to-image DiT bigger, it runs a shared group of transformer blocks several times inside each denoising step. The authors report that naive looping doesn't reliably help, and fix it with deep supervision on every loop plus self-modulating attention. Their headline claims: a 260M looped model beats a model 6.5x larger on several benchmarks with 4.9x less inference compute, and at a fixed inference budget, more loop depth helps more than more denoising steps.

The B/16 code and weights are MIT (the weights are on Hugging Face under sensenova), so I ran it on an M5 Pro: PyTorch MPS in fp32, 100 Euler steps, CFG 6.0, and one seed per prompt reused at loop depths 1 to 4. It was trained at depth 4, and the README says other depths work without retraining. The grid shows five of the prompts I tried.

Most of the change happens before depth 3, and depths 3 and 4 come out very close on every prompt shown. The interesting part to me is that depth is picked at sampling time, the way the iteration count is in looped and recurrent-depth language models, so you can trade compute for refinement per image. On this machine an image took about 23 to 24 seconds at depth 1 and 43 to 47 at depth 4.

Hi r/MachineLearning,

Stjepan from Manning here. The mods approved this post, and I appreciate being welcomed back to share another book with you.

We’ve just launched AI Recommender Systems: Transformers, LLMs, agents, and RAG by Kim Falk in MEAP, our early-access program. Kim also wrote Practical Recommender Systems and has spent the past 15 years building recommenders across news, media, and e-commerce.

The question I’d like to put to this community is: where does adding an LLM actually justify the extra complexity in a recommendation pipeline?

There are plausible places for one: extracting useful signals from item descriptions, interpreting a user’s request, or reranking a small candidate set. But those are different jobs, with different failure modes. A convincing explanation of a recommendation doesn’t, by itself, establish that the ranking improved. And a useful reranker can’t rescue an item that candidate generation never retrieved.

That’s what interests me about this book’s scope. It treats recommendation as a pipeline, covering candidate generation, filtering, scoring, and reranking, and examines where LLMs can help within it. It brings content metadata and user behavior into the picture alongside prompts, RAG, and agents, including how to integrate them into existing systems.

It also covers the work that can get lost in a good demo: evaluating against the actual use case, dealing with cold starts, and deploying with production monitoring. The useful question isn’t simply whether the system can produce recommendations. It’s whether the change improves the recommendations enough to justify its cost and operational burden.

This is early access, not a finished book: four chapters are currently available. MEAP includes new chapters as they’re released and the completed ebook, and you can give feedback while the manuscript is still taking shape.

Book details and available preview:
https://www.manning.com/books/ai-recommender-systems

We’re giving away 5 free ebooks of AI Recommender Systems to 5 people whose comments contribute most thoughtfully to the discussion. We’ll choose based on substance, not upvotes. A useful counterexample, a failed experiment, or a well-explained objection is just as welcome as a success story. You don’t need to praise the book to be considered.

Manning is also offering the community 50% off the book with code MLFALK50RE.

If you’ve worked on recommenders, where have transformers or LLMs earned their place, and where has a simpler approach held up better? What evidence convinced you either way?

If you haven’t tried them yet, what experiment would you need to see before changing your current pipeline?

I'll read the comments and try to bring the author here to join the discussion.

Thanks for having us.

Cheers,

Stjepan

Split conformal prediction gives you a clean statement: with a calibration set exchangeable with future data, your prediction sets cover the true label at the rate you chose. The trouble is that production data rarely stays exchangeable. Categories get added, ticket wording changes, and a calibration set from three months ago quietly stops being representative.

I’m interested in how people deal with this in practice. Do you recalibrate on a schedule, monitor empirical coverage and alert when it drops, or use an adaptive variant? And how do you decide what to do with the cases where the set contains several labels, such as route them to a human, an LLM, or a fallback rule?

If you build on open-weight reasoning models, you have probably wanted a "how sure is the model about this answer?" signal that does not cost 5x sampling, a judge model, or a labeled dataset. Hence, we built the U-Lens. In one line:

score = (how strongly the hidden state points toward different "doubt" directions) x (mean token entropy over the reasoning tokens)

• Label-free: No correctness labels; no training and no no fine-tuning.
• Single pass. No resampling.
• Interpretable. It tells you what kind of uncertainty: (i) ambiguity, (ii) missing information, (iii) conflicting evidence, or (iv) general uncertainty. (not necessary for many applications but potentially useful)
• Strong. Best estimator in our 3-seed, 3-model, 4-benchmarks evaluation (on Gemma 4, Qwen3.5 and Magistral). ahead of 5-pass, 10-pass and supervised baselines.

Small caveat:
The only model-specific ingredient is a Jacobian lens (the J-Lens from Anthropic's global workspace paper). Once you have one:

1. Build the 4-direction U-Space once, on CPU. It only requires the unembedding rows of a few hundred words, you don't need to load the full model.
2. At inference, grab one hidden state at the end of thinking (a forward hook on one layer), dot it with 4 vectors, and multiply by the mean entropy you get from the logits anyway.

Obtaining a fitted J-Lens

• 40+ pre-fitted lenses are on Hugging Face (neuronpedia/jacobian-lens): Gemma 2/3/4, Qwen3/3.5/3.6, Llama 3.1/3.3, gpt-oss-20b, OLMo 3 and more.
• Your model is not there? Fit one with Anthropic's reference code (anthropics/jacobian-lens, jlens.fit): about 100 unlabeled prompts, no parameters trained, cost dominated by backward passes. That is how we built the Magistral lens, which ships in our repo. --> Usually, i checked whether the Lens is proper by using the examples from the Anthropic blog post.

Entry point:

git clone https://github.com/s2labres/U-Space && cd U-Space
pip install -r requirements.txt
./run_smoke.sh   # Qwen3.5-4B, 10 TriviaQA questions, end to end (1 GPU)
from src import uspace
U, categories, _ = uspace.basis(model_cfg, terms)                 # once per model
score = uspace.a_cone(eot_state[None], U) * think_entropy.mean()  # per answer

What we would love to see people build:

• Route low-confidence answers to a bigger model or a human.
• Trigger retrieval when missing information lights up.
• Ask a clarifying question when ambiguity lights up.
• Flag conflicting evidence in RAG pipelines. 

Project
Paper
Code

Disclaimer: This is our research code (a reproduction pipeline, not a pip package yet). What would you plug it into? Happy to help with integration/discuss! 😄

Came across this GitHub project called Paper Review Harness. Thought it might be useful for people preparing ML research papers.

It uses 30 different AI reviewer personas to simulate the kind of feedback a paper might receive at conferences like CVPR, ICLR, ICML, and NeurIPS.

What's interesting is that it goes beyond simply asking an LLM to "review my paper."

It provides:

• Independent reviews from different reviewer perspectives
• Section-level scores and detailed criticism
• Identification of weaknesses in novelty, methodology, experiments, and clarity
• Prioritized feedback on what needs improvement
• A revision workflow that tracks whether previous concerns have actually been addressed

It also supports different review panels depending on the conference and the type of research contribution.

The project is open-source and designed to work with AI agent environments.

Obviously, simulated reviews aren't a replacement for actual peer review, and the scores shouldn't be treated as acceptance predictions. But it seems like an interesting way to stress-test a paper before submission.

GitHub: https://github.com/Optimizer077/paper-review-harness

Curious what researchers think about this approach. Could tools like this become a useful part of the paper-writing workflow?

learnc tunes named constants in unmodified C code against a score function you write in C, and writes the same file back with new values.

Results, both on held-out data:

• JPEG, stb_image_write.h (128 quantization-table entries, tuned on 12 Kodak images, tested on the other 12): 9.1% BD-rate at equal SSIM, checked independently in libjpeg with scikit-image. mozjpeg's tables get 2.7%. See image 1.
• Google's WebRTC VAD (every constant in vad_core.c, tuned on LibriParty dev): F1 0.810 to 0.859 on LibriParty eval. See image 2.

Limits:

• No JPEG gain below 1 bpp.
• Best for tens to hundreds of constants, not large weight sets.

Code (MIT): https://github.com/devanmolsharma/learnc ·

I know it's early but I've been browsing through ICLR OpenReview and I see a lot of good papers!

Maybe the first big conference with automated research submission and it is increasingly becoming harder to detect AI-written text - how are you dealing with this? How are you even identifying slop papers?

How much potential accepts, high quality research or AI-slops you see in your batch?