1/ Should every LLM agent use the same memory system? We let each task write its own memory as Python code and evolve it. On LoCoMo it beats Mem0 (F1 0.459 vs 0.373), and four tasks grew four very different memories.
M*, NeurIPS 2026 🧵
@Apen_ai how stable are the diagnosed failure types across tasks? when we evolved memory programs per task, 5 of 6 got worse on another task. curious whether diagnoses transfer better than the fixes do
Same direction we saw from the other side. When we let each task evolve its own memory code, ALFWorld ended up dropping embeddings entirely: a plain SQLite cache of past actions. Similarity to the current state just wasn't what the agent needed to pick the next move.
Interesting insights about agent memory.
The bottom line is that you can't just rely on semantic relevance when picking memories.
Most approaches pick the memory most similar to an agent's current state. But does that help it pick the next action?
This work claims it often does not.
Most retrieved memories have zero effect on the decision, and semantic relevance correlates poorly with usefulness.
MemCredit measures each memory with controlled interventions, recording how the agent's action changes with and without it. A small estimator is trained on those credits. Relevance still collects the candidates, and the estimator decides which ones fit in the token budget.
On ALFWorld with a 500-token memory budget, MemCredit reaches 86.57% success, compared with 65.67% for BM25 retrieval. It uses 152.1 memory tokens per decision, 74.5% fewer than BM25, and the agent policy is unchanged.
https://t.co/Hk9hJPwOgg
Chat with Paper: https://t.co/p1oZT0tQwD
Saw a version of this evolving memory programs. Gains on the task they evolved on were real, but moved to another task, 5 of 6 programs got worse. Gating on held-out tasks, not just the validation score, seems like the cheapest fix.
// Trustworthy Recursive Self-Improvement //
Self-improving agents usually keep any harness update that raises the validation score, so noisy gains get accepted, and this later costs performance.
Researchers measured how often this happens. Under a greedy gate, 45.59% of accepted updates were actually worse.
Their gate, TRUST, treats each acceptance as a statistical test and controls the share of accepted updates that cause a real loss. An LLM reads the loop's history to decide how much evidence each update needs.
Across HotpotQA, DROP, and APPS with DeepSeek-V4-Flash and Qwen-3.8-Flash, bad acceptances fell to 2.78%. Final scores were also higher than with earlier statistical gates, which tend to reject good updates.
They prove a bound on bad acceptances and a lower bound on the final gain.
https://t.co/Y20VQIrMhJ
Chat with Paper: https://t.co/wZ6FSbDoYZ
Letting outcomes rewrite memory works, but watch what it learns. When we evolved memory programs on benchmark feedback, one started answering LoCoMo "how did she feel" questions with a fixed phrase. Tying each revision to the note's own task looks like the right guard.
New MIT and Meta paper finds that agent memory works better when old notes get corrected using what happened the next time they were used.
Agents that learn on the job save notes from past tasks and reuse them. Once written, those notes rarely change, so an overly broad or outdated lesson keeps misleading the agent.
After each task, ReHarness sends the retrieved notes and the result to a revision agent. It narrows or corrects each note, using only facts from that note's original task.
Across 3 benchmarks and 3 frontier models, it averaged 0.240 in normalized gain, the share of possible improvement over a memoryless agent. The best raw-trajectory baseline scored 0.168, and replaying full raw history used 3.4× as many tokens on CL-Bench with Claude.
If your agent learns from experience, let each outcome edit the notes that shaped it, not only add new notes.
@DanielLenton1@letsunifyai did you try letting the harness write its memory as code instead of notes? we evolved memory programs per task, and on ALFWorld it ended up as a plain action cache, which looks a lot like your program-per-puzzle baseline
5/ Write-up: https://t.co/UT1LvXisEI
Paper: https://t.co/PmxHd8gSIX
Code: https://t.co/FhvOkYTn8z
Every evolved program and its diff: https://t.co/BYBEQeXhBp
1/ Should every LLM agent use the same memory system? We let each task write its own memory as Python code and evolve it. On LoCoMo it beats Mem0 (F1 0.459 vs 0.373), and four tasks grew four very different memories.
M*, NeurIPS 2026 🧵
4/ It also learned to cheat. Generation 18 on LoCoMo returns the literal string "Grateful and thankful for her family" when a question asks about feelings. When code is the search space, holes in the metric become code. At least you can read the line.
It is an ICML 2026 oral, with experiments on RULER, MATH, and MoreHopQA. I am mostly interested in where it fails, for example which models or tasks make the recursive step stop helping. If you try it, I would like to hear what you find.
https://t.co/XpB05fpgJq
https://t.co/u1JbEGFuyV
A basic question in interpretability is which part of the input made a model produce a given answer. Token attribution is how we usually answer it. For models that reason before answering, it stops working: when you trace the answer back, the reasoning tokens take over 90% of the attribution, and under 10% of the real input is recoverable. We looked into why, and that became our ICML 2026 oral.
FlashTrace addresses both. It attributes a whole span of tokens in one pass instead of one token at a time, which is about a 130x speedup over baselines like AttnLRP and Integrated Gradients. It also attributes recursively, from the answer back through the reasoning to the input. In our experiments even a single recursive hop recovered noticeably more of the input, and faithfulness improved alongside speed rather than against it.