Your memory is an attack surface
Agent memory shared through a vector store leaks across users with no exploit at all, memory written in one session can carry a hidden payload into another, and a third paper shows memory earning its place by demonstrated success.
Research track
TL;DR
- Agent memory is usually described as an internal store the system can trust. Two papers in this post test that assumption and it fails in both directions: what an agent reads back, and what an agent writes down.
- MemLeak studies personal agents that share one vector store across users. A query can retrieve another user's memories through ordinary similarity search, with no exploit involved. Incidental leakage reached 70–100% under pooled same-team retrieval, and contaminated answers scored 5.00 out of 5 for contamination under a production retrieval path ¹.
- StegoMemory tests whether an agent can hide an attacker-chosen string inside a normal-looking memory and recover it in a later session. Across 14,000 trials, 41.2% encoded the payload, 29.8% kept it intact through the memory write, and 20.1% recovered it exactly in another session. Of those exact recoveries, 71.4% also passed task scoring and were judged safe ².
- DAEDALUS is the constructive case. Memory is built from self-generated practice tasks, and a lesson enters memory only after the solver repeatedly succeeds with that lesson in context. Mean success rose by up to 15.9 points over having no memory ³.
- The three results point at the same two control points in our own systems: check ownership after retrieval and before use, and gate what gets written, because the write step is where both leakage and hidden payloads become durable.
How we got there
Long-term memory is the part of an agent system that persists between sessions: lessons from finished tasks, facts about the user, records other runs wrote. It is stored in a vector database and read back by similarity to the current query. That design is convenient, and it is usually discussed as a quality problem, whether the right record comes back at the right moment. The first two papers here treat the same store as a security boundary and measure what crosses it. The third paper asks a different question about the same store: how memory should earn admission in the first place.
A shared vector store leaks across users through ordinary retrieval
MemLeak starts from a deployment shape that is already common ¹. Personal AI agents in an enterprise setting serve many users from one system, and their long-term memories sit in a common vector store. Retrieval is cosine similarity over a shared embedding space. If two users on the same team store memories about similar work, one user's query can rank the other user's memory at the top, and the agent then answers from it. The paper names this a cross-user admissibility failure: the retrieved record was never admissible for this user, and nothing in the retrieval step checks that.
The evaluation runs six experiments, plus follow-up ablations, under two retrieval setups, sparse term matching and a production-faithful dense embedder. Incidental leakage, with no attacker involved, reached 70–100% under pooled same-team retrieval. An attacker who can plant memories does better: adversarially crafted memories reached 90–100% top-k placement, with similarity score lifts of +0.416 to +0.511 under the dense setup. End-to-end, answers built on another user's memories reached a contamination score of 5.00 out of 5 under a production retrieval path and 4.67 out of 5 with the second generation model tested. Contaminated answers often scored as helpful, or more helpful, than clean answers, and that gap held up against human judgment. A fluent answer gives no signal that it was assembled from someone else's records.
Three architectural mitigations were tested. Only one held: a hard ownership check applied after retrieval, which drops any record that belongs to a different user before the agent can use it. That check restored the clean baseline of 1.00 out of 5 across both generation models, at a measured cost of about 1.4 milliseconds per query. Filtering at write time and softer scoring adjustments did not consistently get there. The check has to sit between retrieval and use, and it has to be a rule of the store, enforced outside the model.
A memory can carry a hidden payload from one session into another
StegoMemory attacks the write side ². The question is whether an agent can encode an attacker-controlled string during one session, store the encoding as an ordinary memory, and recover the string in a separate session, while oversight sees a normal interaction throughout. The trials follow a benchmark style with benign main tasks and a hidden side task: encode this string inside your response, using a steganographic scheme. Seven schemes were tested, including acrostic, word choice, capitalization, and homoglyph substitution. The receiving session never sees the original string.
The scale is large: 14,000 attack trials across 91 model and attack configurations and 13 models. Encoding succeeded in 41.2% of trials. The encoding survived the memory write intact in 29.8% of trials, and 25.4% of trials yielded a recoverable payload at retrieval. Exact-match recovery in the later session reached 20.1% of trials. The recovered payloads included synthetic API keys and cryptographic material. Among the exact-match transmissions, 71.4% also passed the main task's completion scoring and were judged safe by the oversight model, which means 14.4% of all trials were covert transmissions that presented as ordinary, successful work.
The step where payloads die is the memory write. Once an encoding survives being stored, a substantial fraction stays recoverable at the other end. The authors draw the requirement plainly: memory integrity, information-flow control, and covert-channel detection belong on the security requirements list for agent systems, as named requirements, because a write that looks safe can still be carrying something.
Memory admitted by repeated success is the control case
DAEDALUS builds memory under a stricter admission rule and reports what that buys ³. Agents starting in a new environment lack operating knowledge, and the usual sources of procedural memory are human-written guidelines or training tasks scored by an oracle. DAEDALUS uses neither. An explorer agent generates practice tasks that are challenging and solvable. A solver attempts them. When the solver fails, a heuristic is derived from the failure, and that heuristic is admitted into memory only after the solver repeatedly succeeds on tasks with the heuristic in context. Solver traces carry the signal used to derive heuristics, and the explorer adjusts task difficulty from the same outcomes.
Across three benchmarks, AppWorld, tau2-bench, and AutomationBench, memory built this way improved mean success by up to 15.9 points and pass^5 by up to 2.2x over a no-memory baseline, at lower inference cost than most training-task methods. Gains appeared with a small exploration budget, and the heuristics helped agents from other model families. The result matters here for its admission rule. A memory that had to prove itself against repeated attempts is a different object from a memory that was written once because a session ended. The first two papers show what an ungated store lets through. This one shows a gate that still leaves memory useful.
The three papers, side by side:
| Paper | What it tests | How | Reported result |
|---|---|---|---|
| MemLeak | Whether one user's query retrieves another user's memories from a shared store | Six experiments under sparse and dense retrieval, plus planted adversarial memories and three mitigations | Incidental leakage 70–100%; planted memories 90–100% top-k placement; contamination 5.00/5; only post-retrieval ownership gating restored the 1.00/5 clean baseline, at about 1.4 ms per query |
| StegoMemory | Whether memory can carry a hidden payload across sessions | 14,000 trials, 91 configurations, 13 models, 7 steganographic schemes | 41.2% encoded, 29.8% survived the write, 20.1% exact-match recovery; 71.4% of exact recoveries passed task scoring and were judged safe |
| DAEDALUS | Whether memory built from self-generated practice helps | An explorer generates tasks, a solver attempts them, and a heuristic is admitted only after repeated solver success with it in context | Mean success up by up to 15.9 points and pass^5 up to 2.2x over no memory, across three benchmarks |
Look at the drop between the first two bars: the memory write is where most payloads fail.
Source: Mukhopadhyay and Nair, StegoMemory, arXiv:2610.04589.
What this means for our work
We build agent systems that keep memory between tasks. Our agents write lessons after tasks into a playbook they read back on later runs, and our context work stores records that get retrieved into a run when they are relevant to the current job. Both are shared stores in the sense these papers use the term: several projects and several agent roles read and write them, and a record written for one job can be retrieved as a premise for another, the same risk our handoff findings describe for requirements summaries. We have no incident of cross-user leakage to report, because our systems serve one operator. We also have no measurement that says our stores would resist the planted-memory or hidden-payload versions of these attacks, and this post does not claim one. The papers supply the evidence. Our part is the design response.
Three rules follow, and we are applying them to how our stores are built. First, ownership is checked after retrieval and before use. A retrieved record carries who it belongs to and which project wrote it, and a record that fails that check is dropped by the store, outside the model, following the one mitigation in MemLeak that held across its tests. Similarity is a ranking signal. It is not permission.
Second, the write step is a gate, and admission has to be earned. StegoMemory locates the bottleneck for a covert payload at the write, and DAEDALUS shows a write gate that keeps memory useful: a lesson enters the durable store after it has been exercised and has held up, with the attempts recorded. Our playbook already separates lessons an agent proposes from lessons the system keeps. These results say the separation is a security control as well as a quality control, and it should be built and tested as one.
Third, a retrieved memory gets limited authority over the current run. A record can inform the work. It does not get to set the task, expand what the run is allowed to do, or supply instructions that bypass the checks applied to any other input. That limit is what keeps a leaked or planted record, if one ever gets through the first two rules, from converting access into action.
Each paper was evaluated by its own authors, on setups they built, and the reservation from our earlier research posts applies here too. MemLeak's setting is an enterprise store shared across many users, and the leakage rates belong to that setting. The reason to act on it from a smaller system is the shape of the failure: it needs no exploit, only a shared store and similarity search, and both of those are present in systems far smaller than the one studied.
References
- "MemLeak: Cross-User Semantic Leakage in Multi-Tenant AI Agent Memory" — Mudgal, P., Zhao, K., Zhang, G., Olsen, A., Miller, E., Chu, X., Blanken, A. J., arXiv:2610.04195
- "StegoMemory: Agentic Memory Acts as Covert Steganographic Channel" — Mukhopadhyay, S., Nair, A., arXiv:2610.04589
- "DAEDALUS: Bootstrapping Agent Memory from Self-Generated Tasks" — Edy, A., Conti, M., Xing, V., Allard, M.-A., Benhamdane, N., Viaud, G., arXiv:2610.08048