Skip to main content

One memory per workspace

A workspace is one project folder on one computer. In a new project, nemonist asks your agent to create .nemonist/key at the project’s root, usually in its first turn and sometimes in its second; that file links the project to its memory, and turns before it exists have no memory. Notes appear as your agent learns, usually after a correction or a convention you ask it to remember. Every chat in that project, in any client and with any model, shares the same memory, so what one chat learns the next one knows, even after a new chat starts or the client summarizes the conversation.
  • Keep .nemonist/key. Deleting it erases nothing. With .nemonist/config still there, the next chat writes a new key for the same memory by itself (with another API key, it shows a code to approve at nemonist.com/link). Deleting all of .nemonist/ in a project whose .nemonist/config is committed to git loses nothing either: your agent reads the committed config (git show HEAD:.nemonist/config), recreates the files and reconnects the same memory (with another API key, it shows a code instead). Without a committed config, deleting both files starts a new, empty memory, and your agent says so; the old one stays until you erase it (below). To get it back, restore .nemonist/config from git or a backup and delete the new .nemonist/key, or issue a key from the old project’s Settings (Lost .nemonist/key? Issue a key). See Troubleshooting.
  • A copy shares the memory. A copied, restored or renamed project keeps .nemonist/key, so it reaches the same notes. The first chat in a copy says so and asks whether to share or give the copy its own memory. Answer it (or ask your agent for a separate memory for this copy): the agent replaces .nemonist/key and .nemonist/config in the copy with a new key and folder that nemonist issues, and the original keeps its notes. Do not split by deleting the two files: in a project whose .nemonist/config is committed, the next chat reconnects the shared memory from git.
  • A copy without .nemonist/ gets a new memory. A copy that left out dot-folders (a tar or zip export, a sync that skips hidden files) has no key, so its first chat creates a new, separate memory, empty of the original’s notes. That chat’s reply ends with a line from nemonist saying so. To use the original’s memory instead, copy its .nemonist/key and .nemonist/config into the copy, or issue a key on the original’s Memory page (Settings, Issue a key).
  • Keys stay out of replies. If a reply would show a whole nmk_ key, nemonist shows only its last four characters (nmk_...1a2b), followed by a note that it is shortened and not the whole key. The file .nemonist/key itself is unchanged. To use the memory on another computer, copy .nemonist/config there (or commit it) and the agent writes a key by itself, or issue one on the Memory page (Settings, Issue a key). If a shortened key was pasted into .nemonist/key, the agent replaces it with a working key for the folder .nemonist/config names.
  • Keep it out of git, and commit .nemonist/config. The config names the project’s memory folder and is not secret. A clone of your project on another computer, with the same API key, finds the same memory through it: your agent writes a new .nemonist/key there by itself. With another API key (a teammate’s), the agent shows a code to approve at nemonist.com/link instead. To share notes across a team, use team memory.
  • Nothing to install. Your client sends its usual requests; nemonist adds the memory on the way and the reply comes back as the client expects.

How it learns

Before it answers, your agent reads the notes that bear on the task. After your next message, it judges how the last turn went (a correction, a repeat, an error or a success) and rewrites the notes that led there. Your agent writes these notes itself, so the lesson sticks across chats. Reading notes or learning from a turn sometimes takes a short extra round with the model before the reply. It is charged at the provider’s price like any other round and shows in Logs with a memory badge. See Models and pricing.

See what your agent remembers

The Memory page in the dashboard lists each project. Open one to see what your agent remembers and has learned, in tabs:
  • Notes, Goals and Judgments: the files your agent writes, its work items, and how it judged each turn. Your agent writes the notes; you can Forget a piece of text in a note and its history.
  • Goals has Table and Board views, as a GitHub Projects board: one column per state, stage or last progress, each with its count, and a card per goal with its last progress, judged turns and when it last changed. Open a card to see the goal in a side panel. The view, its State filter and its sort are in the page’s URL, so a link reopens the same view. Only your agent moves a goal, with evidence.
  • Measures: whether your agent is learning. Corrections and repeats per 100 judged turns (with the first half of the project’s turns against the second), misses that led to a note, misses memory already held, and memory size against its budget. By week shows corrections and repeats per 100 judged turns for each week, oldest first, so you can see whether you correct your agent less often than you did.
  • Files and Jobs: files you upload for your agent’s compute jobs (open, copy the nm-file line, or delete one for good), and each job with its outputs.
  • Inbox and Requests: messages sent to the project from Slack or the API, with the reply each got, and every request your agent made here. Open a request to read it exactly as your client sent it.
  • Tools, Spend and Graph: server-side tool calls and errors, this project’s charges, and how notes, turns and judgments connect.
  • Settings: rename the project, issue or revoke its keys, write its charter (your own rules, which only you change), connect Slack, turn on nightly sleep, merge it into another project, export it, pause or delete its memory. Its history lists every change to keys, name, merges and uploaded files for a year, with Undo for a key or a rename.
A project is named by its folder unless you Rename it, or by its files if you turn on Don’t record project folder names under Privacy. Nightly sleep never edits notes by itself. Each night it looks for lessons never written down, files over budget and notes unread for 90 days, and leaves your agent one open work item proposing what to merge, trim or learn. Your agent decides on its next turn. From code, GET /memory-file returns one project’s files and its latest memory reads and edits, named by the contents of its .nemonist/key. The folder endpoints do what the Memory page does with your account’s API key alone.

Forget and erase

  • Forget one thing. Ask your agent to forget it. It removes the text from its notes and their history. The requests that mentioned it stay with your account until you erase everything.
  • Erase a project. Settings on its Memory page, or DELETE /folders/{id} with your API key. Deleting .nemonist/key only unlinks it.
  • A key someone issued to you. You need no account: with that key, GET /folders lists the projects it holds, GET /folders/{id}/export shows one, and DELETE /folders/{id} erases it. A key issued with Separate memory reaches only its own projects; the account that issued it also sees and can erase them on its Memory page, tagged with the key’s name.
  • Erase everything. DELETE /memory erases every project’s memory under your account. Deleting your account from Settings erases it too.
  • Export. Settings exports one JSON file with your profile, API keys (no secrets), usage history and all memory files. A project’s own Export JSON has its notes with their edit history, work items and every judgment; uploaded files, job outputs and recorded requests download from their tabs.

Team memory

On the Teams and Enterprise plans, workspace members can share notes their agents write under team/. It is off by default: an owner or admin turns it on for a workspace in Workspaces settings, then members opt in one by one. An owner or admin can erase a piece of text from a team file and its history for every member. Every change to a team note, and who made it, is in the organization’s Audit log.

What it works with

Memory works on chat completions, Responses and Anthropic Messages requests from coding agents (requests that send tools). Other requests are answered exactly as OpenRouter would answer them. How reliably an agent uses its notes depends on the model.