The longer a task runs, does AI quietly forget the rules it's supposed to follow

The paper gives this failure mode a name: behavioral state decay. The information never actually gets lost — it's still sitting right there in the record — it just stops mattering.

A long task keeps generating new material: task requirements, environment facts, what's already been tried, diagnosed bugs, unfinished sub-goals. As the trajectory stretches out, this information either gets pushed out of the model's visible context window, or — even while still in the window — stops actually shaping what it does next. The paper collectively calls this kind of "information that should keep constraining future actions" execution state.

The timeline below walks through how one requirement, noted early on, drifts step by step from "alive" to "still on record, but no longer shaping the next move":

Swipe left/right to see the timeline through to the end →

The information was there the whole time — it just stopped shaping the next move. The paper notes this relates to the "lost in the middle" phenomenon in long-context models (information buried in the middle gets ignored), but the emphasis here is more on the behavioral failure itself.

Three typical failure patterns from the paper

From this the paper draws a conclusion: simply feeding the model a longer history isn't enough. What's actually missing is a mechanism to decide "should this remembered piece of information be pulled back out and allowed to shape the decision right now."

A memory steward standing off to the side, whose only job is deciding whether to speak up

This is the paper's first core idea. The design: the executor agent doing the actual work is left completely unchanged; a separate memory agent runs alongside it. It's woken up at fixed intervals, first curates a structured memory store, then decides whether to inject a reminder into the executor's next step.

Swipe left/right to see the full flow diagram →

The paper also draws a clear line between this memory agent and an "advisor"-style approach (where a model acts as a strategist, offering all kinds of suggestions to the model doing the work): the memory agent doesn't give broad strategic advice — every word it speaks must be grounded in a maintained piece of execution state: a specific requirement, fact, failure, or diagnosis.

Figure 1(a) | System integration: on the left, the executor agent interacts with the environment; on the right, the memory agent runs in parallel, observing a sliding window of recent steps and the current memory store; it wakes every N steps to update the store and optionally inject a reminder into the next call. Source: arXiv:2607.08716, original paper figure.

Figure 1(b) | Inside the memory agent: Phase 1 manages the memory store via tool calls (status / knowledge / procedural categories); Phase 2 reads the updated store and either issues a context_for_action reminder or chooses no_intervention. Source: arXiv:2607.08716, original paper figure.

In the main experiments, the trigger is the simplest possible: the memory agent wakes on step one and then every step after, observing a sliding window of the last 8 messages each time. The paper notes this could be swapped for more selective triggers (e.g. only waking on errors, failed tests, or repeated commands), but a fixed cadence was used here to isolate the effect of the reminder policy itself.

How much did adding the memory agent actually raise scores

The paper tested on two long-horizon-task benchmarks: Terminal-Bench 2.0 (autonomous command-line operation — editing code, running commands, fixing bugs) and τ²-Bench (multi-turn conversational tool-calling across three real service domains: airline, retail, and telecom). Scoring uses pass@1The AI only gets one attempt at the task — success rate is whether that single attempt gets it right, not the best of several tries..

Two things worth noting. First, the weaker model gains more, but the stronger one doesn't gain nothing either: Opus 4.6 is already strong, yet with the memory agent it still picks up another 2.4 and 2.5 percentage points on the two benchmarks respectively — meaning this isn't just a patch for weaker models. Second, the gains vary noticeably by scenario, consistent with the paper's framing of memory as a "scenario-adapted intervention strategy" rather than a fixed recipe.

Good recall isn't as valuable as knowing when to shut up

This is the paper's second core idea. To pin down exactly which piece is doing the work, the team ran ablation experimentsRemoving or simplifying one component of a system and checking how much performance drops without it — a way to prove whether that piece actually matters, and how much.: the full approach was broken into five variants and compared head-to-head on τ²-Bench. The conclusion points to one thing — what actually matters isn't "how much it remembers," but "whether it can judge when to speak up."

The five variants: the full two-phase approach (self-selected silence), showing the full memory store to the executor at all times, forcing a reminder every single step, dropping the memory store and acting purely as an advisor, and plugging in a generic memory-retrieval layer, Mem0. The chart below shows the most telling case, the airline scenario — note the red-orange bar, which does worse than not having a memory agent at all:

The gray bar is the Sonnet baseline (68.0%). The red-orange bar (advisor-style advice) drops to 62.0% — worse than not having a memory agent at all. Mem0 ties the baseline, failing to improve the airline scenario.

Why is the gap biggest on airline: this type of task is especially vulnerable to over-interruption — a single unnecessary reminder can throw the executor off track. Only the full approach, which actively chooses to stay silent, scored highest here. Conversely, an advisor that only ever offers suggestions, and a Mem0 layer that only retrieves memory, both stumbled on this scenario.

Averaging across the three scenarios (macro = equal weight per scenario, micro = weighted by task count), the full approach has the highest macro score and improves on all three scenarios, with the biggest gain on airline. One detail worth flagging: forcing a reminder every step scores 0.3 points higher on micro, but that falls within normal noise — once scenarios are weighted equally under macro, the silence-capable full approach retakes the lead, with the gap driven mainly by airline.

