Memory Engineering 101: our approach to building a company brain.

Fifteen thousand notes, and most are not about code.

The map above shows what our agents have learned so far, one dot per note. An agent here is an AI model that does real work for us: it writes code, researches a market, edits a film. Each note was written while the agent worked, and notes about the same thing sit together.

The biggest region, 3,489 notes, is how we build: our servers, our code, the things that broke. The rest is the company: product research, the market, our strategy, our films and more.

The idea 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, not scroll away with the transcript.

Agents need memory.

Every session starts blank. The model knows the world, but not your servers, your decisions or what broke last week, so it gives the generic answer. Coding is where this hurts first, because that is where agents do the most work.

Here is one case. Our agents search their notes with QMD, a local search engine. Its best-quality mode, qmd query, loads a 1.28 GB model before every search. Once, an agent ran it in the middle of a task: it hung for 54 minutes and our server stopped answering. An agent wrote the lesson down: never run qmd query inside an agent turn or a hook.

Later, a fresh session was asked: "Our recall hook uses qmd search. Can I switch it to qmd query to get better results? Two short lines." Same model, same empty project. One session had recall, the hook that puts the right note in front of the agent before it answers, and one did not. Here are both answers, word for word.

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

So memory is three jobs, not one. Capture what a session learned, without anyone stopping to write it up. Compound it, so notes from many sessions and many people become one body of knowledge, not a pile. Recall the right note before the agent answers.

One way to do it: capture, compound, recall.

Our agents do all three with Claude Note, which is free and open source. It adds hooks, small scripts that run at fixed moments, to Claude Code and Codex, and records your prompt, every tool call and the end of each turn. When a session ends, a background worker hands 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. Every night a merge on our server compares each note with what the team already knows and makes exactly one move per note.

That is capture and compound. Recall, the third job, decides whether any of it gets used: before the model sees a prompt, it searches every note and puts the best ones 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. Here are three real questions from our evaluation set, each written in the words of someone who had never seen the note, with 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. One is by keywords, through a ladder of shorter and shorter queries. The other is by meaning, so a question can find a note that shares none of its words. A small reranking model then 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 the notes for its error codes, such as insufficientPermissions or ENOSPC. Some failures never fix themselves, an expired login or a full disk among them, and for those it tells the agent to stop retrying.

Watch it work.

We filmed it: the same qmd query question, the recall behind the answer, and how it measures itself.

Does it work? It measures itself.

Memory fails quietly. Ours did once: a cut-off download of the search model turned 992 notes into numbers that meant nothing, and for five days every refresh logged "OK".

So Claude Note checks 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 key, fixed before recall runs, so recall never grades itself.

Questions are split by source note, so no note sits in both halves, and half are held back, like an exam paper the settings never saw: every setting was chosen on one half and reported on the other.

On the held-back half, recall put the right note among the four it injected for 28 of 36 questions. The full results from our vault on 12 October 2026, with 15 more questions that have nothing to do with our notes:

Read the ranges, not just the headline. Thirty-six questions is a small set, and a repeat run of the same setting scored 81%. The answer test is smaller still, at ten questions. A judge saw the note and both answers, unlabelled and in random order, and picked the one that followed the note. The judge is Claude, the same family as the agent it grades, so we gave it a control: shown an unrelated note, it said "neither" 10 times out of 10. Ten questions do not prove the gap, so we keep running the test.

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. The system that remembers also checks that it does.

What stays private.

Memory that reaches every agent can also spread a secret or a wrong note to every agent. Here is what Claude Note does about that today:

Inside our company, a merged note is never visible to more people than its sources were. The notes you can open in the map above faced stricter checks before we published them: a keyword screen, a read by hand and two independent reviews.

Enable it for your own agents.

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

Recall runs on your machine and adds 2 to 3 seconds to each prompt (a third of a second with rerank = false). Writing notes costs one Claude call per finished session, on your own plan.

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

Claude Note is MIT licensed. Source, docs and the recorded runs from the film are on GitHub.

Tomorrow's session starts with today's lesson, and now we can see whether it did.