memory-pulse

memory-pulse

Site: pulse.strategic-innovations.ai, where the guard runs in the browser. Compare with Mem0, Zep, Letta and CLAUDE.md. Guide: docs/GUIDE.md, the day-to-day protocol with runnable examples.

Give any agent self-improving memory you can trust in production.

Every correction is kept, put in front of your agent when it matters, and enforced. Memory security is built in: a stored note that reads like an instruction never reaches your agent, every row is hash-chained so any edit to the record shows, and a guard blocks the edit that writes a retired value back.

Your agent acknowledged the correction, then wrote the old value back next session. memory-pulse records it once, puts it at the top of every session, and blocks the edit that reintroduces it, quoting the line that retired it. For Claude Code, Codex, Cursor, any MCP client and GitHub Actions. The record is a file in your own repository.

Most memory tools stop at showing the correction to the model. The guard is the part that acts on it.

The four tool definitions come to 3,406 chars, 3.3 KB, about 900 tokens at 3.8 chars per token, measured 2026-09-09. test/client.test.js fails the build past 4,000 chars or 60 tokens either side of 900. Independent measurements put a typical five to ten server MCP setup at 50-67k tokens of tool definitions before your first prompt, roughly a third of a 200k context window.

What it does

A session ends and everything it learned goes with it. memory-pulse keeps a ledger of cause -> effect events in a local file, and gives the agent four tools over it:

Two design decisions do the heavy lifting.

Corrections come first, always. An event recorded with kind: "correction" outranks everything at every brief size and never decays. The failure this prevents is your agent confidently quoting the benchmark number you withdrew three sessions ago.

A weak answer returns nothing. When recall cannot clear its confidence floor it returns an empty result, and the brief says so.

Install

Every route, host by host, with what runs on each: docs/INSTALL.md (also at pulse.strategic-innovations.ai/install).

Six routes. Pick the row for your agent. Node 18 or newer (package.json engines); the test suite runs on 22 and 24.

remember and help from the shell arrive in 0.5.9. npm served 0.5.8 on 2026-09-09, where both exit 1 with unknown command. If npx serves an older cached release, pin this one: npx -y memory-pulse@0.16.1; from a checkout, run node server.mjs. Four more things in this README are 0.5.9 behaviour and differ on 0.5.8: guard --verbose names non-JSON stdin on stderr (0.5.8 prints nothing), handoff with no transcript writes nothing and says handoff skipped (no transcript) (0.5.8 records a row that reads asked: n/a | files: none), remember reports boundFromEffect when it read the terms out of the effect slug, and a replacement term under 2 characters is dropped like a withdrawn one. 0.5.8's install-hook --codex also says trust the two memory-pulse entries while writing three hooks: trust all three.

One line, any shell. Installs the Claude Code hooks, the Codex hooks when codex is on PATH, and registers the MCP server. It prints its plan first, runs nothing as root, and downloads nothing itself (npx caches the package under ~/.npm). Append -s -- --dry-run after bash to see the commands without running them, or -s -- --project to write the hooks and the Claude Code MCP registration into the current repository. codex mcp add has no project scope; it writes ~/.codex/config.toml on each machine under either flag.

curl -fsSL https://pulse.strategic-innovations.ai/install.sh | bash

Claude Code, as a plugin. Skill, MCP tools and two hooks (SessionStart brief, PreToolUse guard) from this repo, typed inside Claude Code:

/plugin marketplace add t-crew/memory-pulse
/plugin install memory-pulse@memory-pulse

claude plugin details memory-pulse shows what you pay. About 120 tokens are always on, which is the skill's description (Claude Code, 2026-09-01). The four tool schemas resolve at runtime and the hooks are free. The hooks run the plugin's own server.mjs, so what enforces your corrections is the version you installed. The plugin does not carry the PreCompact handoff; to add it, put this entry under hooks.PreCompact in ~/.claude/settings.json:

{ "hooks": [{ "type": "command", "command": "npx -y memory-pulse handoff" }] }

Codex CLI, as a plugin. Same files, read from .codex-plugin/plugin.json:

codex plugin marketplace add t-crew/memory-pulse
codex plugin add memory-pulse@memory-pulse

Then, inside Codex, run /hooks and trust the three memory-pulse entries (session start, prompt and guard). Codex runs no hook it has not shown you, and installing a plugin does not trust its hooks. That is Codex's rule and a good one.

npm, global install. install-hook writes four hooks into ~/.claude/settings.json: SessionStart brief, UserPromptSubmit prompt, PreToolUse guard and PreCompact handoff. --codex targets ~/.codex/hooks.json instead, --project writes them into the repository, and --ambient adds the UserPromptSubmit observer.

npm i -g memory-pulse
memory-pulse install-hook

Claude Code or Codex without the plugin. Register the stdio server, then add the hooks:

claude mcp add memory-pulse -- npx -y memory-pulse
codex  mcp add memory-pulse -- npx -y memory-pulse
npx memory-pulse install-hook            # Claude Code: ~/.claude/settings.json
npx memory-pulse install-hook --codex    # Codex:       ~/.codex/hooks.json (then /hooks to trust each entry)
npx memory-pulse install-hook --cursor   # Cursor:      ~/.cursor/hooks.json (brief, fail-closed guard, capture)

claude mcp add without a scope registers the server for the current directory; -s user registers it once for every project. codex mcp add has no scope flag and writes ~/.codex/config.toml (codex-cli 0.153.2, 2026-09-09). Add --project to install-hook and the hooks are written into the repo, at .claude/settings.json or .codex/hooks.json. Commit that and every clone is re-entered and guarded with nothing for anyone to install. A Codex clone still trusts the entries once via /hooks, and a scripted codex exec needs that trust in place beforehand.

Cursor. Cursor runs hooks, so npx memory-pulse install-hook --cursor (or --cursor --project for .cursor/hooks.json in the repo) gives Cursor the same brief, guard and capture as Claude Code: the brief at session start, the guard on every write and shell command (fail-closed, so a broken guard blocks rather than passes), and capture with fixes and open threads. For the MCP tools, register command: npx with the args below in .cursor/mcp.json or ~/.cursor/mcp.json. Written from Cursor's hook reference (cursor.com/docs/agent/hooks, read 2026-10-21) and tested against its documented payloads; not yet run inside Cursor itself.

Other stdio clients. The same MCP entry works in any client that speaks MCP over stdio.

{ "mcpServers": { "memory-pulse": { "command": "npx", "args": ["-y", "memory-pulse"], "env": { "MEMORY_PULSE_KEY": "" } } } }

A rule file at .cursor/rules/memory-pulse.mdc tells the agent to call pulse before answering about prior work; the guide has the text.

From source. server.mjs plus the plain modules in lib/, zero dependencies:

git clone https://github.com/t-crew/memory-pulse.git
cd memory-pulse && node server.mjs brief --offline

The second command prints the corrections in this repository's own committed ledger, so you see the output format before installing anything.

What each host runs

Read from server.mjs and hooks/hooks.json, 2026-10-21.

First run

The hooks stay silent in a project that has no ledger: brief prints nothing and exits 0. The first remember creates .memory-pulse/events.jsonl, from a tool call or from the shell: