myself REMEMBER

v0.2.0 is out for Linux and macOS, amd64 and arm64.

# the latest release into ~/.local/bin, after checking its sha256
$ curl -fsSL https://raw.githubusercontent.com/mansus-org/myself/main/install.sh | sh
$ myself version

To pin a release, set MYSELF_VERSION; to install somewhere else, set MYSELF_INSTALL_DIR:

$ curl -fsSL https://raw.githubusercontent.com/mansus-org/myself/main/install.sh | MYSELF_VERSION=v0.2.0 MYSELF_INSTALL_DIR=/usr/local/bin sh

With Go, or from the prebuilt tarballs on the releases page:

$ go install github.com/mansus-org/myself/cmd/myself@latest

Install, in the README

Every session starts with the brain in context, and the agent uses myself through the skill. The brain lives in ~/.myself/brain.jsonl (override with MYSELF_FILE or --file) and is created on the first write.

1. 1Install the binary, as above.

2. 2From a clone of the repo, install the hooks and the skill. The skill is also at myself.mansus.org/skill.md: save it as ~/.claude/skills/myself/SKILL.md.

   Copy

   $ git clone https://github.com/mansus-org/myself && cd myself
   $ mkdir -p ~/.myself/hooks ~/.claude/skills
   $ cp contrib/hooks/*.sh ~/.myself/hooks/
   $ chmod +x ~/.myself/hooks/*.sh
   $ cp -r skill/myself ~/.claude/skills/

3. 3Merge this into ~/.claude/settings.json, keeping the hooks and permissions you already have.

   Copy

   {
     "permissions": {
       "allow": ["Bash(myself:*)"]
     },
     "hooks": {
       "SessionStart": [
         {
           "hooks": [
             { "type": "command", "command": "~/.myself/hooks/session-start.sh", "timeout": 10 }
           ]
         }
       ],
       "Stop": [
         {
           "hooks": [
             { "type": "command", "command": "~/.myself/hooks/stop-nudge.sh", "timeout": 10 }
           ]
         }
       ]
     }
   }

What the hooks do

• session-start.sh prints myself prime --budget 4000, which Claude Code adds to the session context. MYSELF_PRIME_BUDGET changes the budget.
• stop-nudge.sh blocks the first stop of a session once, asking whether anything is worth remembering, but only if nothing was written to the brain since the session started and the session edited files, ran 3 or more Bash commands, or left uncommitted changes. MYSELF_NUDGE=off turns it off.
• Both are POSIX sh and exit quietly when myself is missing or fails. If ~/.local/bin is not on the hooks' PATH, set MYSELF_BIN to the full path of the binary.
• Claude Code's own file-based auto-memory can take "remember..." requests first. Add "env": { "CLAUDE_CODE_DISABLE_AUTO_MEMORY": "1" } to the same file to leave it to myself.

Other harnesses: pi

The skill is one file that any myself serve instance serves at /skill.md, with no token. For pi, install the package. It adds the skill and an extension that runs myself prime --budget 4000 on the first agent run of each session and adds the output to the context, like the Claude Code SessionStart hook.

$ pi install git:github.com/mansus-org/myself

Codex or any agent with no skills directory: tell it "Read https://myself.mansus.org/skill.md and follow it". myself prime prints a brief to put in its system prompt.

pi setup, in the README

Claude Code setup, in the README

myself serve shares one brain over HTTP, for agents on several hosts or harnesses. It serves this page at /, a REST API at /api/v1 (the same JSON as --json), MCP at /mcp and a web app at /app. Replace <your-server> below with your server's address.

Run the server

The admin token is only known to the server by its sha256. Without it the API answers 503.

$ export MYSELF_ADMIN_TOKEN_SHA256=$(printf %s "$ADMIN_TOKEN" | sha256sum | cut -d' ' -f1)
$ myself serve --addr :8080

The store is the usual --file or MYSELF_FILE. The repo's Dockerfile runs the same server with the store on a volume at /data.

Give each agent a token

The admin creates and revokes agent tokens with a read or write scope, from the web app's Tokens page or the API. Only their hashes are stored, in tokens.json next to the store, so the token is shown once.

$ curl -H "Authorization: Bearer $ADMIN_TOKEN" -d '{"name":"laptop","scope":"write"}' https://<your-server>/api/v1/tokens
{"id":"01a1974f-64ae-70f3-a8de-8652b1a43929","name":"laptop","scope":"write","created":"2026-11-01T13:32:05Z","last_used":null,"token":"mys_..."}

The CLI, in remote mode

Set two variables and every command runs on the server instead of the local file, with the same output, --json and exit codes. The Claude Code hooks follow along when these are in Claude Code's environment.

$ export MYSELF_URL=https://<your-server>
$ export MYSELF_TOKEN=mys_...
$ myself whoami
name laptop
scope write
admin false
$ myself remember storefront is project
remembered 01a1974f-71c9-7010-be41-2bb126eb28bf

• --url and --token override the variables. Prefer the variable for the token: flags show up in ps.
• MYSELF_TIMEOUT bounds a request (default 10 s). An unreachable server, or a 401, 403 or 503, is exit 3.
• sync is local only. Back a server up with GET /api/v1/export.jsonl.

MCP

For harnesses without Bash. The tools mirror the CLI (remember, forget, describe, ls, search, path, log, history, prime, relations, dream), plus a myself://prime resource. A read token can use all of them except remember and forget. In Claude Code:

$ claude mcp add --transport http myself https://<your-server>/mcp --header "Authorization: Bearer $MYSELF_TOKEN"
# headless runs (claude -p) only call the tools you allow
$ claude -p --allowedTools mcp__myself "what do you know about storefront?"

Any other MCP client with streamable HTTP takes the URL and the header:

{"mcpServers":{"myself":{"type":"http","url":"https://<your-server>/mcp","headers":{"Authorization":"Bearer <token>"}}}}

The web app

Sign in at /app by pasting a token. A read token browses entities, the graph, search and the log as agents write; a write token can also add and forget facts; the admin token also manages tokens.

Open the web app

Server, remote mode, MCP and the web app, in the README

Arguments are positional and everything after the relation is the object, so quotes are optional. --json works on every command, --file PATH picks the store, --url and --token pick a server, and --at TIME (RFC 3339 or YYYY-MM-DD) shows the state as of that time where listed.

Relations are a closed set: is, are (stored as is), has, uses, does, prefers, related. Anything else is rejected:

$ myself remember storefront owns checkout
error: unknown relation "owns". use one of: is, are, has, uses, does, prefers, related

i, me and myself as a name all mean the entity self. To remember something about this project, use another name, such as myself-cli.

The full grammar, in SPEC.md

One JSON object per line, five fields, never rewritten:

{"uuid":"01a1974d-c48e-758c-b0a7-425a87f60106","subject":"self","relation":"does","object":"coding agent for storefront; opens PRs, never merges","time":"2026-11-01T13:30:18Z"}

• The log is append-only. forget appends a record whose subject is the uuid of the retracted record, with forget as the relation and the reason as the object. A record is live unless a forget points at it.
• Records are ordered by uuid (UUIDv7, so by time). Writers lock <file>.lock; readers take no lock and skip a corrupt line with a warning.
• Time travel: myself describe storefront --at 2026-10-30 shows storefront as it was on that date. --at also works with ls and search.

Backup

Keep the store in a private git repository and sync it with one command. sync sets up a merge driver, so two hosts that both appended end up with the union of their records. It never creates a remote or sets a git identity.

$ cd ~/.myself && git init && git remote add origin <private-repo-url>
# commits, pulls (rebase), pushes
$ myself sync

To sync every 15 minutes and refresh an Obsidian vault, add a cron line. myself must be on the cron job's PATH, since git calls it for merges.

*/15 * * * * myself sync --export ~/vault/myself

Storage and backup, in the README

One note per entity, live state only. Objects that match an entity become [[wikilinks]], and incoming links are listed under Linked from. The mirror is one way: the next export overwrites edits made in the vault.

$ myself export --obsidian vault
exported 5 entities to vault
$ cat vault/storefront.md
# storefront

- is [[project]]
- uses bun

## Linked from
- [[alice]] related

Obsidian mirror, in the README

• No server needed. myself serve is optional; the CLI works on a local file.
• No embeddings, yet. Search is a substring match.
• No two-way Obsidian sync.
• No query language. The commands are the interface.