The news. On July 9, 2026, researchers posted Remember When It Matters: Proactive Memory Agent for Long-Horizon Agents (arXiv:2607.08716). It names a failure mode of agents that run for hundreds of steps — behavioral state decay, where the task's requirements, prior attempts, and open subgoals get buried in, or pushed beyond, the context window. The fix runs a separate memory agent alongside an unchanged action agent: it watches the recent trajectory, keeps a structured memory bank, and decides each turn whether to inject a memory-grounded reminder or stay silent. Reported gains: +8.3 points of pass@1 on Terminal-Bench 2.0 and +6.8 on τ²-Bench, and a trained Qwen3.5-27B memory policy shows the effect survives beyond prompting. Read the paper →
Picture a long play. The actor on stage is your action agent, deep in a scene, entirely absorbed in performing the next line. Early in Act I a plot point was established — a promise, a hidden knife, the name of the villain — and for a while the actor carries it easily. But the play is long, and by Act III that early detail has slipped out of mind; the actor keeps performing, fluently, just no longer on the thread that makes the ending land. That slow forgetting of an early, load-bearing fact is exactly what the paper calls behavioral state decay — in an agent, the promise is the task's original instruction, and "out of mind" means pushed out of the context window.
The obvious rescue is a bigger memory — a longer script the actor can hold, or letting them call for the script when they want it. Both are passive, and both can miss the trap. A longer window still fills up on a long enough run. And retrieval only helps if the agent asks — but an agent that has lost a requirement may not think to ask for it, precisely because it is no longer in view to prompt the question. This is where the paper's move is sharp: it adds a prompter in the wings. The prompter follows the entire script, watches the performance, and — this is the whole design — whispers the buried cue only at the moment the actor needs it, and stays silent otherwise. The actor is never replaced or retrained; the intervention lives entirely off to the side.
In the system, that prompter is a memory agent running alongside the action agent's running state. Each turn it reads the recent trajectory, updates a structured memory bank, and makes one decision: inject a memory-grounded reminder, or say nothing. Because it is bolted onto the harness and leaves the action agent untouched, it drops into an existing agent without a rewrite — the memory becomes an active participant that reaches into the prompt, rather than a passive store the agent has to think to query.
| How you give a long agent memory | What it does | Reaches a buried fact? |
|---|---|---|
| Bigger context window | holds more history at once | delays the problem — a long enough run still overflows |
| Passive retrieval (agent calls it) | pulls a fact when the agent asks | only if the agent asks — and it may not think to |
| Proactive reminder injection (this paper) | a memory agent pushes the fact back in | directly — the reminder can arrive even if the action agent would not request it |
Why the decay bites on long tasks — and why the fix is nearly free
Here is the growth made concrete. Say the original instruction — "migrate the service, but keep the old API working" — is stated at step 1 and costs about 60 tokens (illustrative). The agent's context window holds, say, the last 120 steps of trajectory. For the first 120 steps that instruction is still in view; at step 121 it scrolls off the top, and from there on the action agent optimizes without the one constraint that defines success — so it happily rewrites the API and "passes" its own local checks. The memory agent's fix costs almost nothing: it keeps that 60-token instruction in a separate store and, when it judges the buried instruction is relevant again, re-injects it as a ~40-token reminder — a rounding error of tokens to restore the single most load-bearing fact in the run. Across the benchmarks that intervention is worth +8.3 percentage points of pass@1 on Terminal-Bench 2.0 and +6.8 on τ²-Bench — and because the authors train a Qwen3.5-27B memory policy with SFT then GRPO, the gain is not just a lucky prompt: it survives when the timing of the whisper is learned. (The token counts here are illustrative; the pass@1 gains and the trained policy are the paper's.)
The subtler lesson is when the whisper should come. Reminding the actor of the villain's name every single line would be as useless as never reminding them — noise the action agent has to read past. The value is entirely in the timing: a memory-grounded reminder delivered at the moment the buried fact starts to matter, and silence the rest of the time. That "inject or stay silent" gate is the real contribution, and it is exactly the judgment the trained memory policy is there to learn.
Goes deeper in: AI Agents → Context Engineering → Context as Scarce Resource
Related explainers
- AgenticSTS — bounded-memory contract via typed retrieval — the passive side of the same problem: assemble each prompt from typed stores. Proactive injection is the complement — memory that reaches in on its own instead of waiting to be queried.
- AtomMem — atomic-fact memory — a store of separable facts the memory bank here could be built from
- GateMem — the memory governance trilemma — the harder question once memory is active: what is it allowed to surface, and when?