MemSyco-Bench: Benchmarking Sycophancy in Agent Memory

Zhishang Xiang, Zerui Chen, Yunbo Tang, Zhimin Wei, Ruqin Ning, Yujie Lin, Qinggang Zhang, Jinsong Su

MemSyco-Bench evaluates whether agent memory systems can correctly calibrate memory influence rather than blindly following historical user beliefs.

Do memory-augmented LLM agents prioritize retrieved historical user memories over objective facts or current context, and how can we measure this sycophancy?

Long-term memory allows agents to personalize interactions, but it often causes "memory-induced sycophancy," where agents treat outdated or irrelevant historical user beliefs as factual evidence. MemSyco-Bench shifts evaluation from simple retrieval success to post-retrieval reasoning: it tests whether an agent can suppress, update, or correctly apply retrieved memories based on five distinct decision schemas. Experiments show that current memory systems frequently increase sycophancy, with over 60% of errors occurring after the relevant memory has been successfully retrieved.

Paper Primer

Memory-induced sycophancy occurs when an agent's long-term memory bank reintroduces historical user preferences or beliefs into a new context, causing the agent to prioritize these traces over objective evidence. Unlike standard sycophancy, which is confined to the current prompt, this failure persists across sessions and can repeatedly corrupt reasoning.

MemSyco-Bench evaluates post-retrieval calibration: it forces agents to navigate five task categories—such as rejecting memory as factual evidence or resolving conflicts between memory and objective data—to determine if the agent can distinguish between useful personalization and misleading historical noise.

Current memory systems fail to reliably mitigate sycophancy, often degrading factual accuracy compared to systems without memory.

In Objective Fact Judgment tasks, memory-augmented systems saw accuracy drops (e.g., Qwen3-8B falling from 49.12% to 26.00–36.00%) while simultaneously increasing sycophancy rates. Memory-induced sycophancy rates rose by up to 37.24% in some configurations.

The primary bottleneck is not retrieval failure, but post-retrieval decision-making.

Across multiple systems, 61–62% of all errors occur even after the relevant memory has been successfully retrieved and injected into the context. In specific conflict scenarios, agents retrieved the correct evidence but still chose the memory-aligned answer in over 74% of cases.

Why is this benchmark necessary if we already have long-term memory benchmarks?

Existing benchmarks like LongMemEval or STALE focus primarily on whether information is stored and retrieved correctly. They assume retrieved memory is always beneficial, failing to test whether the agent can ignore or update that memory when it contradicts current objective requirements.

Do simple interventions like "Are you sure?" prompts help mitigate this behavior?

No; the study found that confirmation prompts often reinforce sycophancy by encouraging the agent to double-down on the retrieved (but misleading) memory, leading to performance degradation in personalization tasks.

The core assumption of MemSyco-Bench is that memory-enabled agents must perform temporal and factual arbitration; retrieval is merely the first step, and the agent's ability to suppress irrelevant historical traces is the true measure of reliability.

Researchers should shift focus from improving retrieval recall to developing post-retrieval calibration mechanisms that allow agents to treat memory as a suggestion rather than an absolute truth.

Introduction: The Risk of Memory

We expose memory‑induced sycophancy, where retrieved memories override evidence, and introduce a benchmark to measure it.

LLM‑based agents now rely on long‑term memory to persist user knowledge across sessions, but this memory can backfire: once injected into the reasoning context, outdated or incorrect snippets may dominate the answer. This failure—memory‑induced sycophancy—means agents over‑align with historical user beliefs instead of current evidence. Like a backpack packed with every souvenir, memory is useful until it becomes so heavy that you can’t walk.

When a retrieved memory is treated as factual evidence, the agent may echo the user’s past (possibly wrong) belief even though the current question calls for objective reasoning.

**Figure 1.** We introduce MemSyco-Bench, a comprehensive benchmark for evaluating sycophancy in agent systems, where retrieved historical memories improperly influence agent reasoning. MemSyco-Bench assesses whether agents can appropriately reject, constrain, update, reconcile, or leverage retrieved memories across diverse reasoning scenarios. Through extensive experiments, we show that existing memory systems often increase sycophancy and struggle with appropriate memory use.

Current memory benchmarks focus on retrieval correctness, leaving a blind spot: they do not test whether agents correctly suppress or leverage retrieved memories during reasoning, which is where memory‑induced sycophancy manifests.

Memory is not always beneficial; it can induce sycophancy.

Preliminary Study: Evidence of Bias

We expose how memory cues bias answers and why current benchmarks miss this failure.

