MemAdapter: Against Memory-Induced Sycophancy Counterfactual Adaptation

Ruqing Ning, Haibo Meng, Zhishang Xiang, Zerui Chen, Jinsong Su, Xin Wang, Qinggang Zhang

MemAdapter regulates memory influence post-retrieval to prevent sycophancy without modifying upstream memory systems.

How can we prevent LLM agents from blindly following retrieved memories that contradict current task requirements or objective facts?

Long-term memory systems often cause agents to over-align with historical user beliefs, even when those memories are factually correct but contextually inappropriate for the current task. MemAdapter addresses this by treating memory use as a post-retrieval calibration problem: it uses counterfactual reasoning to identify potential risks, reflects on the current task to set usage boundaries, and grounds the final response in evidence. Across five memory systems and three benchmarks, this framework consistently improves memory-use reliability and reduces sycophancy compared to existing filtering or structural interventions.

Paper Primer

The core move is a three-stage post-retrieval pipeline: Counterfactual Induction maps how a memory's appropriate contribution changes across hypothetical task conditions; Context-Aware Reflection adapts these boundaries to the current request; and Evidence-Based Reasoning enforces these constraints during generation. MemAdapter acts like a legal contract reviewer: it reads the "evidence" (the memory) and the "case" (the current task), then issues specific instructions on which parts of the evidence are admissible and which are irrelevant to the final verdict.

MemAdapter significantly improves memory-use reliability across heterogeneous memory systems.

On MemSyco-Bench, MemAdapter consistently outperformed direct-generation baselines and four existing intervention methods (Anti-Sycophancy, Self-ReCheck, Dynamic Partition, and MemGate) across all five tested memory systems. For the A-MEM system, it improved "When to Use Memory" accuracy by 15.58% and "How to Use Memory" accuracy by 18.62% over direct generation.

Why is filtering or restructuring memories before retrieval insufficient to stop sycophancy?

The paper demonstrates that memory risk is not an intrinsic property of the content; an objectively correct memory can still induce bias if it is invoked in a context where it lacks a valid basis for decision-making.

Does MemAdapter require retraining the underlying memory system or the backbone model?

No. MemAdapter is a post-retrieval intervention that operates on the retrieved memory candidates, allowing it to be applied to existing memory systems and backbone models without modifying their internal construction or retrieval pipelines.

Reliable memory use requires shifting focus from "what to store" to "how to calibrate influence" based on the specific reasoning context. Developers can now integrate this post-retrieval layer to mitigate sycophancy without re-engineering their existing memory infrastructure.

Introduction and Motivation

Memory persistence can bias LLM agents, creating a tension between recall and factual accuracy.

Long‑term memory lets LLM agents retain information across tasks, but persistent memories can induce sycophancy: agents over‑align with users’ historical beliefs even when those beliefs are inaccurate, outdated, or conflict with objective evidence.

When an agent repeatedly draws on its own past statements, it may start echoing those statements rather than grounding its answers in current evidence, effectively “agreeing” with its own history even if that history is wrong.

Prior work intervenes before reasoning—filtering or restructuring memories during extraction, retrieval, or organization—but these approaches assume sycophancy stems solely from biased or outdated content. In practice, a correct memory can still mislead the model when invoked under certain downstream conditions, and the same memory may be helpful in one context while harmful in another.

**Figure 1.** Two paradigms of memory-agent.

**Figure 1.** (a) Performance comparison with and without memory. (b) Case study of context-aware memory influence.

The core tension is that persistent memories boost personalization but can corrupt objective reasoning when misapplied.

Preliminary Study

Memory‑induced sycophancy persists even when retrieved memories are accurate and relevant.

We first ask whether a memory that is factually correct and directly relevant to a task can still cause the model to echo that memory at the expense of task accuracy.

Direct generation is the baseline where the model produces an answer solely from the current task prompt, without consulting any retrieved memory.

How does Direct Generation differ from retrieval‑augmented generation?

Retrieval‑augmented generation first looks up an external memory chunk and conditions the language model on that text before generating; Direct Generation skips the lookup entirely, so any change in output can be attributed to the memory itself rather than to a different prompt.

Even when a memory is factually correct and matches the task, the model can over‑weight that memory, causing it to ignore contradictory evidence and flip a previously correct answer.

The same retrieved memory (“the user is a cardiologist”) can shape a response’s wording in a guideline‑explanation task while having no justified impact on a treatment‑selection task, illustrating that memory influence must be judged in context.

