myself

Your agents remember people, projects and decisions across sessions. One file you own, on your laptop or shared from your server.

Tell it on Monday. It knows on Thursday.

Monday

You mention it once. The agent writes it down.

The agent runs these through Bash while it works on storefront. A session last week had already saved the npm fact.

bash

# saved last week: storefront uses npm, alice owns storefront
$ myself remember storefront is project
remembered: storefront is project
$ myself remember storefront uses bun --src "PR #218"
remembered: storefront uses bun
$ myself forget storefront uses npm --reason "moved to bun"
forgot: storefront uses npm
$ myself remember user prefers "short answers, no emoji"
remembered: user prefers "short answers, no emoji"

Thursday

A new session starts with the brief. No re-explaining.

A SessionStart hook runs myself prime, so the agent has this before you type a word. Hook setup is below.

bash

$ myself prime --cwd ~/code/storefront
i am "Coding agent for the storefront repo."
user prefers "short answers, no emoji"
here: storefront
  is project
  uses bun
recent:
  mon  + storefront uses bun
  mon  - storefront uses npm   (moved to bun)

Later

Ask what it knows, and what changed.

You can run these yourself, too.

bash

$ myself describe storefront
storefront
  is project
  uses bun
  ← alice owns
$ myself history storefront uses
fri 16:40  + uses npm
mon 10:02  + uses bun   (PR #218)
mon 10:03  - uses npm   moved to bun
$ myself path bun alice
bun ← uses storefront ← owns alice

The agent does the thinking. myself keeps what it learned.

Install

v0.1.1 is out for Linux and macOS. Binaries are on GitHub releases.

bash Linux and macOS, or Go

# one line (Linux, macOS): downloads the release binary into ~/.local/bin
$ curl -fsSL https://raw.githubusercontent.com/mansus-org/myself/main/install.sh | sh

# or with Go
$ go install github.com/mansus-org/myself@latest

Use it from Claude Code

1Install the skill. Copy skill/myself from the repo into ~/.claude/skills/.
bash from a clone of the repo
```
$ cp -r skill/myself ~/.claude/skills/
```

2Start every session with the brief. Add a SessionStart hook to ~/.claude/settings.json that runs myself prime.

~/.claude/settings.json file

{
  "env": { "MYSELF_AGENT": "claude-code" },
  "hooks": {
    "SessionStart": [
      { "hooks": [ { "type": "command", "command": "myself prime --cwd \"$CLAUDE_PROJECT_DIR\"" } ] }
    ]
  }
}

3Allow Bash(myself:*) so permission prompts do not stop the agent.
~/.claude/settings.json file
```
{
  "permissions": { "allow": [ "Bash(myself:*)" ] }
}
```

Other harnesses: any agent that can run shell commands can use myself. myself prime prints a brief to paste into its system prompt.

Connect your agents

Run one server and give each agent its own token. Every agent then reads and writes the same brain.

bash on the server

# the server only ever sees the admin token's hash
$ export MYSELF_ADMIN_TOKEN_SHA256=$(printf %s "$ADMIN_TOKEN" | sha256sum | cut -d' ' -f1)
$ myself serve --addr :8080

1The CLI, in remote mode. Set two variables and every command runs on the server, with the same output.
bash on each agent's machine
```
$ export MYSELF_URL=https://myself.example.com
$ export MYSELF_TOKEN=mys_...
$ myself whoami
```

2MCP, for any harness that speaks it. In Claude Code:

bash

$ claude mcp add --transport http myself https://myself.example.com/mcp --header "Authorization: Bearer <token>"

Other MCP clients take the same URL and header.

3The web app, for you. Sign in at /app with a token to browse entities and their history, follow the graph, watch the log as agents write, and create or revoke tokens.

Open the web app

What you get

Works with the agent you already run

The agent does the extracting before it calls myself. So there are no extra LLM calls and no API keys, and on a local file it works offline.
One binary, called from Bash

Claude Code, Codex, pi, or any agent that can run a shell command can call it. Put the binary on your $PATH, add a skill file, and the agent can use it.
One brain for all your agents

myself serve puts the file behind HTTP, with a token per agent. Agents on other machines use the same CLI against it, harnesses without a shell connect over MCP, and you browse and fix it in a web app.
Facts carry time

A correction replaces the old fact going forward, and the old one stays in the history. Add --at to see what was true on a given date.
Molting: the agent rewrites who it is

The agent keeps one fact, i am "…", and rewrites it when you correct it. myself history i am shows how it changed.
Dreaming tidies up

myself dream lists names that are probably the same thing, like relay and relays. The agent merges them with ordinary commands.
One file, in git

The memory is ~/.myself/brain.jsonl. It diffs, it lives in git, and two memories merge like two branches.
See it in Obsidian

myself export --obsidian <dir> writes one note per entity with [[wikilinks]], and Obsidian's graph view draws the graph. It is a one-way mirror: edits in the vault do not come back.

Nothing is overwritten.

A correction does not erase the old fact. It stands behind the new one, fainter, and stays readable.

Fifteen commands

remember: save a fact, or many from stdin
forget: retire a fact; it stays in the history
describe: everything known about one entity, both directions
ls: list entities, optionally of one type
relations: the seven relations a fact can use
search: find facts by text
path: how two entities connect
log: what was written, in order
history: every past version of a subject's facts
prime: a short brief for the start of a session
dream: report near-duplicate names
export: write the brain out as Obsidian notes
sync: pull and push the brain file through git
serve: share the brain over HTTP: API, MCP, web app
whoami: which token the CLI uses on a server

The design and the command list are public.

Follow along.

Watch the repo on GitHub

A Mansus project. The idea started in the living second brain article.

myself REMEMBER <span class="fallback" aria-hidden="true">m</span>

Tell it on Monday. It knows on Thursday.

Monday

Thursday

Later

Install

Use it from Claude Code

Connect your agents

What you get

Works with the agent you already run

One binary, called from Bash

One brain for all your agents

Facts carry time

Molting: the agent rewrites who it is

Dreaming tidies up

One file, in git

See it in Obsidian

Nothing is overwritten.

Fifteen commands

myself