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:

npx -y memory-pulse@0.16.1 remember pricing-shipped price-corrected --kind correction --withdrawn '$49' --replacement '$29' --note 'measured willingness to pay is $29'

before 0.6.0 is on npm, the same command from a checkout:

git clone https://github.com/t-crew/memory-pulse.git && node memory-pulse/server.mjs remember pricing-shipped price-corrected --kind correction --withdrawn '$49' --replacement '$29' --note 'measured willingness to pay is $29'

The hook command install-hook writes is npx -y memory-pulse guard, and npx resolves the package on every call: 0.99 s warm and 1.4 s cold (empty npm cache) per edit on an M1 Pro on 2026-10-16 with 0.8.0, against 52 ms for node server.mjs guard on the same ledger, which is the path the plugin runs. If the cost matters, install the plugin, or install globally and edit the hook command to memory-pulse guard.

Where the key goes

export MEMORY_PULSE_KEY=mp_live_... in the shell that starts Claude Code or Codex; the plugins and the hooks read the shell environment. On claude mcp add, pass --env MEMORY_PULSE_KEY=.... In Cursor, the env block above. Do not also run claude mcp add on a plugin install, or you get two servers.

Corrections are enforced, not only surfaced

Showing an agent a correction is not enough. TRACE (arXiv 2606.13174) measured agents re-violating more than half of the corrections they had been shown, with a memory tool installed. The PreToolUse guard sees every Edit, Write and MultiEdit in Claude Code, plus a Bash command whose write is literal in the command string (a heredoc, a redirect or a tee, read with nothing executed), and every apply_patch in Codex, where one patch may touch several files and each is checked under its own path. An edit that writes back a withdrawn value is blocked, and the agent is told which ledger line retired it and when. An edit that names the replacement beside the old value passes, because "was $49, now $29" is a comparison. Only a bare reintroduction is blocked. A shell command who