The paper's takeaway: simply maintaining a memory store helps, but isn't enough; advisor-style advice without a memory store lacks anchoring and is unstable; forcing a reminder every step is competitive but uneven. The full approach wins precisely because it combines "well-maintained execution state" with "an intervention policy that both knows what to say and knows when to shut up."

Exactly where did the memory agent choose to speak up

The paper's authors manually reviewed trajectories that ran with memory, and found that memory doesn't help through vague summaries — its standout moments come at the exact instant the executor is about to ignore some critical piece of information, reactivating it right then. Below are three real cases.

Laid out across the full trajectory, this looks like the signature chart: most steps are hollow circles (silence), with only a few nodes lit up (a reminder injected) — and each lit node is labeled with exactly what got said.

The paper is also upfront about the remaining failure cases: mostly calibration issues — the memory agent occasionally states a merely speculative conclusion with too much confidence, restates something the executor already knows, or raises a plausible-sounding but unnecessary concern that forces an extra round of checking. These are exactly the motivation for the next step: training it to be even better at knowing when to stay silent.

Teaching this same judgment to a small open-source model

The memory agent in the main experiments is Claude Opus 4.6 — a frontier closed model that has to be called an extra time at every memory step, which isn't cheap. So the team ran an early exploration: can this same judgment be trained into a small open-source model, Qwen3.5-27B, to serve as the memory agent, with the executor model swapped to a frozen Qwen3.5-122B-A10B.

Training used SETA (a scored set of command-line tasks), holding out Terminal-Bench 2.0 as the final transfer test. The method is two steps: SFTSupervised fine-tuning — teaching the model by giving it worked examples to imitate. Here, trajectories from the Opus memory agent serve as the templates, teaching the small model the memory-store operations and the silence/reminder interface. first teaches the interface and basic rules, then GRPOA reinforcement-learning method where the model makes repeated attempts and adjusts its policy based on outcomes, further calibrating "when to speak, when to stay silent" rather than just imitating the templates. reinforcement learning further calibrates the "should I speak up" judgment.

The conclusion: this memory strategy can indeed be learned, but it needs proper calibration — dropping an untrained small model straight in actually makes things worse. It's also worth being clear-eyed about the gap: the trained small model's transfer gain is 3.5 percentage points, well below the 8.3-point gain from using Opus 4.6 as the memory agent. The paper frames this section as "early exploration" — proof the path is viable, not proof it's already caught up to the frontier closed-source version.

Things to watch if you want to try this yourself

Two easily-overlooked points, laid out here in full.

First, the paper claims open-source, but the repo is empty.The paper's body text gives the code address as github.com/yifannnwu/proactive-memory-agent, but this repository was verified on GitHub to be empty: 0 bytes in size, created on June 12, 2026, with nothing ever pushed since — no README, no description. As of July 13, 2026, the code has not actually been open-sourced. There's currently no usable implementation to run directly.

Second, the best-performing memory agent's cost isn't reported anywhere.The best-performing memory agent in the main experiments is Claude Opus 4.6, a frontier closed model — and in practice it's called on step one and then every single step after, which is more frequent than the "fixed interval" language in the methods section suggests. The paper itself admits this isn't the most practical deployment shape, which is exactly why they trained a small open-source model — to cut this cost. But the paper doesn't report actual figures for the extra token consumption and latency the memory agent adds; that math has to be done yourself before deploying it.

The paper also spells out where this applies: this architecture — a separate memory agent deciding whether to interject — doesn't require modifying the main executor model and can be plugged into existing agent workflows. For teams building long-horizon AI agents — automated command-line operations, or multi-turn tool-calling customer service or business processes — this is a module that can be layered on directly.

Meta's solution: leave the working AI completely unchanged, and run a separate "memory steward" alongside it. It periodically curates a memory list, then decides whether to inject a reminder into the next step. The more counterintuitive finding: what actually matters isn't "remembering more," it's "knowing when to speak up." Letting it choose silence on its own beats dumping the full memory out every time, or forcing a reminder at every single step — both scored worse and less consistently.

This reminder is used once and then discarded — it doesn't modify the working AI itself. So how does this "memory steward" actually operate? See the diagram below.

The memory steward (played here by XiaoHu) wakes up every fixed number of steps and does two things: first updates a memory list split into three categories (task requirements, environment facts, what's been tried), then makes a binary choice — inject a reminder, or explicitly stay silent. The diagram below walks through a real scenario: in an airline customer-service task, the user claims to be Gold tier, but the system record shows Regular.

"+8.3 percentage points accuracy" doesn't mean much on its own — put it in terms of actual tasks: hand 100 long command-line tasks to the cheaper Claude Sonnet 4.5, and it gets about 38 right on its own; add the memory steward, and it gets about 46 right — and that handful of extra correct answers is exactly enough to catch it up to the pricier Claude Opus 4.6 (which gets about 44 right on its own).