Research Deep-Dive · XiaoHu Explains

Meta AI proposes a proactive memory agent: teaching agents to "only speak up when it matters," lifting Terminal-Bench accuracy by 8.3 points

The paper says the code is open-sourced — but the repo turns out to be empty, with not a single commit ever pushed.
60-second overview
  • Meta AI proposes a "proactive memory agent" that runs alongside an unmodified executor agent, periodically updates a structured memory store, and actively decides whether to interject a reminder for the executor.
  • On Terminal-Bench 2.0, pairing Claude Sonnet 4.5 with the memory agent lifts accuracy from 37.6% to 45.9% (+8.3 percentage points); on τ²-Bench it rises from 55.0% to 61.8% (+6.8 percentage points).
  • Ablations show: letting the memory agent decide "whether to speak" on its own beats showing the full memory store every time, forcing a reminder every step, dropping the memory store and only giving advice, or plugging in a generic memory-retrieval layer like Mem0 — more consistently across the board.
  • The team also tried training the same memory agent on the open-source small model Qwen3.5-27B (supervised fine-tuning plus reinforcement learning); paired with an executor agent swapped to the open-source Qwen3.5-122B, Terminal-Bench accuracy rose from 37.6% (the open-source executor model's own baseline, which happens to match Sonnet 4.5's baseline) to 41.1% — a 3.5-point gain, smaller than the version using Claude Opus 4.6 as the memory agent.
  • The code repository named in the paper's body text was verified to be an empty repo (0 bytes, never pushed to since creation), and as of July 13, 2026 has not actually been open-sourced.
1 What it is · Why it's worth reading

What Meta AI just released

Meta AI's research team published a paper on arXiv on July 9, 2026, proposing that agents executing long-horizon tasks be paired with a "proactive memory agent" whose sole job is deciding when to speak up and when to stay silent.

The approach delivers a counterintuitive result: pairing the weaker Claude Sonnet 4.5 with the memory agent lifts its accuracy on the long command-line-task benchmark Terminal-Bench 2.0 to match the more expensive Claude Opus 4.6 (also paired with the memory agent) — and even surpasses Opus 4.6's own unpaired score.
📊
The hard numbers: On Terminal-Bench 2.0, Sonnet 4.5 with the memory agent scored 45.9%, tying Opus 4.6 with the memory agent (also 45.9%), and beating Opus 4.6 running solo at 43.5%. In other words, a cheap model plus this memory agent matched the performance of a pricier one.

All authors on the paper are from Meta AI. The problem it sets out to solve is specific: when an AI agent runs for hundreds of consecutive steps on a long task, it often "forgets" rules it should have kept following, even when that information is sitting right there in the conversation history. Let's first look at the problem itself.

2 The problem

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.

An analogy

It's like plastering an entire wall with sticky notes. You remember each one clearly when you post it, but once there are too many, you stop looking up at the wall at all. The words are still there — they just no longer shape what you do in the moment.

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":

Step 2 · Noted
Rule: IP segments can be a single digit
Step 4
Rule still on record
Step 6
Rule still on record
Step 8 · Fixing another bug
New regex misses single-digit segments
Result
✗ Violates its own earlier requirement

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

①A requirement is discovered early, then later violated while fixing an unrelated bug.
②A command, parameter, or implementation path was already tried and failed — and later, a near-identical variant gets retried anyway.
③An error pattern was already diagnosed, then later gets treated as a brand-new problem and handled from scratch all over again.

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."

3 Method · Core idea

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.

Executor agent
⇄
Environment
→woken every step
Memory agent
(sees last 8 messages)
→injects reminder
Next-step decision

Swipe left/right to see the full flow diagram →