There's a quiet revolution happening in how we think about decision models, and the latest experiment from the researcher behind the Jev decision lab makes the case better than any press release could. When you budget-match a linear recurrent architecture against a standard transformer, same parameters, same task, same training environment, the linear model doesn't just compete; it dominates on cost while matching accuracy where it matters. For anyone building tools that need to make fast, bounded decisions at scale, this isn't an academic curiosity. It's a practical roadmap.
The results are refreshingly honest. On a long-context retrieval task spanning 2,000 to 8,000 characters, neither the linear model nor the transformer learned much at 15 million parameters, accuracy hovered near chance. That negative result is the point: small decision models are accuracy-starved at this scale, regardless of substrate. But look at the cost side, and the story flips. Training the linear model took about 30 minutes for six fine-tuning epochs. The transformer needed 40 to 45 minutes *per epoch*. That's a six-to-sevenfold gap that only widens as context grows. At 8,192 tokens, the linear model delivered results 2.37 times faster during inference. The O(T) versus O(T²) advantage theory predicts shows up exactly where and when you need it. Earlier rounds on shorter tasks already had the linear model winning outright on accuracy, 50.4 versus 46.2, then 66.2 versus 61.0. So the emerging picture is consistent: linear recurrence wins or ties on short-context decisions and dominates on long-context cost. It simply doesn't learn the hardest retrieval task any better than attention at this parameter count.
This aligns with what we've seen in our own coverage of decision-model architectures. Our comparison of Seven Decision Models Put to the Test Against a Generative LLM showed that routing accuracy and latency don't always move together, and the trade-offs depend heavily on the substrate. The experiment here drills down on that exact tension, proving that for bounded-decision tasks, where you need a choice or a probability, not a paragraph, you can shed the quadratic cost of attention without sacrificing capability. Our earlier piece on Two paths to a smarter decision model: equal accuracy, unequal cost framed this as a theoretical possibility. Now we have reproducible notebooks running on a Colab T4 that make it concrete. The bidirectional variant currently running, V5, will test whether context-aware recurrence closes the accuracy gap on hard retrieval. That result is worth watching.
The practical takeaway for anyone building or choosing a decision model is direct: if your task involves long contexts or high throughput, the linear recurrent backbone is the better bet today. The transformer still has an edge at very short sequences, below about 1,500 tokens it's faster, but that window shrinks as your data grows. The real open question is whether a bidirectional linear model at slightly larger scale can finally match attention on those hard retrieval tasks while keeping the cost advantage. The repo is live, the notebooks are reproducible, and the next round of results will tell us whether we're looking at a specialization or a genuine successor. Either way, the era of assuming attention is the only path to good decisions is over.