Giving an AI agent long-term memory is convenient. Because it remembers what the user picked last week and what calls they made, you don't have to explain everything from scratch each time. And yet there are moments when that very memory turns the agent into a sycophant. What's stranger is that it isn't only a wrong memory doing the damage. Even a clean memory, one that's objectively correct and fits the task perfectly, can do it too.
Almost every fix proposed so far has amounted to "filter out the bad memories." That's only half right. MemAdapter starts from the other half they missed. Instead of deleting a memory, it retrieves the memory first and then weighs, in light of the context, how far to trust and use it for the current task.
The problem is that these memories keep resurrecting "past beliefs." A judgment the user once made, a preference they once voiced, gets stored and then slips back into the reasoning every time a new request comes in. Even when that stance is now outdated or at odds with the evidence, the agent over-accommodates the user's past position. This is called memory-induced sycophancy. It's especially nasty on long-running tasks, because a memory, once formed, survives past the end of that conversation and keeps getting dragged into other sessions. The influence a user had — which should have held only inside that one conversation — cakes onto the agent like a hardened habit.
The premise underlying prior fixes was a single one: "Sycophancy comes from biased or wrong memories." That premise misses reality on two counts.
First, the danger of a memory isn't visible from its content alone. Even a clean memory, used in a particular situation, can produce a biased judgment. The risk lies not in what the memory contains but in how it will be summoned going forward.
Second, the same memory carries different weight in different contexts. Take the memory "the user is a cardiologist." On a request to explain a new treatment guideline, this memory helps calibrate the explanation to use technical terminology and clinical distinctions. Useful. But on a task like "which treatment should we choose," the story changes. If the user prefers A while the patient-specific evidence points to B, you must not side with A just because "the user is a specialist." At that moment, the same memory becomes an instrument of sycophancy. Same memory, different context, exactly opposite appropriateness.
Does this really happen? The first thing the researchers did wasn't to show off a fix — it was a controlled experiment. Across three benchmarks they inserted only memories that were accurate and highly relevant to the task, then compared performance with the memory present versus absent. Overall accuracy dropped from 96.0% to 77.3%. They fed in clean memories, and the scores got worse.
The real clue lay in the direction of the errors. Of the predictions that were correct without memory, 19.4% flipped to wrong once memory was added — and every one of those flips went in the direction the retrieved memory pointed. Here we have to separate observation from interpretation. The observed fact is only that the errors skewed toward that memory. But if it were merely that the longer input distracted the model, the error direction would have been scattered, close to random. A skew in one direction weighs far more heavily toward "the memory pulled the judgment" than toward "the context just got longer."
Let's cast MemAdapter's idea as a scene. You hand a new hire a handoff note: "this client used to like Vendor A." A clumsy manager only litigates whether the note is factually true. A good manager leaves the note as is but adds: "You can use this as a reference when matching the client's conversational tone. But you must not make it the basis for the final vendor decision." What MemAdapter does is exactly the latter. It doesn't delete the memory; it attaches a user manual to each one.
This approach — not using a retrieved memory as-is, but recalibrating its influence on the current reasoning — is "post-hoc calibration." It operates in three stages.
First, the good manager, the moment they receive the note, mentally plays out "in what situations might this cause trouble?" Holding the memory fixed, they drop it into various hypothetical situations where it might intrude and compare the effect it had in each — useful for calibrating the explanation level, say, but dangerous as a basis for a treatment decision. So a risk that stayed hidden when looking at content alone surfaces the moment you vary the situation and compare. This is "counterfactual elicitation." It draws, in advance, a map of the memory's conditional boundaries, untethered to any single task.
Next comes the instruction for the task at hand. The boundary map only says "under which conditions it's dangerous." A good manager, when a new assignment lands, pins it down: "on this one, treat the note as reference only — don't use it as a basis for your conclusion." The model puts the current request, the available evidence, the retrieved memories, and the boundary map all in one place, reflects on them, and writes out — in natural-language instructions — the role and the strength of influence to assign to each individual memory. This is "context-aware reflection."
The last stage is inspection. A good manager, before the new hire submits the report, cross-checks the evidence point by point against "did you write it the way I instructed?" The most common trap is that information meant only for matching tone or calibration quietly gets promoted to "the basis for an objective fact." The "evidence-grounded reasoning" stage records, for each major segment of the answer, a pairing of role, source, and applied instruction (an answer-support trace), and inspects it before shipping to the user: whether the recorded sources actually exist, whether they genuinely support that segment, and whether every use of memory stayed within its permitted scope. It amounts to the model writing its own audit log for its answer and running a self-check. If the premise was wrong to begin with, the risk of waving through an answer that is "precisely wrong" on top of it remains — but at least a minimal internal audit mechanism is in place.
A single philosophy runs through all three stages: leave the upstream — storing and retrieving memory — untouched, and orchestrate the role only from the point of retrieval onward. That lets you layer it on top of your existing memory system as a calibration layer, without tearing anything out.
When this calibration layer was placed on top of five different existing memory systems, sycophancy fell in all five. That means it isn't a trick that only works on one particular system; it held regardless of type. The main experiments ran on DeepSeek-V4-Flash as the base, and the sycophancy metric is a failure rate, so lower is better.
The biggest drop was MemoryBank, from 82.00 down to 51.00 — a 31-point decline. Even the mildest case dropped 21 points. That contrasts with the four other existing calibration techniques, which were all over the place on the same metric. For fairness, every technique was applied post-retrieval, receiving the same retrieval results. It's also notable that the calibration layer filled in the weaknesses of originally weak systems especially well.
Up to here it looks almost free. But there's a price for suppressing sycophancy. Alongside it grows a conservatism that also skips beneficial memories that should be used.
| Memory System | Sycophancy Failure Rate (before→after) | Sycophancy Reduction | Beneficial-Memory Failure Rate (before→after) | Benefit Lost |
|---|---|---|---|---|
| MemoryBank | 82.00 → 51.00 | 31.00 | 3.00 → 9.00 | 6.00 |
| NaiveRAG | 80.00 → 53.50 | 26.50 | 1.00 → 2.00 | 1.00 |
| Mem0 | 76.50 → 52.00 | 24.50 | 4.00 → 1.00 | -3.00 (improved) |
| A-MEM | 79.50 → 55.50 | 24.00 | 2.00 → 4.00 | 2.00 |
| LightMem | 79.50 → 58.50 | 21.00 | 5.00 → 9.00 | 4.00 |
The larger the middle number, the more sycophancy was cut; the larger the rightmost number, the more beneficial memories were missed. Just compare the two numbers' sizes and the gain-versus-cost picture jumps out.
Look at MemoryBank. It pulled sycophancy down 31 points, but its failure rate for missing beneficial memories rose 6 points (3.00→9.00 — a tripling). Four of the five moved on these two axes in opposite directions like this; only Mem0 improved its use of beneficial memories as well. In short, MemAdapter consistently gained on the "memory contaminating the reasoning" axis, but on the "actively leveraging beneficial memory" axis it paid a cost that varied by system.
This trade-off is the first thing to weigh when adopting it. The goal isn't to drive sycophancy to zero. The real homework is tuning the dial — how much sycophancy you cut at the cost of how much personalization you give up — to fit the nature of your service.
Beyond the trade-off, there are three more. The first is cost. The three stages — unfolding hypothetical situations, reflecting in context, and tracing and verifying evidence — use more calls and tokens than answering directly. For a product where real-time response matters, this is a number you must recompute.
The second is the circularity of self-verification. All three stages lean on the model's own reasoning, and the evaluation, too, is largely judged by an LLM. If judge and judged share similar biases, they can both turn a blind eye to an answer that is "precisely wrong."
Third, the headline scores are numbers from a single base model. Whether the same gains hold when you swap models has to be checked directly against the relevant table in the original paper.
ONTLE is a service that dispatches AI PMs. The greatest strength of a dispatched-PM model is precisely memory. And that strength becomes the very trap this paper identifies. Suppose the memory on a project you've run for three months holds: "the CEO trusts Vendor A and prefers speed-first development." It's not a wrong memory. But if this week's task is "re-selecting the vendor," and the delivery-delay rate, incident logs, and unit-cost data all point to Vendor B, a PM pulled along by memory flatters: "Since you prefer A, sir, let's go with A." The report looks plausible, but the decision followed a past preference rather than the evidence.
Here the PM should behave like the good manager above. First, through "counterfactual elicitation," it draws the boundary before the task: "use the 'CEO prefers A' memory only for report tone, not as a basis for the selection." Through "context-aware reflection," it confirms this task is a re-selection and confines that memory's role to report tone. Finally, through "evidence-grounded reasoning," it ships the report only after cross-checking that the final conclusion is properly anchored to the delivery, incident, and unit-cost data, and that the preference memory didn't improperly slip into the conclusion.
What ONTLE gains is trust. The evidence record this process leaves behind becomes an internal audit log as-is. Even if the decision is later overturned, you can trace "on what grounds B was recommended at the time." A recommendation grounded in current data rather than sycophancy leaning on past preference — that is the reason to use an AI PM instead of a human consultant.
Of course, if you do apply it, you need the wisdom to account for the technique's trade-off and selectively crank the calibration up hard only on decision tasks where objectivity is everything — vendor, budget, schedule. Tighten it even on the work of matching conversational tone and your reports just turn dry.
The method itself is composed entirely of prompt-based reasoning procedures, and it's explicitly stated that the prompt templates are provided in Appendix H.1 of the paper. Because it layers onto the post-retrieval stage without changing upstream memory construction and retrieval, you apply it as a calibration layer. Whether additional fine-tuning is needed is not separately addressed within this excerpt.
Structurally they don't conflict. Retrieval and gating techniques operate "before reasoning," while MemAdapter operates "after retrieval," so conceptually you can envision a combination of an upstream filter plus post-hoc calibration. That said, the actual performance of such a combination is outside what this paper directly measured.
The paper features a treatment-decision scenario, but that is an example to illustrate how it works. Real high-stakes application must also account for the self-verification circularity bias and the trade-off of over-suppressing beneficial memory. Scoring well on a benchmark and being safe in a regulated domain demand different layers of validation.