Global memory
An agent-written memory library the agents can browse, search and add to — modelled on Omniscio's own docs system but live: a budget-aware tree a session can load at the size it wants, memories an agent writes from its own work, and comprehension search.
On this page
What it is
A progressive-disclosure, agent-written memory library built on the Context Dock native store —
modeled on Omniscio's own docs system (CLAUDE.md → MEMORY.md → topic files), but live and
agent-facing. Milestone 1 is the read path (browse a budget-aware tree + load any memory at the
size you choose); Milestone 2 is the write path — agents remember from their own work; and
Milestone 3 adds search — find memories by meaning + keyword. It is gated off by default
(globalMemoryEnabled / the global-memory unreleased feature). The engine is agent-facing (CLI
routes + first-message injection); a user-facing Memory panel under Agent Tools (desktop) is the
one place to see and edit what the agents remember — see The Memory panel below.
The idea
- A memory is just a Context Dock store doc — it already has three compression levels (full / medium / short = original / keyPoints / summary), a per-level token count, a one-line summary, and tags. Nothing new is stored.
- Memories are organized into a tree: fixed top branches (About You / This Project / People) → tag-groups → memories. Every node shows how many memories it holds and what they'd cost to load at each level, so the agent only drills in when it's worth the tokens.
- Groups are keyed on a standard set of 17 tags (merge, testing, git, cloud, bug-fix, …) rather than whatever tag the model happened to invent — see How the tree groups.
- A tiny always-loaded root map is injected into each session's first message (when on), so the agent knows memory exists and how to reach it — capped (~6k tokens), and nothing at all when off.
Where to find it
The Memory panel (see + edit your memories)
When the system is on, a Memory item appears in the left sidebar under Agent Tools (desktop). It's the one place you can look at everything the agents have remembered and curate it:
- A searchable list of your memories on the left; click one to read it at any level (full / key points / summary) on the right.
- Edit a memory's tags or delete one you don't want kept — it reuses the ContextDock Library's detail pane, so it's familiar and consistent.
- It shows ONLY the agent-written memories (rows minted with a
mem_id), never your imported course/curriculum docs — those stay in the ContextDock Library.
It reuses the ContextDock-native store under the hood (no new data, no new backend — just a widened
access gate so the panel works with only Global Memory on), and it's desktop-only for now (the
local store isn't wired to the mobile bridge yet). It's part of the same global-memory feature, so
it stays hidden until you turn Global Memory on.
Deleting a memory erases its words. Delete (here, from the CLI, or from the Project Manager's view below) removes the memory's text from this computer, not just hides it. Archive is the recoverable option.
When Global Memory is off: the Project Manager still remembers you
Once Mission Control is switched on, Omni keeps what it learns about you (how you work, what you prefer, your role) in About You, even while Global Memory is off. It keeps facts about the person only, never project notes or facts about other people. While Global Memory is off it saves only during the conversation itself; the end-of-session summary step stays off, so no extra copy of the conversation is sent anywhere.
- Only the Project Manager uses it while Global Memory is off. Other sessions, the Memory panel, search and the nightly tidy-up stay off. Omni conversations count as Project Manager sessions, the same as Mission Control ones, and a Project Manager session can still open its own notes with the switches off.
- What Omni reads when a conversation starts. Nothing is cut to fit a size limit. With the Context Dock off, Omni gets a table of contents of the About You folders and one line per note, each with its id, and opens any note in full on demand. With the Context Dock on, Omni gets the full text of the folders that fit the board item it was opened on (every folder when there is no item), and the rest one line each.
- Turning Global Memory on later is instant. It is the same About You store, so everything the Project Manager learned appears in the Memory panel at once, with nothing to copy.
- See and erase it any time in Settings → Mission Control → Omni's memory → What Omni knows about you (it shows the name you gave Omni). It is shown while Mission Control is on, and also after you turn Mission Control off if anything is still saved. Erase one item or erase all; erase also clears items the tidy-up archived.
- Each signed-in account has its own About You. Every memory about you is labeled with the Omniscio account that saved it, and each account sees only its own (plus older memories saved before this split, which stay visible to everyone on that computer). Project memories, people memories and Context Dock library documents are shared on the computer as before. The tidy-up job works only on the signed-in account's memories.
- Omni learns from your Context Dock library, except what you mark private. Everything in the library is on your computer, so Omni can read it through memory. A library document marked private stays out of Omni's memory everywhere: the memory map and search, the memory tools, the memory block a new session starts with, and the tidy-up job.
- Every feature saves what it learns about you here. About You is the one shared record:
- Mission Control setup answers (your role, how comfortable you are with AI, what you want help with) are kept as one note while Mission Control is on, marked From Mission Control setup. Omni reads your setup answers live, so it skips this copy; it is there for Tasks and the coach.
- Your week in numbers: after the daily close-out, with Tasks memory on, Tasks saves one short note per week (how much you finished against what you planned, your busiest days, and what keeps slipping). It is worked out on this computer with no AI call, and only for a week with at least three closed-out days.
- Your AI Coaching profile is copied here every time it is saved, marked From AI Coaching. Erasing your coaching data erases the copy's words too.
- Six person-shaped folders. About You files every note into one folder: How you plan and work, Your week in numbers, Your role and team, Goals and values, How you like to communicate, Your schedule and energy, or Other. A note's folder comes from the feature that wrote it (Tasks notes file under How you plan and work, for example) or else from its tags.
- Who sees what. With Global Memory off, each feature sees only the notes it wrote itself: Omni its own and the setup answers, Tasks its own, the coach its own. With Global Memory on, every feature sees every note, so Tasks AI and the coach also read what the rest of the app knows.
- Coaching notes stay on Anthropic. The coaching profile is handed only to Anthropic's own AI, on every way of reading About You (the start of a conversation, opening a note, search), unless you said yes for one specific AI company. Tasks asks once, the first time it would help Plan my day ("Use your coaching profile to plan your day?"): Yes sends it from then on, with nothing cut; Not now sends nothing and does not ask again. Take a yes back in Settings → Mission Control → About You.
- Tasks' "Learned about you" notes live here too. They are About You memories marked From Tasks in the settings list. With Global Memory off only Tasks reads them; the Project Manager's summary and search leave them out. With Global Memory on they help your other sessions like any other About You memory. Erasing one here removes it from Tasks too. Tasks is the only thing that changes their words: the tidy-up job never merges or files them away, and an agent's memory edit is refused with a note pointing to Tasks.
- How you want Omni to work. When you tell Omni a standing rule ("from now on, always ask me before moving dates on Hiring"), it saves the rule on the spot, even while Global Memory is off, and follows it in every later Omni and Mission Control conversation. Only a Project Manager session can save one. Each conversation gets the newest rules first, up to about 3,800 characters in all, and each rule is cut to 500 characters; rules past that are left out and Omni says how many it did not show, so erase the ones you no longer need. See, erase or clear them in Settings → Mission Control → Omni's memory → How you want Omni to work. They show up in the Memory tree as their own Omni branch, and the tidy-up and the summarizer never touch them.
- Stored only on this computer. The conversation itself still goes to the AI model you use, as every session does, so the wording is never "never leaves your computer".
How it behaves
How the tree groups
About You uses the six person-shaped folders above. The rest of this section describes the other branches (This Project and People).
Memories file under a standard tag, not the freeform one the model wrote. The model that writes a memory invents its own tags each time, so grouping on those directly shattered the library — on the real store (1,495 memories, 2,390 different tags) there were 713 top-level folders, and 522 of them held a single memory. A library where every memory is its own folder is one you can't browse.
So every tag is folded onto a closed list of 17 standard tags — merge, testing, git, cloud,
bug-fix, infrastructure, build, automation, process, tech-debt, security, ui, docs,
data, performance, i18n, preferences — plus a general catch-all. ready-to-merge,
auto-lander, rebase and merge-conflict all land in merge; verification, typecheck and
guard-lane all land in testing. On the same library that turns 713 folders into 18 — with no
single-memory folders left at all — and 95% of memories land somewhere meaningful.
Two things worth knowing:
- Nothing is rewritten. The fold happens when the tree is drawn, so your memories keep their specific tags for reading and searching — the standard tag is only the filing key. No migration, and the existing library regroups instantly.
- Both levels fold. When a group gets too big it splits by a second tag — folding that one too is what stops the mess from just moving down a level (734 single-memory subfolders became 25).
- A tag about two things files under the first one.
cloud-testingis both cloud and testing; it files under cloud because the leading word is what it's mainly about.
The Learning Loop's reviewer is also shown the standard list so new memories arrive already using it, but that's a nicety: the fold happens on read either way, so a model that ignores the list still files correctly.
What an agent sees + does
Five routes on the local control server (http://127.0.0.1:19519, bearer $AMC_CLI_TOKEN):
GET /memory/map— the branch map: each branch with its memory count + short/medium/full token cost.GET /memory/open?node=<node>— drill in.about-youlists that branch's tag-groups;about-you/authlists the memories in a group (each with id, one-line summary, tags, cost).GET /memory/load?id=<id>&level=short|medium|full— return one memory's body at the chosen level (falls back to an available level if the requested one wasn't generated; budget-capped via the Context Dock assembler).POST /memory/remember(M2) — write a memory mid-work; it's checked first, scoped (About You / this project / People), deduped against what's already stored, and linked to the current session. A save the check flags is held for the user and answers202withheld: true.GET /memory/search?q=<query>(M3) — find memories by meaning AND keyword (hybrid); returns ranked hits with their ids to then load. With Outside memory on, the answer also carries anoutsidesection of labelled notes after the local results.
These were MCP tools until 2026-09-02 (memory_map, memory_open, memory_load,
memory_remember, memory_search), served by a pure-Node subprocess spawned once per session.
That subprocess is retired: the routes run in the main process, which already owns the database, so
the whole per-session process disappeared and nothing about the behaviour changed. If you are
hunting for a memory MCP tool, it no longer exists — call the route.
The root map is also injected as text at the top of the first message, so an agent that never calls a route still knows the library is there — and that injected text names the exact command.
How auto-write works (Milestone 2)
- The agent that did the work writes the memory. At the end of its work, every session is asked — quietly, in its system prompt — whether anything about you is worth keeping. It asks exactly two things: did you reveal something about yourself, and did you correct it. It is explicitly forbidden from asking what the session accomplished, because in a fleet where agents finish tasks all day that question produces a changelog, not a memory. The default is to save nothing, and that is the normal outcome.
- Why the agent is asked first. A summarizer that only ever saw a truncated transcript could not tell whether a fact was already written down in the repo's own docs — and 75% of the library ended up as project notes duplicating git-tracked documentation. The agent that did the work can answer that, because it knows what it just wrote.
- The bar it applies. Save what stops you having to correct or remind it again; nothing that will be stale in a week; facts, never instructions to itself ("you prefer short replies" ✓, "always reply briefly" ✗ — an instruction gets re-read as an order later); and knowledge about the codebase goes in the repository's own docs, never here.
- The Learning Loop is the background reviewer. When the Learning Loop is on, it looks back over finished work at natural breaks — on every engine — and saves memories about you through the same writer, each one backed by a line you typed. It replaces the old session-end summarizer, and the summarizer's model choice and daily limit carry over to it. Its model, its daily limit and how much it says in the chat are the Learning Loop's own settings (Learning Loop settings).
- A mid-work
POST /memory/rememberlets an agent record something the moment it matters, without waiting for the session to end. - Scope. Each memory is
about-you(cross-project facts about the user),people,omni(standing instructions for Omni), orproject:<id>. A project memory only surfaces under that project; About You / People / Omni are global. - Dedup. A write matches an existing memory by content-hash or normalized title within the same scope instead of duplicating (meaning-based dedup arrives with M3's embeddings). An identical save refreshes the memory; when the same author saves new text under that title, the old version is archived and the new one saved, so nothing it said before is lost.
- Every save is checked. Before anything is stored — an agent's own save or the Learning Loop's — it is checked for something that looks like a password or key, an access token, login details, or planted instructions written to steer future agents. A flagged save stores nothing: it waits for you on a card showing the text with the sensitive parts already hidden, and approving saves exactly that copy.
- Safe by construction. The background review reads the transcript as fenced data — instructions inside it are ignored — and must answer in strict, validated JSON, so a memory can never smuggle a prompt-injection into future sessions. All of its spend counts against the Learning Loop's one daily limit, and it skips quietly when the Learning Loop is off, you have no AI key of your own, the limit is reached, or there is too little new work.
Milestone 1 model (deliberately simple)
- No persistent node table. The tree is a fixed scope scaffold (a code constant) + tag-derived groups computed on read. Deep, auto-splitting "index of indexes" arrives with the janitor (M4), which is the first thing that actually needs a stored node tree.
- Migrated library = About You. Existing store docs (pre-M2) read as About You (the user's personal library); untagged docs fall under an Imported library group. New memories carry the scope the writer assigned.
Milestone 4 — janitor + nesting (built)
A daily background janitor tends the library, and it owns the persistent nested index
(memory_index_nodes) — the "index of indexes" branches that auto-split when they grow. It stays
gated off with the rest of the feature, and it NEVER deletes: everything it tidies away is
archived (a distinct, fully recoverable state — deleting is a user-only action). An archived memory
drops out of the agent's active browse and GET /memory/load (and reappears if restored), so the tidying
is actually visible instead of silent.
Each run does four passes, cheapest-first:
- NEST (pure, free): rebuild the nested tree — group by tag, split any group over ~20 memories or ~8k tokens into sub-tag subgroups (max three levels), stamp each memory's leaf. Deterministic, so the tree never churns between runs; it's a rebuildable projection, never a second source of truth (drop it and the on-read scaffold still shows every memory).
- DEDUP (mechanical, free): collapse exact/title duplicates — keep the richest survivor, union its tags, keep the earliest provenance. A loser whose unique text isn't already on the survivor is co-filed (left live), never hidden.
- PRUNE (mechanical, free): archive empty-body memories only.
- AI lane (opt-in, ~$1/day cap): a cheap model (Haiku) does meaning-based near-duplicate matching (candidates from cosine neighbours over the M3 embeddings — read defensively, degrades to mechanical when they're absent) and stale judgement. Every prompt is injection-fenced (memory content = untrusted data) and every verdict is schema-validated (a bad one is dropped). Confirmed near-dups merge + archive their losers; stale memories archive — all recoverable.
The scheduler is a daily cron (hourly tick + a once-per-day file), single-flight, feature-gated so it costs nothing while off.
How search works (Milestone 3)
- Hybrid.
GET /memory/searchruns two engines and merges them: meaning-based (an on-device embedding model,all-MiniLM-L6-v2, cosine similarity) and keyword (SQLite FTS5). A memory found by both ranks highest. - Free. Embeddings run locally — M3 makes no LLM/API call and needs no cost cap.
- Always works. Keyword search is instant (a trigger-synced FTS index, no model). If the embedding model isn't ready, search degrades to keyword-only rather than failing.
- Stays fresh. A background pass at session end embeds new or changed memories (detected by a content hash), so search keeps up as the library grows — harvested from the MemPalace engine.
Combining memories
When the Learning Loop is on and Merge near-duplicate memories is on, an area (about you, people, or one project) that grows past its Memory size limit (30,000 characters by default) has memories that say nearly the same thing merged into one, in up to three rounds. The originals are archived, never deleted; each merge is a Memories combined — N into 1 line on the Learning timeline, where Undo brings every original back and Restore redoes it. A merge you undid is not tried again. The merged memory is checked for secrets and planted instructions like any other save.
Outside results in memory search
If you turn on Outside memory, GET /memory/search still answers from this
computer first and in the same order. After the local results it can add a separate section of notes
from your own Mem0 or Honcho account, clearly labelled with the service's name. They are notes, never
instructions, they are cleaned of passwords and keys, and they come only from the asking session's own
project plus your about-you and people areas. If the service is slow (more than four seconds) or
refuses, the section is replaced by one line saying so and the local results are unchanged. With
Outside memory off, search is exactly as before.
Roadmap
- All milestones (M1–M4) are built: read path (browse + load), auto-write (agent capture,
POST /memory/remember, and the Learning Loop as the background reviewer), search/RAG (hybridGET /memory/search+ on-device embeddings), and the janitor with its persistent nested index.
Related
Flashcards is the other local, agent-adjacent store in this library; the KMS vault is where your own hand-written notes live. The Learning Loop is the background reviewer that saves memories about you from finished work, with its own timeline and undo.
Last verified 2026-11-07