Memory

Memory is what Lookout keeps between chats: your preferences, and facts about a project. A new chat starts with the list of what is remembered; longer details stay in their files until the agent reads them.

Memory has two scopes:

• Everywhere: yours, in every project and every agent, on every machine signed in to your Lookout account.
• A project's own: only in chats in that project, on every machine with a clone of its repository.
• An agent's own: only in that agent's conversation. Whatever an agent saves or learns stays there, so one agent's role or notes never reach your coding chats or another agent.

An agent's Controls can keep Everywhere out of its conversation (Read Everywhere memory) and stop Lookout learning from it (Learn from its chat).

Each scope is a folder of Markdown files under ~/.lookout/, outside your project folders: a MEMORY.md list, plus a file for each memory with details.

A project's memory belongs to its git repository, not to the folder's path: every clone and worktree of one repository on a machine shares it, wherever it sits. A folder outside git keeps a memory of its own. When a project's memory first moves to its repository, two copies of it merge with nothing lost: each memory once, and of two versions of one topic the newer stays while the older goes to Forgotten (See and change what is remembered).

Save a memory

• Ask the agent. Say "remember that the staging deploy needs the VPN". The agent saves it to the project. A save meant for Everywhere asks you first: a card in the chat offers Save everywhere, Save to this project and Don't save, and nothing is written until you pick. Settings › Memory › Save Everywhere memories changes who may save there: Ask me, Only me (an agent's save goes to the project instead), or Agents may save. An agent's forget of an Everywhere memory goes through the same setting: under Ask me a card shows the memory as it reads now and nothing is forgotten until you pick Forget everywhere (or Keep it), and under Only me the agent can't forget one.
• Write a note. Start a message with # to note it for this project, or #! for Everywhere. The note is saved word for word, no turn starts, and the message says where it went.
• Add it in Settings. Open Settings › Memory and click Add memory.

# The API tests need Docker running
#! I prefer small pull requests

A note is 3 to 400 characters. Lookout refuses a memory that looks like a password, key or token: save where the secret lives instead, such as the name of the variable that holds it.

Learn from chats

With Learn from chats on, Lookout reads a turn after it ends and keeps the preferences and project facts it picked up. It runs after a turn that did real work (at most once every 10 minutes in a chat), on the chat's own model. To have something kept at once, ask the chat to remember it, or write a # note. What it learns lands in that chat's own memory (the project's, or the agent's in an agent chat), never Everywhere, and Settings lists it as Learned. It can also forget a memory the turn proved wrong, or one you asked it to forget. A memory you wrote yourself is different: Lookout changes or forgets it only after a turn in which you spoke of it, such as "we moved off yarn, the yarn note is out of date". When the agent or Lookout rewrites a memory, Settings says so (edited by Lookout). Only what you type in Lookout is you speaking. A message one of your agents, another chat, or an app such as Claude Code sent (its row names the sender) never changes your own memories, nothing from it lands in Everywhere, and what Lookout keeps from it says who said it. A note such a sender saves is listed By the agent, not by you.

When a project's or an agent's memory gets crowded, Learn from chats also tidies it, at most every 6 hours: it merges memories that say the same thing and forgets task status, to-dos (runs or checks still owed) and what a newer memory contradicts. A memory that also holds a lasting fact, such as a decision or a measured result, is rewritten without those parts instead of forgotten. Each pass reads the memories changed or not read since the last one, oldest first, so a large memory is read whole over several passes; a merged memory keeps the date of the newest one it came from. When the list is within 10 of its 200 limit, a pass reads more of them, starting with those that have a close match, and brings it to about 180. It only merges memories about one subject, and forgets ones whose dates have passed. It may also forget a memory whose work has landed, when the pull request, commit or doc that memory names records it. The details a later task still needs and the pull request lacks move first, in up to three lines with the pull request number, into the memory about that feature; a memory with more stays. The same holds for any memory with measured numbers: it is forgotten only when the record it names holds them, or once they move into the memory about its subject. A memory with a run still owed today or later stays. It never lumps different subjects together to shorten the list. A merge can carry a memory over word for word. What it takes is listed in Forgotten. It never tidies Everywhere, and never a memory you wrote yourself.

