Neural Map
Think of git log for a moment: a chronological record of every change, each entry attributable, each one inspectable after the fact. The Neural Map is that idea applied to knowledge instead of code — a log of what your agents learned, drawn as a graph. Every memory an agent records becomes a node; relationships between lessons become edges; and instead of scrolling a linear history, you look at the shape of what your workspace knows.
What problem it solves
Once agents write memory to themselves, a new question appears that plain CLIs never had to answer: what do my agents actually believe right now? With a hand-maintained instructions file you always knew, because you wrote it. With self-writing agents, knowledge accumulates while you are not watching — across sessions, across agents, across weeks. Unaudited, that accumulation is a liability: agents confidently applying conclusions you never reviewed.
The Neural Map makes the invisible stock of knowledge visible. A graph, rather than a list, is the honest shape for it: lessons cluster around topics, some nodes connect widely and matter more, and isolated fragments stand out as candidates for pruning. Two properties do most of the auditing work for you:
Freshness fades. Older entries literally fade on the map. Knowledge has a half-life — a note about a dependency version or a temporary workaround rots quietly — and the map encodes that decay visually instead of presenting a ten-week-old lesson with the same confidence as yesterday's.
Scope is filterable. Pinned Memory filters let you narrow the map to what is pinned — the entries agents treat as always-in-force. That is the highest-stakes slice of the graph: if something wrong is pinned, it is wrong in every session, so it deserves the closest reading.
What it replaces
Nothing, and that is the point — the plain-CLI world has no equivalent, because it has no self-accumulating knowledge to audit. The nearest human practice it replaces is the periodic archaeology session: grepping old notes and scrollback trying to reconstruct why an agent behaves the way it does. On the map, the answer is a node you can find, read, and act on.
Honest limits
The map shows what was recorded, not what happened. It inherits every limit of memory itself: an agent that failed to write a lesson down produces no node, and a mistaken lesson produces a confident-looking one. The map surfaces beliefs for review; it does not certify them true.
Fading is a heuristic. Age correlates with staleness, but some old truths are permanent and some fresh notes are already wrong. The fade tells you where to look first, not what to delete.
The map is local. It renders your machine's knowledge. There is no cross-machine or cloud-merged view of what agents know elsewhere.
To work with the map itself, see the Neural Map guide, starting with Reading the map.