Your Session Survives a Compaction
Long agent sessions get compacted, and the summary usually throws away what you were in the middle of. Curator now puts the working thread back the moment a session compacts, so the agent keeps its footing instead of going blank.
Run an agent long enough on one problem and the context window fills. To keep going, the client compacts the session: it summarizes the conversation so far and continues from the summary. The summary keeps the shape of what happened. It rarely keeps the part you actually cared about, which is whatever you were in the middle of when the window ran out.
The agent does not announce that it lost the thread. It keeps talking, confidently, on top of a summary that quietly dropped the decision you just made, the standard you just reaffirmed, and the approach you rejected an hour ago. Compaction is the moment a long session goes blank without telling you.
What a compaction costs you
A good summary preserves the gist and sheds the detail. That is exactly the wrong trade for coding work, where the detail is the point. The mid-edit call about how a file gets touched, the reason you steered the agent off its first plan, the pattern you told it not to repeat: those are precisely the things a general summary treats as noise and cuts. What survives is a tidy recap of the topic. What is gone is the working state you were operating from.
So the second half of a long session runs on stale footing. The agent picks up the thread it thinks it had, not the one you actually left, and you find out when it re-proposes something you already rejected before lunch.
Recall that fires on compaction, not just on resume
Curator already runs a resume diff when you come back to a project after time away, so the agent starts from current-you instead of the version of you that wrote the old code. Compaction is a new trigger for the same instinct. The difference is that it fires in the middle of a live session, not at the start of the next one.
The moment a session is compacted, Curator puts a bounded recall block back in front of the agent. It surfaces three things: what this session was doing, captured as its key moments; what has changed in your standards since you last touched the project; and the decisions you marked durable enough to keep. It is on by default, so you do not have to remember to ask for it at exactly the moment you are least able to.
To be clear about what this is not: Curator is not snapshotting new memories into the store when the window fills. Nothing new gets written at compaction. It surfaces what already lives in your memory and re-injects the slice that matters right now, so the summary does not get the last word on what your session knew.
The working thread comes back
The result is narrow and practical. After a compaction the agent does not restart from a polite recap of the topic. It picks up mid-thread: it knows what this session was doing, it edits the way today’s standards say it should, and it honors the durable decisions instead of rediscovering them the hard way. The failure mode where a long run gets duller right when it should be hitting its stride stops being the default.
None of this depends on you noticing the compaction happen. That is the point. The one moment you are guaranteed not to be watching for lost context is the moment the client decides to compress it, so the recovery has to be automatic.
Where it stands
Compaction recall shipped and is on by default. Curator is a working pre-release product that runs on your own machine, close to where the edits happen, and reaches your agent over MCP. It remembers for Warden and TheAuditor, shares a brain with Arbiter, and answers to the same proof discipline as BenchProctor. Read resume with what you know now for the trigger that runs when you return to a project, or follow release preparation.
Was this useful?