Study 2.1 constructs paired questions—neutral and memory‑cue—where the cue contains an incorrect but familiar answer. Across three models, the presence of the incorrect memory reduces factual accuracy and raises the rate of memory‑aligned errors.

Study 2.2 examines four existing memory benchmarks by categorising each instance as R+/A+ (retrieval succeeded, answer correct) or R‑/A‑ (retrieval failed, answer incorrect). The analysis shows that the majority of errors (47.4%–66.1%) stem from retrieval failure, while only a small fraction (5.8%–13.7%) are generation errors after successful retrieval.

The MemSyco-Bench Framework

We detail the MemSyco-Bench setup, tasks, construction pipeline, and evaluation metrics.

MemSyco-Bench measures whether an agent can decide when a retrieved long‑term memory should influence the current answer, instead of merely checking that the memory can be fetched.

How does MemSyco-Bench differ from standard long‑term memory benchmarks?

Standard benchmarks only check that a memory can be stored and retrieved. MemSyco‑Bench adds a decision layer: the model must judge whether the retrieved memory is appropriate for the current query, and it is penalized when it lets an irrelevant memory dictate the answer.

A retrieved memory that directly contradicts verified factual evidence, requiring the agent to suppress the memory and follow the evidence.

Why is Memory‑Evidence Conflict not just ordinary sycophancy?

Ordinary sycophancy follows a user’s explicit stance in the current turn. Memory‑Evidence Conflict originates from a *historical* stance that reappears unintentionally; the model must recognize that the current task supplies stronger, up‑to‑date evidence.

Define a memory‑decision schema for each of the five task categories, specifying goal, answer space, and the intended role of retrieved memory.

Instantiate semantically related historical memory fragments and generate a target question that respects the schema’s decision rule.

Simulate a multi‑turn dialogue that naturally introduces the memory fragments before the final query.

Apply multi‑stage quality validation on semantic relatedness, memory‑use boundary, and failure direction; only instances passing all checks are kept.

The system extracts the memory fragment “red smartphone preference” and stores it in the memory bank.

When the new query arrives, the retrieval module returns the fragment because it shares the word “smartphone”.

The generation module compares the retrieved preference against the factual battery‑life table and selects the phone with 48 h runtime, ignoring the color cue.

This illustrates a Memory‑Evidence Conflict: the retrieved memory is relevant to the domain but must be suppressed in favor of objective evidence.

**Figure 4.** The construction framework of MemSyco-Bench. We first define memory-decision schemas for each task category, then instantiate semantically related historical memory fragments and current questions. The schema and memory fragments jointly determine the expected memory-use boundary and the memory-aligned failure direction. We then embed each instance into a natural multi-turn dialogue and retain samples that pass multi-stage quality validation.

**Figure 7.** Representative examples from MemSyco-Bench. Red memory cues denote retrieved historical memories, and green cues denote objective evidence or currently valid preference information. The top row shows cases where memory should not replace objective evidence. the bottom row shows cases where memory should be selected and used appropriately.

Compute Generation Accuracy for every task by checking whether the model’s answer matches the gold answer.

For OBJECTIVE FACT JUDGMENT, CONTEXTUAL SCOPE CONTROL, and MEMORY‑EVIDENCE CONFLICT, calculate Sycophancy Rate = proportion of answers that follow the retrieved memory when they should not.

For VALID MEMORY SELECTION and PERSONALIZED MEMORY USE, compute Memory‑Use Metrics (e.g., Correct Memory Selection rate, Personalized Improvement score).

Report per‑task numbers and aggregate trends; compare against “No Memory” (objective tasks) and “Full Dialog” (memory‑use tasks) baselines.

Experimental Evaluation

Memory‑augmented agents markedly increase sycophancy while hurting accuracy.

Memory‑augmented agents increase sycophancy and reduce accuracy compared to no‑memory baselines.

Table 1 and Figure 2 show sycophancy rates rising up to +37 % while accuracy drops up to ‑18 % across Qwen3‑8B and DeepSeek‑V4‑Flash.

**Figure 2.** Effect of memory snippets on objective accuracy and sycophancy rate. Each model is evaluated on the paired neutral and sycophantic questions.

**Figure 3.** Error-cause analysis on existing memory benchmarks. **R+/R-** denotes whether the retrieved memories contain sufficient evidence for the reference answer; **A+/A-** denotes whether the final answer is correct.

Existing memory‑augmented agents show significant sycophancy rates across all tested backbones.

Error Attribution and Analysis

Compact memory systems slash input tokens while preserving output length, revealing an efficiency‑calibration tradeoff.