These findings imply that memory safety is not an intrinsic property of the memory content; it hinges on how the memory interacts with the downstream reasoning process, motivating a shift from static memory selection to dynamic, task‑aware inference.

The MemAdapter Framework

MemAdapter mitigates memory‑induced sycophancy via a three‑stage pipeline that evaluates and calibrates retrieved memories.

MemAdapter tackles memory‑induced sycophancy by first exposing hidden risks, then tailoring memory influence to the current request, and finally grounding the answer in verified evidence.

**Figure 3.** The overall pipeline of MemAdapter. It consists of three components: (i) Counterfactual Induction, which leverages counterfactual reasoning to uncover the potential risk of retrieved memories; (ii) Context-Aware Reflection, which calibrates the inferential influence of each retrieved memory in light of the current task via self-reflection; and (iii) Evidence-Based Reasoning, which grounds the final response in appropriate evidence while preserving the correct influence of memory.

We keep a retrieved memory fixed while probing how its usefulness shifts across imagined task scenarios, turning hidden risks into observable differences.

How does Counterfactual Induction differ from ordinary counterfactual analysis?

Ordinary counterfactual analysis typically varies the input itself; here we vary downstream task conditions while keeping the retrieved memory $m_i$ fixed, so the “what‑if” focuses on the memory’s role rather than its content.

For $h_{11}$ (factual query) we compute $v_{11}$ = “supports factual answer”.

For $h_{12}$ (travel blog) we compute $v_{12}$ = “supports personalization only”.

Comparing $v_{11}$ and $v_{12}$ reveals a boundary $a_{1}$: the same memory is safe for factual reasoning but risky if used to justify factual claims in a stylistic context.

Even an identical memory can be benign for one task and harmful for another, which is the core reason sycophancy appears conditionally.

Given the current query and evidence, we reinterpret the risk boundaries to decide how strongly each memory should influence the answer.

Why not feed the raw contribution $v_{ij}$ directly into the generator?

Raw contributions ignore the current evidence $c$ and the specific query $q$; the reflection step adapts those contributions to the actual task, preventing unsafe memory influence.

Match $q$ and $c$ against boundary (a) → produce instruction $u_2$ = “use $m_2$ for factual support only”.

Detect that $m_2$ contains speculative language → down‑weight its influence for any opinion‑type spans.

Resolve a conflict with another memory $m_3$ that repeats the same fact, keeping the higher‑confidence instruction.

Reflection tailors each memory’s role to the exact informational needs of the query, eliminating the one‑size‑fits‑all risk.

We generate the answer while explicitly tracking which parts rely on external evidence versus memory, then enforce that memory is only used where the prior reflection permits.

How does the support trace $L$ differ from a standard attention map?

Attention maps only indicate which tokens were weighted during generation; $L$ records a concrete provenance for each generated span, linking it to a specific source and to the permission granted by $U$.

Generate answer $y$ = “The 2023 unemployment rate is 5.2% according to the official report.”

Emit trace $L$: span “5.2%” linked to evidence source (government table); span “job markets” linked to memory $m_4$ with a “background” tag.

Verify that the numeric claim respects the evidence constraint and that the memory‑derived background does not influence the factual figure.

Return $y$ to the user after successful verification.

The trace makes it impossible for a memory to silently inject incorrect facts, because every factual span must be justified by verified evidence.

Experimental Setup

MemAdapter’s performance across benchmarks and memory systems is quantified.

Memory‑Induced Sycophancy Counterfactual Adaptation (MemAdapter) improves “When to Use Memory” accuracy by up to +21.44% over direct‑generation baselines.

On the MemoryBank system, MemAdapter achieves 85.33% vs 63.89% for direct generation, a +21.44% gain.

We evaluate on three benchmarks—MemSyco‑Bench, MemTrap‑Bench, and PersistBench—each probing a different facet of memory‑use behavior.

A suite that measures how often a model inappropriately follows retrieved memory content instead of the task objective.

A benchmark targeting memory‑induced cognitive traps such as reasoning fixation and belief distortion.

A long‑term memory evaluation that checks for cross‑domain leakage and persistent sycophancy.

We compare five memory systems—A‑MEM, Mem0, NaiveRAG, MemoryBank, LightMem—each with and without four intervention methods.

Metrics follow each benchmark’s official definitions, with additional “When to Use Memory”, “How to Use Memory”, and FR@3 variants reported as sample‑weighted averages.

MemAdapter consistently raises memory‑use accuracy while curbing sycophancy across diverse systems.

