Docs · My Brain

Share a brain-pack you control

A brain-pack is a slice of your brain published for other people to install. You pick the memories one at a time, read the exact text that will leave your machine, and only then publish. Nothing goes out that you have not seen.

Publish a pack

Sign in and open /my-brain/share. The page loads every memory you own that is active, grouped by kind (lessons, decisions, patterns, and the rest).
Tick a whole kind, or tick memories one by one. A pack reads better when it is a coherent set, so prefer “how I plan and verify a change” over a dump of everything you have written.
Give it a title and a description. The description is what an installer reads to decide, so write what installing it does for them, not what it contains.
Choose unlisted or public. Unlisted packs are reachable only by their link.
Press Preview and read the panel. Then publish.

What the preview tells you

The preview is the point of the whole flow. It runs the same resolver that publishing runs, so what you read is what leaves. It shows three things:

The resolved items, each with a snippet taken after redaction. A secret that redaction strips is already gone from the snippet, so this page cannot show you something publishing would have removed.
The redaction diff: how many items are being shared, how many secrets were stripped, and how many machine paths were stripped.

Publish stays disabled until you have previewed the selection you are about to publish. Change the selection or the title afterwards and the preview marks itself stale rather than answering for a set you no longer have, so you preview again first.

Memories that can never be shared

A memory can carry a never-share flag that lives on the memory itself, not on any one pack. A flagged memory is dropped before it can reach a pack, and the flag beats an explicit include, so once you set it every future share honors it. The curation page lists how many of your memories are flagged and holds them out of the picker entirely.

Setting the flag is an API call today. There is no button for it yet:

POST /api/me/brain/sensitivity
{ "filePath": "lessons/client-escalation.md", "neverShare": true }

The route only ever touches your own memory. Your identity comes from your session on the server, never from the request, so a path that is not yours matches nothing and returns 404.

Update a pack after your brain moves on

Publishing stores a recipe on the pack: the slice you picked, the memories you excluded, and a content hash for each item that went out. The recipe is yours. It is never in the payload an installer receives, and it appears on no marketplace or lineage response, because it describes what you chose to leave out.

The recipe is what lets a pack be brought up to date. Re-resolving re-runs it against your brain as it is now and reports what changed:

POST /api/me/brain/share/<packId>/re-resolve        # dry run
POST /api/me/brain/share/<packId>/re-resolve?apply=1  # publish the update

Without ?apply=1 nothing is written. You get the added, removed and changed lists and a fresh redaction diff, and the published pack is untouched. A memory you wrote since publishing shows up as added and stays out of the pack until you apply. That is deliberate: a slice you picked in March should not quietly start shipping what you wrote in August.

Re-resolve has shipped endpoints and no UI yet, the same as the never-share flag.

Revoke

Your published packs are listed on the same page with their item counts. Revoking one takes it down. It does not reach into the brain of somebody who already installed it, because what they installed is theirs now, so revoke stops future installs rather than undoing past ones.

What an installer gets

Installing your pack does not overwrite anybody’s brain. Each item lands as a proposal the installer reviews and accepts one at a time, tagged with where it came from. Knowledge moves between people, and the person on the other end still decides what they keep.