An agent shouldn't compress its experience before it knows what it will need.
Most memory systems decide what to remember the moment a task ends — long before the next task is known. MemCurator keeps past experience whole and does its thinking later: when a new task actually arrives, it writes a short, tailored briefing for that task from the raw history.
LLM agents are increasingly asked to handle a stream of tasks over time — resolving support tickets, navigating websites, operating tools — rather than one isolated problem. An agent that starts from a blank slate on every task throws away its single most valuable asset: everything it just learned doing the last one.
Agentic memory is the machinery that fixes this. It keeps something from past experience — a note, a reusable skill, a full transcript — and pulls it back up on future tasks so the agent gets better as it goes, without retraining the underlying model. The open question isn't whether to remember. It's when, in the agent's lifecycle, to decide what a memory should say.
THE DESIGN SPACE
Three moments to shape memory
There are really only three moments in an agent's lifecycle where it can decide what a memory should say. Almost every prior system picks the first — MemCurator moves to the second.
WRITE-TIME
Before the task
ReasoningBank · SkillOS · MemP
The agent distills a note the instant a task ends and files it away for whatever comes next.
★ MemCurator
READ-TIME
When the task arrives
MemCurator
Raw experience is kept whole; a learned curator distills it only once the new task is known.
WIP
TURN-LEVEL
When the state demands
MemGuide
Guidance is re-decided at each step, against the agent's live state.
the agent's timeline →
THE PROBLEM
Curating in the blind
Almost every system today picks that first moment — write time — committing a note before anyone knows what the next task will be. It is guessing which fragments of today's experience will matter tomorrow, and two costs follow directly.
First, information loss is premature and permanent — whatever gets dropped is gone, and a later task that needed it can't recover it. Second, a single stored note has to be one-size-fits-all: the same web-browsing trace might teach one task a shortcut and warn another about an error, but a write-time note can only say one of those things. And because a stored note is only "graded" much later — if and when a matching task ever shows up — the signal for learning good curation is delayed and hard to attribute.
THE IDEA
Curate just in time
The fix is to wait for the second moment. MemCurator does its curation at read time: past task transcripts are kept whole — nothing is thrown away up front — in a passive store. When a new task arrives, a small learned model called the curator reads the most relevant past transcripts together with the task in hand and writes a compact briefing tailored to exactly that task. The same stored experience becomes a different briefing depending on who's asking — the property we call task-adaptive.
Two things fall out of this one move. Nothing is lost prematurely, because curation happens after the task is known. And the learning signal becomes immediate: the briefing is judged on the very task it was written for, so the curator can be trained on whether it just helped — no waiting many tasks for a delayed reward. Strikingly, even an untrained curator already beats the write-time baselines; training it on that immediate signal then compounds the gain.
Explore the demo
Jump into any part below.
How each mechanism moves memory
All the methods below use the same few building blocks, just wired differently. Pick one and step through its pipeline — the payload chip under the diagram shows the actual text handed to the model, so you can watch a fixed note turn into a task-adaptive briefing.
Taskthe new problem the agent has to solve right now.
Memory Bankthe store of past experience — notes, skills, or full transcripts.
Retrieverlooks up the entries from the bank most relevant to the situation.
Curatorthe learned model that decides what the memory should say.
Executorthe frozen model that actually acts on the task. Never changes.
Trajectorythe transcript of a finished attempt — what was seen and done.
One trajectory, two tasks — why read time matters
This is the payoff of curating at read time. A single stored trajectory becomes a different briefing depending on the task that retrieves it — something a fixed write-time note can't do.
Results
Success rate across three benchmarks and three frozen executor models.
WORK IN PROGRESS · no headline results yet — this is the direction we're building next
MemGuide — curation at the right read times
MemCurator does its curation once, at the start of a task. But on long, multi-step tasks the agent's needs change as it goes — the briefing written at step 0 was conditioned on nothing that happened since. MemGuide extends the same idea along the time axis: instead of one briefing up front, a learned policy decides at every turn whether fresh guidance is needed, what to pull from memory based on the live situation, and how to phrase it.
THE GAP
One briefing, fixed at the task's start, decays three ways as the episode unfolds:
Stalenessit was conditioned on zero observations
Decayit loses influence as the trajectory grows
Mismatchthe useful memory is state-similar, not task-similar
THE METHOD
So MemGuide replaces that one briefing with a policy that re-decides at every turn, across three heads:
GATEwhether to intervene now
QUERYwhat to retrieve, keyed on the live state
CURATEhow to phrase it — or stay silent
WHY IT MATTERS
Same briefing, different turn — on τ²-bench telecom, timing alone moves success:
0.404at task start
→
0.600at the best turn
A start-only briefing — what MemCurator does — can't reach that best turn. On a long task the moment guidance matters most is somewhere in the middle, and a learned per-turn gate is what lets memory arrive there.
+0.20 from timing alone — the content is identical; only the turn it arrives on changed.
How to read these numbers. Both inject the same MemCurator briefing on τ²-bench telecom; the only thing that changes is when it arrives. At task start (0.404) is MemCurator's read-time injection — once, on the opening turn. At the best turn (0.600) is an oracle that delivers the identical briefing at the single most useful turn of each episode. Because the content is held fixed, the gap between them isolates one thing: the value of timing.
And timing is worth a lot — more, here, than the content itself. For reference, no memory at all scores 0.290: so injecting the briefing at the start helps (+0.11 → 0.404), but delivering that same briefing at the right turn helps even more (+0.20 → 0.600). On a long task, when guidance arrives matters as much as what it says — and a start-only briefing, which is what MemCurator does, leaves that timing headroom on the table. Capturing it is exactly what MemGuide's learned per-turn gate is built to do.
Live demo — Trajectory Lab recorded
Pick a task, then compare memory methods on it. Each method's real recorded run plays out below — the curated memory it received, then the agent's turns and the outcome. Switch methods to see where task-adaptive memory changes the result.