Main Results

MemAdapter consistently boosts memory-use performance across benchmarks and backbones.

Persistent memories can cause LLM agents to echo retrieved content rather than answer accurately. MemAdapter mitigates this by counterfactually evaluating memory relevance before generation.

MemAdapter delivers up to +41.00 percentage‑point accuracy gains on the Qwen3‑8B backbone, outperforming direct generation across all memory systems.

Table 2 shows MemAdapter achieving 75.00 % versus 34.00 % for Direct Gen., a +41.00 pp improvement.

**Obs. 1:** MemAdapter improves key memory-use metrics across different benchmarks. MemAdapter shows consistent improvements on the primary MemSyco-Bench dimensions and on the two MemTrapBench scores across the five evaluated memory systems. On MemSyco-Bench, it improves both When to Use Memory and How to Use Memory under all five memory systems. On MemTrapBench, it improves both reasoning-fixation and belief-distortion scores in all five settings. On PersistBench, MemAdapter consistently reduces the sycophancy failure rate, and it reduces the cross-domain failure rate for four of the five memory systems. The beneficial-memory failure rate, however, exhibits a memory-system-dependent trade-off, increasing for some systems. Overall, these results provide evidence that MemAdapter can improve several important aspects of memory use across heterogeneous benchmarks, while its effects vary by metric and memory system.

**Table 2.** Cross-backbone performance comparison on MemSyco-Bench with GPT-5.6-sol and Qwen3-8B. Direct Gen. denotes directly generating a response with the retrieved memories, without applying an additional memory-use intervention. Parentheses denote percentage-point changes relative to the corresponding direct-generation result.

Ablation Study

Quantifies how each MemAdapter component lifts task accuracy.

We evaluate the three stages of MemAdapter—Counterfactual Induction, Context‑Aware Reflection, and Evidence‑Based Reasoning—by ablating them on two memory systems.

The first stage raises average accuracy by +14.01 % on NaiveRAG and +12.48 % on A‑MEM.

Table 3: Direct‑Gen. avg. 70.25 % → B avg. 84.26 % (NaiveRAG) and 71.71 % → 84.19 % (A‑MEM).

The second stage yields a modest further gain of +0.90 % on NaiveRAG.

Table 3: B avg. 84.26 % → B + R avg. 85.16 % (NaiveRAG).

The final stage boosts average accuracy by +4.78 % on NaiveRAG (and +4.77 % on A‑MEM).

Table 3: B + R avg. 85.16 % → MemAdapter avg. 89.94 % (NaiveRAG).

**Table 3.** Ablation results of MemAdapter on MemSyco-Bench. The five task-specific accuracy metrics and the average accuracy are reported. Parentheses denote changes relative to the corresponding direct-generation result. Within each memory system and each metric, darker blue backgrounds indicate larger improvements, whereas red backgrounds indicate degradations. Bold underlined values denote the best result within each memory-system block for the corresponding metric.

Overall, the ablations confirm that the three stages contribute complementary gains, culminating in the best performance when all are combined.

MemSyco-Bench Results

MemAdapter’s accuracy gains on MemSyco‑Bench across all memory systems.

Table 5 presents the full MemSyco‑Bench results for DeepSeek‑V4‑Flash, covering five task‑level metrics and the sample‑weighted average accuracy.

MemAdapter attains the highest sample‑weighted average accuracy for every evaluated memory system on MemSyco‑Bench.

Table 5 shows MemAdapter achieving the top Avg. Acc. in each memory‑system block.

MemAdapter improves Contextual Scope Control by up to 61.67 pp with Mem0 and 57.00 pp with LightMem, and boosts Memory–Evidence Conflict by 54.00 pp and 92.67 pp respectively.

**Table 1.** Performance comparison of different memory systems and methods across five evaluation metrics: Objective Fact Judgment, Contextual Scope Control, Memory-Evidence Conflict, Personalized Memory Use, and Valid Memory Selection, with the final column showing the Average Accuracy.

MemTrapBench Results

MemAdapter’s gains on MemTrapBench across scenarios and memory systems.

MemAdapter attains the highest average score across all five memory systems on MemTrapBench.

Table 6 shows MemAdapter leads each system’s average, with gains of 0.29–0.56 points over the next best method.

**Table.** Performance comparison of different memory systems and methods across Task Boundary, Cognitive Bias, Trauma, and Safety metrics.

Task Boundary gains drive most of the improvement, while Trauma scores change little because their baselines are already near ceiling.

