Yuno15
← All work

Personal project · open source · 2026

GreyMatter

Persistent memory for command-line agents: an installable engine, kept separate from your notes, that updates itself. Published as open source.

Role
Design, architecture, extraction, publication

Stack

  • Python
  • Bash
  • Electron
  • WebGL
  • GitHub Actions
  • Apache 2.0
Result
46 releases published under Apache 2.0, installable in one command — and a leak check that is allowed to block any publication.
The trunk map on MacBook Pro and iPad
The same trunk map at the same instant on both screens: 701 notes, 2,881 links, 21 regions. At the bottom, the power-on self-test and the column of code being written right now. Captures of a demonstration trunk at full density, names and paths neutralised before the photo. Official Apple bezels, at true relative scale.

The capsule sits in a corner of the screen and asks for nothing. The line underneath names the task in hand. It is the engine’s only interface: everything else is text.

Every dot is a note, and distance means resemblance. Click one: it opens with its region, its summary and its links. Ask for the filing: the map reorganises into a ring. Enter a family: the map closes in on it. Filmed on a demonstration trunk at true density — 701 notes, 2,881 links, every name neutralised before filming

What it is for

A command-line agent is brilliant inside a session and amnesiac between two. GreyMatter gives it memory that lasts: whatever is solved once is distilled into a note, filed, linked, and resurfaces on its own in the next session.

What the engine does

  • Distillation: a working session becomes clean notes — one fact per note, with its provenance and its degree of certainty.
  • Automatic recall: on every question asked, the relevant notes come back on their own, with nothing to look up.
  • Knowledge tree: notes link to each other; a lesson learned on one project is findable from every other.
  • Gardening agents: eight specialised roles file, de-duplicate, challenge stale notes and repair broken links.
  • 3D planet: the whole graph is visualised in real time, one continent per domain.

How a session becomes memory

Everything runs on the machine — nothing here is a service you log into
  1. 01 The trunk Plain Markdown files on the machine: the notes, the map, the state.
  2. 02 On every prompt A lexical search picks the few notes that answer, and pastes them into the question.
  3. 03 During the session What is written and what is read are recorded — the real material of the work.
  4. 04 At session end The session is archived, then the agents wake: two always, a third only if its sensor crosses a threshold.
There is no orchestrator: each stage hangs off a moment in the session. That is what makes the memory free to use — you never have to remember to feed it.

What makes publication possible

Two folders that never mix

The engine — disposable, replaced on every update

  • The code that files, links and retrieves
  • The checks and the measurement benches
  • The install and migration tooling

The trunk — it only moves when I write

  • A year of notes, lessons and decisions
  • Client names, addresses, machine paths
  • What an update must never touch
The split is not a filing convention: an update replaces the engine wholesale, and is not allowed to write into the notes.

The chain that protects the lived record

From the living notebook to the public package
  1. 01 The living notebook A year of real notes: clients, addresses, machine paths.
  2. 02 Allow-list copy What is not named does not leave.
  3. 03 De-identification Replayable rules strip names, numbers and paths.
  4. 04 Leak check 21 markers. One of them turning red blocks the publication.
  5. 05 The public package The engine, installable by anyone. Never the lived record.
A one-way chain: nothing flows back from the public repository into the notebook. The leak check is allowed to block publication, and it already has.

How it installs and stays alive

  • One command: the package installs as an extension to a command-line agent.
  • Every release is replayed by continuous integration: full install, uninstall, and every past migration run twice — with the requirement that it has eaten no note.
  • 46 releases published, under the Apache 2.0 licence, on a public repository.

Source code: github.com/Yuno15-bb/c-brain