The note kept the verdict
My assistants remember through small notes. The notes remember what I concluded, and that turns out to be the least useful part.
A paper this week tested something I had been living with for months. Agents that summarise their experience when a task ends, and store the summary, did worse than agents that keep the raw record and build a compact, task-specific summary only when a later task needs it. The gap was about sixteen points on two of the three benchmarks. My own assistant setup is built entirely on the first approach: at the end of a session, the useful facts go into short notes, one fact per file, with an index that loads at the start of the next session. It works well. It also let a single word stay wrong for five weeks.
What a summary is for
A note written at the end of a session answers the question the writer had in mind. It keeps what looked important then and drops everything else, because a note that keeps everything is a transcript and nobody loads a transcript at the start of every session.
The problem is that the next task asks a different question. The paper's setup makes this measurable: when the curation happens at read time, with the raw trajectory still available, the reader can pull out what matters for the task in front of it. When the curation happened at write time, whatever the writer cut is gone. The authors report that even an untrained curator at read time beat the strongest write-time memory system they compared against.
A summary answers the question its author was asking. The next task is asking another one.
One word, five weeks
In a client automation in August, I added a field to a data structure so that a daily report could tell record types apart. At the end of that session the note said the field was in place and verified.
Five weeks later, while fixing something unrelated, it turned out the field had never been part of the structure the records actually used. It was invisible in every record. The note had carried the word "verified" through dozens of sessions, and every one of them trusted it, because the note did not say what had been checked. Had it said "pushed, then read back one record, field present", the gap would have been obvious: that check had never happened. What had happened was that the push returned success.
The note had kept my verdict and dropped the evidence for it, and a verdict without evidence reads exactly like a verdict with evidence.
The same thing, one level up
It happens with plans too. This month I misread a plugin's status screen as proof that a client had no search console. That reading went into a planning document. Weeks later, in a new session, the plan was loaded as context and the misreading came back as a premise. I made the same mistake twice, and the second time I did not make it, I inherited it.
Every layer of summary does this. A handoff summarises a session, a plan summarises several handoffs, a status report summarises the plan. Each step keeps conclusions and drops the path to them.
What a note should carry
- Notes store the check next to the claim: what was run, what came back, and where the raw output lives. A note that says "verified" without saying how counts as unverified.
- Raw material stays. Meeting transcripts are synced daily into plain files, run logs are append-only, and nothing in the note system replaces them. The notes point to them.
- Every note is loaded with a reminder that it is a point-in-time observation. Anything that names a file, a function or a setting gets checked against the live system before it is used as a fact.
- Reading is where curation should happen. For a real decision, the assistant should go back to the log or the transcript and build its own summary for that question, instead of trusting the one I wrote for a different question weeks ago.
It costs a few seconds per note and some disk space. The paper's numbers suggest it also costs less than the alternative.
Store the evidence, not the verdict. The reader decides what matters, because the reader knows the question.

