Long-running AI agents can lose track of what they already learned. Meta AI researchers describe a memory module meant to reduce that problem by keeping useful task state available and deciding when the agent needs to hear it again.
The problem is not just forgetting
The paper describes a recurring failure pattern in extended agent work. An agent may notice a constraint early, then break it later while fixing a separate issue. It may see a command fail and soon try a nearly identical version. It may identify an error pattern, only to treat the same pattern as unfamiliar later in the task.
The authors call this "behavioral state decay." The core issue is that the information guiding the agent’s behavior becomes scattered through a growing task history. It may be buried deep in the context window, drop out of context entirely, or remain visible but stop influencing decisions reliably.
That distinction matters. A longer history gives the system more material to access, but Meta AI says that alone does not solve the behavioral problem. The agent still needs the right constraint, failed attempt, or verified fact to matter at the right moment.
Why a memory agent is different from a summary
Many memory systems focus on storing, updating, and retrieving information. The paper says that approach can be useful for personalization and recall across sessions. But an agent working through a live task faces a more immediate question: should a stored memory affect the next action?
Too little memory support can lead to repeated errors. Too much can create its own cost by adding latency, using tokens, and distracting the agent from current work. Meta AI’s proposal is therefore not only about what to remember. It is about when to interrupt.
This is also why the system is different from a summarizer. A summarizer decides what to keep. Meta AI’s memory module decides whether a stored execution state should be reintroduced into the agent’s next step. Because failure modes differ across tasks, the researchers argue that a fixed summarization rule is not reliable enough for that decision.
How the two-agent setup works
The proposed design keeps the main worker unchanged. Meta AI pairs an unmodified "action agent" with a separate "memory agent." At fixed intervals, the memory agent reviews a sliding window of recent steps, updates a structured memory bank, and then decides whether to send a short reminder into the action agent’s next call.
The memory agent can also stay silent. That silence is part of the policy, not a failure to act. The point is to avoid flooding the action agent with every stored note when only a narrow reminder is useful.
The memory bank has three parts:
- Private status: tracks progress and outstanding risks, but is never shown to the Action Agent.
- Knowledge Memory: stores stable facts such as requirements, file paths, and configurations.
- Procedural Memory: records what the agent tried and what happened, including failed commands, successful fixes, and rejected hypotheses.
The memory agent cannot simply overwrite the bank freely. During each memory step, it updates the bank through predefined tool calls. It then decides whether to reactivate stored state and, if so, writes a focused reminder.
The authors present the module as a plug-and-play component for existing agents and harnesses. It is not a general advisor model. Its role is narrower: provide memory-based reminders rather than broader strategic advice.
Benchmarks show selective reminders helped
The researchers tested the system on Terminal-Bench 2.0, which evaluates autonomous agents in realistic command-line environments. They also used tau2-Bench, which tests conversational tool use in the airline, retail, and telecom sectors. Claude Opus 4.6 served as the memory agent, though the model has since received several updates.
With the older Claude Sonnet 4.5 as the action agent, the system solved 46 percent of Terminal-Bench tasks on its first attempt. The baseline solved 38 percent. On tau2-Bench, the task-weighted average rose from 55 to 62 percent.
The gains were not uniform. Airline and retail tasks each improved by about 10 percentage points, while telecom improved by only 3 points. The researchers say that uneven pattern suggests the memory agent is changing how often it intervenes depending on the task, rather than applying a fixed aggregation rule.
The system also helped when the action agent was stronger. Opus 4.6 improved by 2.4 percentage points on Terminal-Bench and 2.5 points on tau2-Bench. That result suggests the memory module is not only compensating for a weaker model’s limited capacity.
More memory was not always better
The team tested which parts of the design mattered by removing capabilities one at a time. Giving the action agent the full memory bank at every step performed worse than the full system. A version without the "silence" option, which returned a memory at every step, remained competitive but produced less consistent gains across domains.
An advisor-style version without a persistent memory bank helped in some areas and hurt performance in others. The full design, combining a maintained memory bank with selective reminders, performed best.
Meta AI’s approach also outperformed Mem0, a production memory layer that retrieves records through search. The paper’s argument is that the difference is not only retrieval. The memory agent also decides whether and how a remembered state should re-enter the workflow.
One example from the tau2-Bench "Airline" domain shows the intended behavior. A user claimed Gold status, but the tool identified him as a regular customer. The baseline granted compensation based on the user’s claim. The memory agent instead reminded the system to rely on the verified tool data.
Remaining errors were mostly about calibration rather than memory itself. In some cases, the memory agent gave too much weight to a speculative inference.
Open models still need help
The main version does not require a specially trained model and runs as a prompted agent. The researchers also tested whether the intervention policy could be taught to an open model. They trained the smaller Qwen3.5-27B as the memory agent while keeping a much larger action model frozen.
Without training, the smaller memory agent reduced performance. Supervised fine-tuning recovered that loss, and later reinforcement learning improved its decisions about when to recall a stored state.
Meta AI lists several unresolved questions. These include training the memory and action agents together, allowing the system to invoke memory when needed rather than on a fixed schedule, and deciding when literal memories are better than task-specific abstractions.
The broader field has not settled on a standard answer. The source also points to the open-source Mastra framework, which uses two background agents to monitor and compress a conversation, and the GAM system, which aims to prevent "context rot" in long chats. Meta AI has published the project’s code on GitHub.