v0.1.7 open-think · MIT
[M]AIN
v0.1.7 · open source · MIT

memory for your
AI agents.

A local-first CLI that gives agents persistent, curated memory. Log work as it happens. Let AI decide what matters. Recall it next session.

$npm install -g open-think
requires Node 22.5+

// the problem

Every new session, your AI agent wakes up with amnesia. It doesn't know what you shipped yesterday, what decisions you made last week, or what the team is focused on. You paste context. You re-explain. You repeat yourself.

// the fix

open-think is a local-first CLI that gives agents persistent, curated memory. Your work gets logged as it happens, curated by AI into what actually matters, and made available to any agent that needs it.

Built for Claude Code users and developers who want their tools to remember.

// next

Read the concepts to understand the pipeline, or jump to install if you want to start using it now.

// concepts

Five concepts. One pipeline. Entries become engrams, engrams become memories, memories get recalled.

[01]

entries

Timestamped notes and work logs. The raw material. Stored locally in SQLite, always on your machine.

$ think sync "shipped auth refactor"
✓ Logged [sync] 2026-04-14 10:23
[02]

engrams

Raw work events awaiting evaluation. When a cortex is active, your syncs become engrams — short-lived signals waiting to be curated. Engrams never leave your machine.

$ think sync "blocked on partner API"
✓ [engineering] engram saved
[03]

cortex

A memory workspace. Personal or shared. Each cortex is a separate memory space with its own engrams, memories, and curation history, backed by a git repo.

$ think cortex create personal
✓ Created cortex: personal
[04]

curator

AI-powered evaluation. Reads engrams, weighs them against what's already known, and promotes what matters to long-term memory. Drops the rest.

$ think curate
Evaluating 12 engrams...
✓ 12 evaluated, 3 promoted, 9 dropped
[05]

recall

Search across memories and local engrams. Give your agents context before they start working. The recall surface is what other agents read from.

$ think recall "auth"
Team memories (last 14d):
→ Auth refactor shipped...

// architecture

Local-first, by default. Engrams never leave your machine unless you explicitly curate them. The curator runs locally. Only promoted memories are pushed to your chosen backend.

  ┌─ your machine ─────────────────────────────────────────┐    ┌─ backend ─┐
  │                                                        │    │           │
  │   entries ──→ engrams ──→ curator ──→ memories   │ ─→ │   git     │
  │                                  (local AI)            │    │   S3*     │
  │                                                        │    │   PG*     │
  └────────────────────────────────────────────────────────┘    └───────────┘

  * future backends. today, git is the backend. point think at a repo and go.

// install

Five steps from zero to a working memory pipeline.

  1. Install the CLI

    $npm install -g open-think

    Requires Node 22.5+ (uses the built-in node:sqlite module).

  2. Log something

    $think sync "first entry"

    Without an active cortex, syncs are stored locally as plain entries.

  3. Set up a cortex

    $think cortex setup git@github.com:you/memory.git
    $think cortex create personal

    Point think at any git repo. The cortex becomes the home for curated memories.

  4. Set up your agents

    $think init

    Writes work-logging instructions into your project's CLAUDE.md.

  5. Curate & recall

    $think curate
    $think recall "what did I ship?"

    Curation evaluates pending engrams and promotes the important ones to long-term memory.

// built for AI agents

Drop into any Claude Code project, run think init, and your agents start auto-logging work. The curator decides what's worth remembering. Next session, the agent recalls what it needs — no pasting, no re-explaining.

// docs

Reference, source, and where to find help.

// all commands

Run think --help for the full command reference, or browse the README on GitHub.

// where things live

  • ~/.think/default data directory (override with $THINK_HOME)
  • data/think.dblocal entries (SQLite)
  • engrams/per-cortex engram buffers
  • repo/cloned cortex (curated memories live here)
open-think · ready
↑↓nav ⏎select ggithub iinstall ?help