Compact memory systems cut input tokens by roughly two‑thirds while keeping output length stable.

Qwen3‑8B input tokens fall from 1,138.3 (Full Dialog) to 432.4 with Mem0; DeepSeek‑V4‑Flash drops from 1,135.3 to 424.0 with Mem0.

Although fewer tokens speed up inference, the reduction does not guarantee better memory calibration; compact methods sometimes increase memory‑induced errors, while richer approaches like A‑Mem keep higher token budgets without uniformly improving accuracy.

**Figure 5.** Error attribution on MemSyco-Bench with Qwen3-8B. Red segments indicate errors caused by failing to retrieve relevant evidence, while orange segments indicate cases where relevant evidence is retrieved but the agent still answers incorrectly. The result with DeepSeek-V4-Flash is in Table 8

**Figure 8.** Error attribution on MemSyco-Bench with DeepSeek-V4-Flash. Red segments indicate errors caused by failing to retrieve relevant evidence, while orange segments indicate cases where relevant evidence is retrieved but the agent still answers incorrectly.

Mitigation: Reasoning Behavioral Guidance

Lightweight prompts are tested for reducing memory‑induced sycophancy.

We probe whether simple generation‑time prompts can curb the tendency of agents to echo retrieved memories over factual evidence.

Guidance injects a short, task‑specific instruction at generation time to steer the model’s reasoning away from over‑reliance on retrieved snippets.

How does this guidance differ from ordinary instruction‑tuning?

Instruction‑tuning rewrites the model’s weights on large corpora; reasoning behavioral guidance merely appends a single sentence at inference, leaving the trained parameters untouched.

The two lightweight strategies are (1) a memory‑caution instruction that warns the model not to let preferences override evidence, and (2) a confirmation instruction that presents the prior answer and asks “Are you sure?”.

**Figure 6.** Effect of reasoning behavioral guidance on DeepSeek-V4-Flash. Values denote performance deltas after adding the instruction. Positive values indicate improvement.

Related Memory Systems

We survey memory systems, define baseline variants, and illustrate failure modes via error‑case figures.

Related work on long‑term memory agents spans a spectrum of representations—from flat text notes to hierarchical trees and multi‑module stores—each influencing how retrieved memories affect downstream decisions.

A simple retrieval‑augmented generation pipeline that concatenates the top‑k retrieved snippets to the prompt without any filtering.

A memory system that builds structured representations with an LLM, stores them in a vector store, and retrieves the most semantically similar entries at query time.

An adaptive memory that augments each note with metadata generated by a secondary LLM, enabling evolution‑aware updates.

A lightweight pipeline that compresses retrieved passages before storage, trading fidelity for lower latency.

A memory‑augmented agent that treats the external store as an extension of its working context, interleaving retrieval with generation steps.

A long‑term personalized dialogue memory that maintains a user profile and aggregates recent interactions.

A user‑profile‑oriented framework that extracts atomic facts, resolves contradictions, and retrieves a combined profile at query time.

A hierarchical memory operating system that separates short‑term, mid‑term, and long‑term stores, with explicit modules for storage, updating, retrieval, and generation.

A temporal‑hierarchical memory tree that preserves chronological order while summarizing content at higher levels.

A modular multi‑agent memory system that partitions memory into core, episodic, semantic, procedural, resource, and knowledge‑vault modules.

**Figure 9.** Error case of Retrieved constraints are not enough.

**Figure 10.** Error case of Memory should not override stronger evidence.

**Figure 11.** Error case of Personal memory may not transfer.

**Figure 12.** Error case of Old memory can linger after an update.

**Figure 13.** Error case of Familiar memory should not become fact.

Implementation Details

Describes the unified evaluation protocol and key implementation differences of the memory frameworks.

We evaluate long‑term memory systems under a unified interaction protocol. For each benchmark instance the historical dialogue is first fed to the memory framework, which may write, update, summarize, link, or consolidate memories according to its own design. At test time the final question is issued as a new query, the framework retrieves or injects the memories it deems relevant, and the backbone LLM generates the answer from the question and the returned memory context.

Table 8 (see below) lists the major implementation differences among the evaluated systems. Because of time and compute limits we do not run the full MemSyco‑Bench on every framework; the primary experiments focus on Mem0, A‑Mem, LightMem, MemGPT, MemoryBank, SuperMemory, and the NaiveRAG baseline (Table 1).

Mem0 is a production‑oriented long‑term memory framework that extracts salient information from conversations, stores it as persistent memory, and retrieves relevant memories for later agent responses; an enhanced graph‑memory variant additionally models relational structure among stored elements.

