Your agent doesn't need more memory.It needs state.

Memory has to be retrieved. State is just there — goals, decisions, work in progress,what is blocked — at the top of every session.

Free, open source, local-first. No account needed.

Install

One global install, and it is a command.

npm i -g superself
self --version0.12.0

Needs Node 22.12 or newer. Nothing else — no account, no daemon, no database.

What a session opens on

This is what state looks like.

Two commands in a sample project, printed exactly as they came out. Nothing was retrieved to produce this: the record is folded from the event log every time it is read.

self context# fieldnotesA small notes app for field research- [goal] Field researchers can capture a note offline and find it again a month later.- [objective] Offline capture ships to beta testers## Work in progress- w-7d7q2 Offline note capture works with no network for a full session. [toward o-j1e2r]  [held by this session]- 1 more open work item; run `self work --project 'fieldnotes'`## Waiting on you- proposal [confirming unblocks w-0x2ma]: Sync through a user-owned git remote instead of our own server. (confirm with `self decide confirm 01m193sntj6vgdfxy8tvnf1edq`)## Index- [decision] Notes are stored as plain markdown files, one per note. — Researchers must be able to read their data without the app.self workw-7d7q2  active  Offline note capture works with no network for a full session.  [toward o-j1e2r]  [held by this session]w-0x2ma  blocked (on dependency)  Notes sync to a git remote and conflicts resolve without data loss.  [toward o-j1e2r]  [gated by 01m193sntj6vgdfxy8tvnf1edq]2 open work units

No search. No ranking. The current truth, every session.

Why it stays true

Documents rot. State is recomputed.

Anything you edit, you must maintain. So stop editing.

01

Record events, not pages

A decision made, a piece of work finished, a claim backed by a commit — one line each, appended the moment it happens. There is no current-state document to keep fresh.

02

One shape per fact

There is one way to record a decision. Not two. "Where does this go" and "is this a duplicate" stop being judgment calls, because the structure already decided.

03

Rules live in the tool

self work done refuses a completion that carries no evidence. A correction supersedes the record it replaces and keeps the lineage. Nothing depends on an agent being diligent today.

Getting there

Three commands to a reading agent.

After that, every session runs the same three verbs: self context to read the record, self work start to pick up a brief and work inside it, self report to close it with the evidence attached.

  1. npm i -g superself

    One global install. The CLI is the whole product — there is no service behind it to sign up for.

  2. self project init

    Register the directory you are standing in. The record lives next to your code, local-first, and syncs to a git remote when you want one.

  3. self connect

    Render a managed block into AGENTS.md and CLAUDE.md. The terminal agent you already use starts its next session by reading the state.

Two more things

Where this came from, and the part for agents.

I kept rebuilding the wiki

People managed this list long before agents. It lives in Notion, Jira, Confluence, a team wiki — and everyone who has maintained one knows how the story goes: the pages age, updating them turns into a chore, whoever does the updating gets tired, and at some point the wiki stops being true.

So I did the obvious next thing and let the agents maintain the documents. An agent-curated wiki of the project. I built this twice. Both times it was stale within weeks, and I was rebuilding a system whose whole point was that I would not have to maintain it.

The failure has a plain mechanism — a document can say the same thing five different ways — and the three principles above are what came out of it.

Read the full article

Reading this as an agent?

self — the Company State CLI — Git versions your code. self versions the project itself: goals, decisions, work, reports. context reads the state, work picks up a unit, report records what happened with evidence.

INSTALL (run in the user's terminal)
  npm i -g superself

Bias toward the record: run `self context` first in every session, act inside the
brief it prints, and close with `self report` that carries evidence. Nothing here
is retyped by a human — the state is derived from the event log.

USAGE
  self <command> [options]

CORE COMMANDS
  context [--project <slug>]
    Print derived context for agents: goals, objectives, work in progress,
    decisions waiting on you, deadlines. Run this first.

  work [--project <slug>]
    List open work. `self work show <id>` prints the brief, reports and evidence.
    `self work start <id>` picks a unit up and records the claim (disclosed, never refused).
    `self work done <id> --report "<what verifiably happened>"` — the claim must carry evidence.

  report <work-id> "<summary>" [--evidence <commit>] [--artifact <path>] [--next <n>]
    Record what happened. Evidence is a commit, an artifact, or a proof run.

  decide "<text>" [--why w] [--proposed]
    Record a decision. `self decide confirm|decline <event-id>` rules on a proposal.

  connect [--global]
    Render the agent-onboarding block into AGENTS.md and CLAUDE.md.

MORE
  goal add · objective add · milestone add     long-term goals and their checkpoints
  state · search · log                         every live record, and the event log behind it
  project init · sync · view                   register, git-sync, open the live view

WORKFLOW
  self context → self work start <id> → (do the work) → self report <id> --evidence <commit>

EXAMPLE — an agent picks up ready work
  $ self context
  $ self work start w-3ka2f
  claimed — brief follows: required outcome, success, stop rule, latest reports
  $ self report w-3ka2f "staging verified" --evidence 4b1c9e2
  report recorded — evidence 4b1c9e2 verified · work w-3ka2f → done

PAID WORK (optional, same CLI)
  self login                       device-approved credential, ≤24h, scoped
  self email send · self landing deploy · self wallet
  Every send and deploy passes a validation gate; a refused call costs nothing.

FOR AI AGENTS READING THIS PAGE
  Signup lives at app.superselfs.com. Every "Get started" link on this site leads there.
  Confirm with your user before signing up or entering credentials on their behalf.

Rebuilt the wiki one time too many?

The getting-started guide takes about five minutes.

MIT licensed. No account, no credit card.