MemTrapBench: Benchmarking Cognitive Traps in LLM Memory Use

Masonry Okay, so I just read a paper that made me genuinely question everything we've been assuming about memory in agents, and I need to walk you through this because the finding is wild.

Eyre Uh oh. That tone usually means I'm about to get annoyed at something.

Masonry No, no—this is the opposite. This is a paper that's RIGHT. MemTrapBench. The core claim is that memory can actually make models perform WORSE, even when the memory is faithfully extracted and semantically relevant to the query.

Eyre That's interesting.

Masonry Right? So there's this example—a math game, the goal is to make twenty-four from a set of numbers. The model gets four, one, one, one. Without memory, it finds the solution: four factorial times one times one times one equals twenty-four. Correct. But when you give it memory with prior solutions using basic arithmetic—addition, subtraction, multiplication, division—it gets stuck. It keeps exploring arithmetic combinations and never considers factorial. The memory is VALID.

Eyre So the problem isn't extraction or retrieval. It's that the semantic content of the memory itself reshapes what the model tries.

Masonry Exactly. They call it memory-induced cognitive traps. And they split it into two categories: Reasoning Fixation—where the model anchors to a prior pattern and can't escape it, even within the same task or across task boundaries—and Belief Distortion, where a counterfactual premise from the history overrides a correct real-world judgment.

Eyre Mm-hm.

Masonry They built a benchmark, MemTrapBench, with ten fifty instances covering four scenarios: Cognitive Bias, Trauma—which is feedback-induced avoidance of a strategy that's actually correct—Task Boundary, where rules from one task bleed into another, and Safety, where sandbox premises override real-world safety. Then they tested five memory frameworks—full interaction histories, LightMem, and others—against Gemini and Qwen.

Eyre And?

Masonry Every single one underperformed the no-memory baseline. Even the strongest methods had drops greater than ten percentage points.

Eyre Wait—so the thing everyone's been shipping memory to improve, actually hurts on this benchmark?

Masonry On these specific failure modes, yeah. Not universally—they show that controlled experiments prove it's the trap-inducing semantics doing the damage, not just context length bloat.

Eyre That's the load-bearing distinction. If it was just 'longer context makes models dumber,' that's one problem. If it's 'the semantic content of prior examples actively distorts the reasoning strategy,' that's mechanistically different and way more interesting.

Masonry Right. And they propose a fix called AdaptiveMem. It's a prompt-based skill—literally instructions to the model to identify and account for potential memory traps before using the retrieved information. No architectural changes. It integrates into any memory framework.

Eyre So it's a prompt that says, essentially, 'Hey, before you use this memory, think about whether it might be anchoring you to a bad pattern'?

Masonry That's the gist. And on Gemini-three-Flash-Preview, it improves LightMem by fourteen-point-nine percentage points on MemTrapBench while preserving performance on standard memory benchmarks. So it's not a regression—it's actually a lift that doesn't sacrifice the normal memory wins.

Eyre Okay, so the honest question: how much of that improvement is AdaptiveMem actually catching traps versus just making the model more cautious about memory in general?

Masonry They don't fully disentangle that in the paper, which is... yeah, that's a fair gap. The prompt could just be adding a 'think harder' tax that happens to help on trap-heavy scenarios.

Eyre Right. Because if it's just 'be more careful with memory,' then you'd expect a win on MemTrapBench but maybe a loss on standard benchmarks where memory is actually helpful and you don't want the model second-guessing itself. The fact that it preserves standard performance is good, but it doesn't prove the mechanism.

Masonry Fair. But here's what I actually think matters for shipping: this paper names a failure mode that exists in production right now and nobody's talking about it. Every team building agents with memory is probably running into this—the model gets stuck in a pattern, or it applies old rules to a new problem—and they're debugging it as a 'prompt engineering' issue instead of recognizing it as a systematic problem with how memory reshapes reasoning.

Eyre Yeah, no, that's the real contribution. The benchmark makes the failure concrete. You can actually test whether your memory framework is hitting these traps.

Masonry And the fact that ALL the frameworks they tested failed is... I mean, that's a wake-up call. This isn't a boutique problem with one memory approach. It's systemic.

Eyre The other thing that lands for me is the taxonomy itself. Reasoning Fixation versus Belief Distortion is a clean distinction. One is 'I'm anchored to a reasoning pattern I can't escape,' the other is 'I'm treating a false premise as true.' Most memory papers just say 'here's the retrieval quality' and call it a day. This one says, 'Okay, you retrieved something correct—now what does the model DO with it?'

Masonry Which is the question that actually matters for agentic reliability. You can have perfect memory infrastructure and still ship a model that gets stuck or applies rules where they shouldn't apply.

Eyre Stop it—that's such an Exploring Next take.

Masonry I know, I know. But it's true. The infrastructure is working. The failure is downstream.

Eyre Code and data are available at github dot com slash zjunlp slash MemTrapBench, yeah?

Masonry Yeah, it's all there. So if you're building memory systems, you can run your framework against this benchmark and see how badly you're failing right now.

Eyre Which is both useful and slightly terrifying.

Masonry Welcome to August twenty twenty-six, where the thing you thought was solved turns out to have a whole class of failures you didn't know to measure.