Every session makes the next one smarter.

Fifteen thousand notes, and most are not about code.

The map below is our company's memory. The biggest region is how we build: 2,477 notes on our servers, our code and the things that broke. Around it sit the market (2,388), our strategy (1,612), the banks we sell to (1,438), our films (829) and seven more subjects. Agents wrote them while doing the work.

The idea behind it is simple. What one agent learns, every agent should know. A fix found on Monday should save Tuesday's session an hour. A lesson from last week's film should shape this week's edit. Knowledge should compound instead of scrolling away with the transcript.

Without it, every session starts from zero.

Coding is where this hurts first, because coding is where agents do the most work. Our web app runs on a server with 4 GB of memory. Building the app on that server once ran it out of memory and took the site down. An agent wrote the lesson down: never run the production build on the 4 GB box.

Later, a fresh session got the obvious question. Same model, same repository. Here are both answers, word for word.

The note existed. Nothing read it. A memory file helps a little, but Claude Code loads only the first 200 lines of one. A folder of fifteen thousand notes is no use unless the right one is in front of the agent at the moment of the question.

So we built a loop around the notes.

Claude Note is our fix, and it is free and open source. It hooks into Claude Code and Codex and records your prompt, each tool the agent calls, and the end of every turn. When a session ends, a background worker gives the transcript to Claude, which writes what was learned as plain Markdown notes in a folder you own.

Every note gets a type, because the type decides when it is useful:

Notes grow instead of being rewritten. When a later session learns more, the worker appends a dated section. Once a day each laptop sends its shareable notes to the company vault, and every night a merge on our server compares each one with what the team already knows and makes exactly one move.

Secrets are stripped before any model sees a note, and a merged note is never visible to more people than its sources were. Then comes the half that matters most: before the model sees a prompt, recall searches all of it and puts the best notes in front of the agent.

Code is where it pays first. It does not stop there.

The same loop runs for everything the company learns. These are real questions from our evaluation set, each written in the words of someone who had never seen the note, and the note recall puts first:

Recall searches before the model answers.

Recall runs on every prompt, before the model sees it. It searches the notes two ways at once: by keywords, through a ladder of shorter and shorter queries, and by meaning, so a question can find a note that shares none of its words. Then a small reranking model orders the best candidates, and the top four go into the agent's context with their file paths. When nothing is close enough, recall says so instead of guessing.

When a command fails

A second hook, the sentinel, reads the output of a failed shell command and searches for its error codes, like insufficientPermissions or ENOSPC. For failures that never fix themselves, such as an expired login or a full disk, it tells the agent to stop retrying.

Watch it work.

We filmed it. Asked the build question again, Claude Code found the note and said no. Codex did the same, and linked the note.

Installed is not the same as working.

One week our map turned one colour. A cut-off download of the embedding model had turned 992 notes into numbers that meant nothing, and for five days every refresh logged "OK". Nothing had crashed. The memory had simply stopped working, and nothing said so.

So Claude Note measures itself. Claude writes questions from your own notes, each in the words of someone who had the problem but had never seen the note. The note a question came from is its answer, so recall never grades itself. Half the questions are held back for reporting, so nobody can tune their way to a good number. On our vault, with 36 held-back questions and 15 that have nothing to do with it:

Three things get it there. A clean index from QMD 2.8.3, the local search engine underneath. A small server that keeps the models warm, so one local request runs the whole keyword ladder and the search by meaning. And a small reranking model for the shortlist, with a floor: if even the closest note is far in meaning, recall injects nothing. Every setting was chosen on half the questions and checked on the other half. Without the reranker, recall answers in a third of a second and finds the right note 58% of the time.

Finding the note is only half of it. The answer has to use it. We put 10 held-out questions about our own decisions and gotchas to Claude twice, once with recall and once without. A judge saw the note and both answers, unlabelled and in random order. With recall, the answer followed our note 7 times out of 10. Without it, 2 times. Shown an unrelated note, the judge said "neither" every time, so it was reading. Ten questions are a small test, and we will keep running it.

The evals ship with Claude Note. The same report comes out as JSON, so an agent can read where recall is failing and fix the notes itself. That closes the loop: the system that remembers also checks that it does.

Install it, then prove it works.

You need Python 3.11+, uv, QMD 2.x and the Claude CLI. Setup backs up every file it changes, and --dry-run shows what it would do first.

When you learn something the hard way, write it down on the spot. The next prompt, yours or another agent's, starts from it:

Tomorrow's session starts with today's lesson, and now we can see whether it did. Claude Note is MIT licensed. Source, docs and the recorded runs from the film are on GitHub.