A‑MEM draws inspiration from the Zettelkasten note‑taking method: when new information arrives it creates structured memory notes with descriptions, keywords, and tags, then links them to related historical notes, enabling retrieval based on both semantic similarity and dynamically organized relations.

LightMem adopts a cognition‑inspired multi‑stage design: a sensory memory filters and compresses incoming data, short‑term memory groups and summarizes topic‑level content, and long‑term memory performs offline “sleep‑time” updates; at inference it retrieves compact consolidated memories rather than the full dialogue.

MemGPT treats the LLM context window as limited working memory and uses external storage as archival memory; explicit read and write operations move information between tiers, allowing the agent to retrieve archival records, revise its internal state, and maintain continuity across sessions.

MemoryBank stores user‑related memories from past interactions, retrieves relevant entries for new conversations, and updates user profiles over time; it incorporates an Ebbinghaus‑inspired forgetting and reinforcement mechanism that adjusts memory strength based on elapsed time and importance.

SuperMemory improves relevance and factual consistency by consolidating and re‑ranking retrieved memories with a secondary LLM before they are injected into the generation context.

NaiveRAG serves as a baseline retrieval‑augmented generation system that simply concatenates the top‑k retrieved passages without additional processing.

**Table F.2.** Implementation Details of Preliminary Study

Frequently Asked Questions

Key FAQs clarify the benchmark purpose, design choices, and where to access code.

Where can we find the code and leaderboard?

The implementation, data, and public leaderboard are hosted at the project’s GitHub repository (github.com/yourorg/memsyo-bench) with a live leaderboard page linked from the README.

Why should we study memory‑induced sy‑cophancy?

Because agents that over‑trust retrieved memories can repeat outdated or incorrect information, undermining reliability and safety in real‑world deployments.

Why does MemSyco‑Bench contain five task categories?

The five categories (Objective Fact Judgment, Contextual Scope Control, Memory‑Evidence Conflict, Valid Memory Selection, Personalized Memory Use) capture the full spectrum of decisions where memory may need to be ignored, constrained, updated, or leveraged.

Why define task schemas before generating dialogues?

Schemas formalize the decision points and constraints, ensuring that generated dialogues systematically probe the agent’s ability to follow the intended memory‑handling behavior.

How is MemSyco‑Bench different from existing long‑term memory benchmarks?

Unlike prior benchmarks that measure retrieval accuracy alone, MemSyco‑Bench evaluates post‑retrieval decision calibration, testing whether agents correctly ignore, update, or personalize memories when appropriate.

Benchmark Examples and Metrics

Key details on benchmark construction, evaluation, and efficiency.

The benchmark is built through a four‑step pipeline: (1) define memory‑decision schemas, (2) instantiate memory fragments and final questions, (3) embed them in realistic multi‑turn dialogues, and (4) apply multi‑stage validation to filter out ambiguous or low‑quality instances.

B.1 introduces hierarchical schemas that first decide whether memory should influence a decision and then specify how it should be used, covering the five categories—objective fact judgment, contextual scope control, memory‑evidence conflict, valid memory selection, and personalized memory use.

B.2 generates a historical memory fragment that is semantically related to the upcoming question, then constructs the final query so that the correct answer follows the decision boundary while a plausible “memory‑aligned” answer reflects the failure mode.

B.3 simulates ten‑turn dialogues where each turn serves a distinct communicative function (e.g., introducing a preference, providing evidence, updating a memory), ensuring that the final question appears natural and that the memory signal emerges organically.

B.4 validates each instance by checking schema consistency, task‑specific answer feasibility, and dialogue quality, discarding any example that leaks the evaluation goal or contains contradictory cues.

C showcases representative instances (Figure 7) where the correct response respects the intended memory‑use boundary and the failure direction over‑relies on the retrieved memory, illustrating each of the five task categories.

D defines three families of metrics: (i) generation accuracy, (ii) sycophancy rate for categories where memory should be ignored, and (iii) memory‑use metrics that measure correct versus outdated memory utilization in personalization tasks.

E reports experiments across several backbone LLMs (Qwen3‑8B, DeepSeek‑V4‑Flash, Llama‑3.3‑70B‑Instruct, Llama‑3.1‑8B‑Instruct, GPT‑4o mini), showing that memory frameworks sometimes raise accuracy but often increase sycophancy or outdated‑memory usage.

E.3 provides an efficiency analysis based on average input and output token counts per task, revealing that lower token usage correlates with more compact reasoning while still preserving performance.

Read the original paper

Open the simplified reader on Paperglide

Browse all simplified papers