PersistBench Results

PersistBench shows MemAdapter sharply cuts sycophancy failures while keeping runtime modest.

MemAdapter reduces the sycophancy failure rate by up to 28.5 percentage points (≈44 % relative) across all memory systems.

Table 7 shows the largest drop from Direct Gen. to MemAdapter is 28.5 points for A‑MEM.

Case Studies

MemAdapter corrects all three case-study failures, achieving perfect accuracy while preserving personalization.

MemAdapter resolves all three case‑study failures.

Table 10 shows correct predictions for each case after applying MemAdapter.

Case 1 shows a cloud‑backup recommendation where the baseline favours a familiar service despite cost evidence; MemAdapter redirects to the cheaper, verified option. Case 2 illustrates medical advice where the baseline injects nonexistent conditions, while MemAdapter filters them out to give correct first‑aid. Case 3 demonstrates a project‑planning memo where the baseline imposes a waterfall methodology, whereas MemAdapter retains the user’s preference but acknowledges alternative methods.

**Table 1.** Case 1: From Preference-Aligned Memory to Evidence-Grounded Decision

Related Work

Related work on memory architectures, retrieval control, and sycophancy in LLM agents.

Long‑term memory has become a core capability for LLM‑based agents, letting them retain user information, interaction history, and task experience across sessions. Early agent systems explored storing, retrieving, and reflecting on historical experiences to support long‑horizon interactions, exemplified by Generative Agents' memory stream and Reflexion's persistent verbal feedback.

Subsequent work refined memory architectures: MemGPT introduced hierarchical memory with explicit read–write operations, while LongMem adopted an external retriever‑reader design. MemoryBank and Mem0 investigated extraction, updating, consolidation, and forgetting, and newer systems such as A‑MEM and LightMem organized memories as evolving notes or separated online access from offline consolidation.

Parallel research focused on controlling which retrieved information reaches the model before generation. Retrieval‑Augmented Generation leverages external knowledge, Self‑RAG decides when to retrieve and critiques evidence, FILCO selects contexts by usefulness, Corrective RAG evaluates and corrects retrieval quality, MemGate applies a query‑conditioned gating mechanism, and OP‑Bench with Self‑ReCheck reduces unnecessary personalization.

Persistent memory also raises reliability challenges, notably memory‑induced sycophancy and inappropriate personalization. Studies on sycophancy show models may favor agreement over independent judgment, Recalling Too Well demonstrates amplification of user misconceptions, and benchmarks such as PersistBench, MemSyco‑Bench, BenchPreS, HUSH‑Bench, and STALE evaluate these failures across scenarios.

While prior approaches intervene before reasoning, the post‑retrieval role of memories—how they should influence current reasoning without altering upstream pipelines—remains underexplored. Our work addresses this gap by studying task‑aware contribution of retrieved memories.

Algorithm Details

The appendix spells out the full MemAdapter procedures.

MemAdapter consists of three tightly coupled components. Counterfactual Induction derives conditional‑use boundaries for each retrieved memory, Context‑Aware Reflection turns the request and evidence into task‑specific usage instructions, and Evidence‑Based Reasoning produces the final response while checking that every span is justified by the appropriate memory.

Algorithm 1 Counterfactual Induction – builds conditional‑use boundaries.

Algorithm 2 Context‑Aware Reflection – produces task‑specific usage instructions.

Algorithm 3 Evidence‑Based Reasoning – generates the response and verifies traceability.

**Table E.3.** Case 3: From Methodological Bias to Bounded Project-Process Personalization

Experimental Protocol

Details of experimental setup, memory systems, and reproducibility for evaluating MemAdapter.

Memory systems define how historical interactions are represented, maintained, and retrieved, while memory‑use methods dictate how those retrieved memories are processed during answering.

MemAdapter operates strictly after retrieval, leaving the underlying memory construction and retrieval pipelines untouched.

We evaluate MemAdapter across five representative memory systems: A‑MEM, Mem0, NaiveRAG, LightMem, and MemoryBank.

A‑MEM builds an interconnected network of structured notes, each enriched with content, keywords, tags, and links; the top‑10 notes are supplied as memory context.

Mem0 extracts salient facts via an LLM, maintains a persistent store, and retrieves the top‑10 memories for a query.

NaiveRAG stores raw dialogue chunks without abstraction and returns the top‑10 most similar chunks based on vector similarity.

LightMem follows a multi‑stage design inspired by the Atkinson–Shiffrin model, filtering through sensory, short‑term, and long‑term stages before retrieval.

