Memory
CLI users already have a primitive form of agent memory: the instructions file. You write down project conventions, hard-won gotchas, and standing rules in a markdown file, and the CLI reads it at session start. It works — but you are the one doing the remembering. The agent learns something at 4 p.m., the session ends, and unless you transcribed it, the lesson is gone.
NEXUS memory is that same file, with the authorship flipped: memory is an instructions file the agent writes to itself. When an agent learns something worth keeping — a build quirk, a decision you made, the reason an approach failed — it records the lesson as a memory entry. Next launch, the lesson is simply known.
What problem it solves
The cold-start problem is only half solved by persistent agents. A durable name with static instructions is a colleague with a job description but no experience: it starts every day knowing what it should do and nothing about what happened. Human-maintained instruction files decay for a predictable reason — the person who benefits from the note (the agent, tomorrow) is not the one who has to write it (you, today, while busy). Self-written memory aligns the incentive: the party that learned the lesson is the party that records it.
Memory is also scoped rather than monolithic. An agent's Memory card shows what it knows; pinned entries mark what must always be in play, and scope filters separate an agent's own lessons from workspace-wide knowledge. That structure is what makes memory auditable instead of being one ever-growing blob of text.
What it replaces
Manually curated instruction files, session-notes documents, and the ritual of pasting "context recaps" into a fresh session. It also replaces the subtler work pattern of keeping one terminal alive for weeks because closing it means losing what the session "knows" — with memory, closing the session is safe.
Honest limits
Memory is local. Entries live on your machine with the rest of the workspace. There is no cloud sync of what your agents know; moving knowledge to another machine is an export you perform deliberately, not an ambient service.
Memory is testimony, not a transcript. An entry is what the agent chose to record, not a log of what occurred. It can be incomplete, stale, or wrong — and a wrong memory is worse than none, because it is applied confidently on every launch. This is why memory is a first-class, inspectable surface rather than a hidden cache: the Neural Map draws it, fades entries as they age, and lets you challenge what an agent believes.
Memory does not grow the context window. It changes what an agent loads, not how much it can hold. Pinning everything is equivalent to pinning nothing.
To browse and manage what an agent knows, see the Agents guide and the Neural Map guide.