Most "agent memory" demos stop at the moment something gets saved. The interesting failures happen later: the right fact is in the window and the model still answers with the old one, or the memory store grows so lopsided that a few hub entries soak up every retrieval while rare states quietly go wrong. Below are six longer reads from this autumn on where memory and context actually break, and on the growing argument that some of that work should move out of the prompt and into code. Each gets a short summary in my own words and a link to the full write-up.
1. Stop deciding what to remember before you know the question
Most memory systems distill a trajectory into a reflection, a workflow or a skill at write time, before anyone knows what future task will need it. Whatever gets thrown away at that point is gone. JitMem (arXiv:2609.27334) keeps raw trajectories and lets a curator assemble a task-specific payload at read time. Because the payload is used on the same task, the curator can be trained straight from task success with GRPO. The post walks through the retrieve, curate, execute, update loop, the reported gains on ALFWorld, WebShop and τ²-bench, and when write-time distillation still makes sense.
Read: JitMem and the case for curating memory at read time
2. Memory use has a shape, and the tail is where errors pile up
Task success and token cost are the usual two rulers. This deep read of CTWM (arXiv:2610.00010) adds a third: how retrieval is distributed. With a finite window, use concentrates on a small core and rare states drift into a long tail where prediction errors accumulate. The proposed fix allocates prompt budget by rank, steers concentration with a single exponent, and summarizes the tail instead of dropping it. Results are reported on a synthetic graph world, ALFWorld and LongMemEval. The section on what to carry over into your own memory layer is the most practical part.
Read: a closer look at heavy-tailed memory traces in long-horizon agents
3. The update is in context, and the model still picks the old value
You tell an assistant you switched your meal preference, and a few turns later it repeats the old one. That isn't a hallucination or a retrieval miss. A UC Berkeley paper (arXiv:2609.38866) calls it stale binding and builds the CICM benchmark to measure it. Probes show the new value is still readable inside the model when it answers wrong, so this is a selection failure, not forgetting. The write-up follows the attention drift toward old values, the one-layer derivation of how old values win together, and a way to redirect attention without retraining.
Read: why memory updates fail even when the new value is right there
4. Memory control doesn't need to run through an LLM
When every write, link, search and stop decision is another round of text generation, memory gets slow and expensive fast. Jev-Mem (arXiv:2609.23986) splits the work into three planes: a fast structured control plane for routine memory decisions, a multi-relational graph for storage, and a reasoning model that is only called when evidence needs to become an answer. The post checks the LoCoMo numbers, compares the design with earlier posts on the site about decision models and harnesses, and ends with a checklist for when a separate control plane is worth building.
Read: taking memory control off the autoregressive critical path
5. Grow the harness instead of the context window
The default way to scale an agent in 2026 is to add more context: longer history, more summaries, more injected skills. Growing Harness (arXiv:2609.26760) asks which control decisions are already stable enough to leave the prompt for good. It starts from a strategy-free scaffold, finds recurring control in failure windows and traces, and compiles it into executable code behind a rollback gate. The post covers the reported success, call and cost numbers, what the learned programs look like, and how the idea relates to prompt optimization and skill libraries.
Read: Grow the harness, not the context
6. A small harness with a real control plane
Pi used to advertise that it did not support MCP. Version 1.0 puts MCP in core, because deferred tool loading and mid-conversation system messages turned out to need the same exposure metadata MCP provides. The center of the release is Codemode: the model writes JavaScript that runs in a QuickJS sandbox to compose, parallelize and filter tool calls, so intermediate results don't flood the context. The post compares this with bash pipes and lists which of Pi's defaults you probably shouldn't copy.
Read: Pi 1.0, Codemode and the minimal coding-agent harness
The common thread: making the window bigger rarely fixes a memory bug. Decide what gets kept later (JitMem), budget by shape (CTWM), check that updates actually take effect (stale binding), and move stable control into code (Jev-Mem, Growing Harness, Pi). I wrote a Japanese roundup on a related set of memory papers on Qiita if you prefer that.
Top comments (0)