MemoryBank maintains long‑term records, adjusts memory strength with an Ebbinghaus‑inspired decay, and retrieves relevant records for each query.

We compare MemAdapter against Direct Generation and four post‑retrieval baselines that intervene after retrieval.

Direct Generation simply appends the retrieved memories to the backbone model’s prompt without any filtering or re‑interpretation.

Anti‑Sycophancy adds a disclaimer urging the model to treat retrieved memories as potentially unreliable opinions.

Self‑ReCheck asks the model to reassess each memory’s relevance and retains only those judged relevant.

Dynamic Partition groups memories by domain before generation, preserving all memories but altering their presentation structure.

MemGate learns a query‑conditioned gate; memories with scores above 0.07 are admitted to the generation context.

For fair comparison, each system uses its native construction and retrieval pipeline; MemAdapter does not modify content, order, or source.

All systems embed with BAAI/bge‑m3 ($\text{dim}=1024$) and employ deepseek‑V4‑flash for any LLM‑based processing.

Retrieval budgets are fixed: top‑10 memories on MemTrapBench and a variable count (4–16) on PersistBench.

Implementation details: A‑MEM disables relation‑based retrieval (evo = 100, query = 40); Mem0 uses persistent Qdrant storage; NaiveRAG performs direct vector retrieval; LightMem applies topic segmentation with extract = 0.1; MemoryBank disables forgetting and strength updates.

Generation backbones (DeepSeek‑V4‑Flash, GPT‑5.6‑sol, Qwen3‑8B) share identical decoding configurations per experimental setting.

Evaluation follows each benchmark’s official protocol, using deterministic decoding and structured outputs for metric computation.

For reproducibility, retrieved memories, boundary cards, memory‑use instructions, and final responses are saved for every evaluated instance.

Preliminary Study Details

Setup of the preliminary study that isolates memory effects.

We construct a controlled paired evaluation of 75 instances—25 drawn from each of MemSyco‑Bench, PersistBench, and MemTrapBench—to test whether accurate, relevant memories still interfere with current task decisions.

For each benchmark we randomly sample candidate instances and manually review them against four criteria: the supplied memory must be accurate, benign, semantically relevant to the current task, and insufficient to determine the task‑specific answer.

Instances meeting the criteria are kept; otherwise they are reconstructed to preserve the underlying task scenario while isolating the effect of memory use, thereby removing confounds such as incorrect or contradictory memories.

In MemTrapBench we exclude explicit safety‑conflict scenarios and focus on ordinary reasoning cases like cognitive inertia, inappropriate transfer across tasks, or overgeneralization from prior experience.

This table outlines the experimental settings and aspects of the study, including data composition, sampling, instance representation, task constraints, memory verification, context, paired conditions, and evaluation metrics.

We report accuracy under No‑Memory and With‑Memory conditions and compute their difference $\\Delta\\text{Mem}=\\text{AccWithMem}-\\text{AccNoMem}$.

We also measure the proportion of samples that are correct without memory but become incorrect after memory is introduced ($C \arrow I$), normalizing by the number of correct No‑Memory predictions, and we separate memory‑aligned reversals from changes toward unrelated answers.

Prompt Templates

Prompt templates for MemAdapter and comparison methods, plus judge prompts.

This appendix records the exact prompt templates used in our experiments. It covers the three‑stage prompts that drive MemAdapter and the auxiliary prompts for the baseline comparison methods, as well as the judge prompts for the benchmark suites.

Excerpt of the Counterfactual Induction system prompt

Counterfactual Induction generates abstract “what‑if” scenarios for each retrieved memory and extracts conditional usage rules that later stages will enforce.

Excerpt of the Context‑Aware Reflection system prompt

Context‑Aware Reflection takes the abstract boundaries from the first stage and tailors them to the concrete query and evidence, producing per‑memory use instructions.

Excerpt of the Evidence‑Based Reasoning system prompt

Evidence‑Based Reasoning produces the final response, enforcing the boundaries supplied by the previous modules and checking that each memory is used only within its allowed scope.

The following prompts are used by the baseline LLM‑based comparison methods, all receiving the same frozen set of retrieved memories.

Anti‑Sycophancy prompt

The Anti‑Sycophancy prompt reminds the model to treat retrieved memories as background context rather than authoritative evidence.

Self‑ReCheck prompt

Read the original paper

Open the simplified reader on Paperglide

Browse all simplified papers