An agent may also edit a memory file directly (with a file tool or the shell). Lookout then does what a save would: the memory's date moves to that day, the text it replaced goes to Forgotten, Settings says the agent edited it, and a password, key or token written that way is taken back out.

Turn it off in Settings › Memory. Use memory turns memory off altogether: new chats start without it, and what is saved is kept. Both are on until you change them.

See and change what is remembered

1. Open Settings › Memory (⌘,).
2. Pick whose memory in the scope menu: Everywhere, a project, or an agent under Agents. The page opens on the project or agent of the chat in view.
3. Search, show only what was written By you, By the agent or Learned, and sort.
4. Click a memory to edit it in a dialog, change where it Applies, see which chat it came from and open its file. Add memory opens the same dialog, and the trash beside a memory forgets it. To share an agent's memory everywhere, open it in that agent's scope and pick Everywhere. An Everywhere memory an agent's chat wrote offers Only with that agent's name, which moves it to that agent's own memory.

A memory forgotten in any way (by you, by the agent, or by Learn from chats) is kept for 30 days: Forgotten lists it with who forgot it and when, and Restore puts it back where it was.

Open chats learn of your edits and forgets at their next message; what other chats save or Learn from chats changes reaches a chat when it starts. The eye beside the search, See what’s sent, shows the exact text a new chat starts with; a memory past what a chat is shown reads Not sent. The folder button opens the scope's folder.

On every machine

Your Everywhere memories are the same on each of your machines: the Mac, and each server you added to your Lookout account, including one that runs your agents. A memory saved or forgotten on one reaches the others within a couple of minutes, without a click, and opening Everywhere in Settings › Memory brings it up to date at once. A memory forgotten on another machine is in Forgotten here too, so it can be restored. They sync through your account's vault, as your provider sign-ins and connectors do.

Each memory keeps who wrote it, so one an agent wrote says Saved by with the agent's name on every machine that knows the agent.

When the same Everywhere memory changed on two machines before either heard of the other, the page says so above the list, and each machine keeps its own until you pick: Keep this machine’s sends this one to the others, Use the other machine’s takes theirs. The rest of your memories keep syncing meanwhile.

A project's memory follows its repository to each of your machines too: a chat on the Mac and a chat on a server in clones of one repository read and add to the same project memory, even while the other machine is off. It syncs every couple of minutes, or at once when you open Settings › Memory. When both machines changed the same memory before either heard of the other, the newer version stays on both and the older one goes to Forgotten on the machine that met both, so nothing is lost and nothing waits for you. A forget on one machine reaches the others, in their Forgotten too. Your account keeps each project's memory sealed: it can't read it or tell which repository it belongs to. A project memory too large to share (over 1.5 MB, far past what a project holds day to day) stays on its machine until you forget some of it. A folder outside git, and an agent's own memory, stay on their machine.

Export and import

The export button (Export memories) saves a .zip of memory folders: the project or agent in view, Everywhere, or all memories, each agent's own included. As git repositories makes each folder a repository ready to push. Importing an export of all memories puts each agent's memory back into that agent only, never Everywhere or a project.

The import button (Import memories) adds memories to the scope in view:

• Import a folder: any folder with a MEMORY.md, such as one Lookout exported or another agent's memory folder.
• Import a .zip: a memory export.

A memory that is already there is skipped, and the result says what came in and what was left out.

Limits

• A scope's list holds up to 200 memories in 6 KB, and up to 128 KB with details. The page shows how full it is; when a scope is full, new memories are refused until you forget some.
• A new chat is sent each list, newest first, up to 6 KB. Older memories past that, such as after a hand edit of MEMORY.md, show Not sent: the agent reaches them only by opening the file.