memory-pulse gives any agent self-improving memory you can trust in production.
Every correction you make is kept, put in front of your agent when it matters, and enforced. Built-in memory security stops a stored note from instructing your agent and shows any edit to the record.
One line, any shell
curl -fsSL https://pulse.strategic-innovations.ai/install.sh | bashThe script prints its plan first, installs the Claude Code hooks, adds the Codex hooks when codex is on PATH, registers the MCP server, and runs nothing as root. Append -s -- --dry-run after bash to see the commands without running them.
Claude Code plugin, typed inside Claude Code
/plugin marketplace add t-crew/memory-pulse
/plugin install memory-pulse@memory-pulseThe plugin installs the four tools, a SessionStart brief, the PreToolUse guard and a skill. Claude Code put the always-on cost at ~120 tokens on 2026-09-01.
Codex CLI plugin
codex plugin marketplace add t-crew/memory-pulse
codex plugin add memory-pulse@memory-pulseThen open Codex, run /hooks and trust the three memory-pulse entries. Codex runs no hook you have not reviewed.
npm, global install
npm i -g memory-pulse
memory-pulse install-hookinstall-hook writes four hooks into ~/.claude/settings.json: the brief, the guard and the compaction handoff. Add --codex for Codex and --project to commit them into the repository.
Any MCP client, no plugin
claude mcp add memory-pulse -- npx -y memory-pulse
codex mcp add memory-pulse -- npx -y memory-pulseCursor and other JSON-configured clients register command npx with args -y memory-pulse; the guide shows the block. The brief and guard hooks run in Claude Code and Codex only.
From source
git clone https://github.com/t-crew/memory-pulse.git
cd memory-pulse && node server.mjs brief --offlineOne file with no dependencies. The second command prints the corrections in the repository's own committed ledger, so you see the output format before installing anything.
Claude Desktop, Cursor, Python and every other route, with what runs on each
$ codex exec "write pricing.md: price is $49"hook: SessionStart CORRECTIONS (1) — read before quoting any number: ! price-49-launched -> price-corrected-to-29 — WTP is $29hook: PreToolUse apply_patch pricing.mdhook: PreToolUse Blockedmemory-pulse guard: blocked. pricing.md: • "$49" was withdrawn at ledger t2: price-49-launched -> price-corrected-to-29 — use $29Use the corrected value (a comparison naming both goesthrough), record a new correction, or record an override.
The same check, running in your browser
The memory on the left is editable, and the file on the right is checked against it before anything lands. This is the rule that runs on every edit an agent makes, so the answer here is the answer in your editor. No model is involved and nothing leaves this page.
The verdict follows the text as it changes. An edit naming the replacement beside the old value goes through, since it is a comparison. A correction recorded here binds the next edit immediately. In the hook, a blocked verdict exits 2 and the agent reads the text shown here.
What developers report in public trackers
Most memory products put the memory into the model's context and stop there. The reports below keep landing on the same gap, which is that an agent can have the correction in front of it and still not follow it.
“The one rule whose remedy was mechanical, a test in the repository that fails when the banned pattern appears, has not regressed since.”
“The memory system becomes write-only. Data goes in but doesn't reliably influence behavior.”
“Agreeing with a rule is not complying with it.”
“An uncited memory is an assertion the model has to either trust or ignore. A cited one is evidence it can weigh.”
Walk your memory in three dimensions. Raycast-packed into a procedural cortex mesh modeled in Blender, with live causal wavefronts, multi-source lobes, and red fibres across retired notes. Runs completely offline in WebGL.
Built-in security for agent memory
Memory an agent reads is an input it acts on, so memory-pulse treats it like one. Each item below is plain code in the open-source client or the engine, and each one runs on every write or read.
| Memory cannot instruct your agent | A note that reads like an instruction is held back when it is written and again when it is read, by nine checks you can read in the client. It is reported to you and never passed to the agent, including notes that arrive through git or an import. |
|---|---|
| Every edit to the record shows | Each row is hash-chained to the one before it. memory-pulse verify names the first row that was edited, removed or inserted, and every check run on a broken record says so. |
| Corrections are enforced | On Claude Code and Codex, an edit that writes a retired value back is blocked before it reaches the file, and the block names the row that retired it and the value to use. |
| Receipts anyone can check | On Pro and Enterprise each check returns a signed receipt, and anyone can verify it at /v1/verify without your key. |
| Nothing of yours on our side | The record is a file in your repository. Reads go to the engine and the answer comes back; the engine keeps no database of your memory. Usage counts are off unless you turn them on. |
How it works
A correction is recorded once. Every later session opens with what was already decided, and an edit that walks it back is stopped and returned with the reason. A stopped edit becomes the next correction.
The correction, recorded once
Findings, decisions and dead ends are written one per entry to .memory-pulse/events.jsonl in your repository. A correction names the exact values that are now wrong and what replaces them. Writing is local and works offline, so nothing waits on a network call.
Every session opens with what you already decided
At session start the hook prints a short brief. Corrections come first at every brief size, then the chain of what caused what, then recent events. At its smallest the brief is about 1% of the whole history.
The bad edit never reaches your branch
Before each Edit, Write, apply_patch or shell write, the guard checks what the change introduces against the values you retired and any rules you declared. A blocked edit quotes the line that retired the value. An edit that names the replacement alongside the old value goes through.
The same corrections, enforced on the pull request
The same corrections that hold your agent hold the pull request, so a change that walks one back fails the check before a reviewer sees it. Showing an agent a correction is measurably not enough. TRACE (arXiv 2606.13174) measured that with Mem0 memory, 57.5% of applicable preference checks were still violated. Every check answers in one of three ways, and the empty case is reported as empty.
The change agrees with the ledger
The verdict names the recorded events that bear on the edit.
It writes a withdrawn value back
The verdict names the ledger line and date that retired the term, and the replacement to use. In a hook it exits 2. On a pull request it fails the check.
The ledger has nothing to say
Reported as exactly that, and never as a pass. The hook stays silent, because a hook that comments on every edit livelocks the agent. check --ci prints it, and on a pull request it is neutral.
memory-pulse blocked this change. 1 withdrawn value(s) reintroduced
This change writes back a value the ledger retired, or trips a declared invariant. The verdict cites the line that binds.
- "published as 0.1.8" was withdrawn at ledger t1: client-0.1.9-published -> versions-0.1.6-to-0.1.8-never-existed-on-npm — use 0.1.9
- uses: t-crew/memory-pulse@v0
with:
ledger: .memory-pulse/events.jsonl
What your agent gets
Four tools your agent can call, and the checks that run whether it calls them or not.
Findings and corrections, written to the local ledger, offline. Corrections do not decay and always sort first, so a withdrawn number does not come back three sessions later. A correction that would bind nothing is recorded and says so, rather than passing quietly.
A short brief of what happened on a project you left three weeks ago, corrections first, sized to the budget you give it.
What caused X, and what X caused. Every answer carries a confidence score and the recorded links verbatim, and when the confidence is too low it returns nothing.
Questions that need the whole history, answered without the whole history entering context. The code runs in a sandbox and only its answer comes back.
Blocks an Edit, Write, apply_patch or shell write that reintroduces a withdrawn value. A heredoc or a redirect has its target and content read from the command, with nothing executed. Each file in a patch is checked under its own path, so overrides and invariants keep their scope.
A correction typed in an ordinary prompt is recorded without you stopping to file it. Both shapes count: swapping one value for another, and prohibiting one outright. Deterministic patterns, and a pasted document is never read as an instruction. Turn it on with install-hook --ambient, or add one UserPromptSubmit entry running memory-pulse observe; the guide shows it.
A note you or a teammate stores can be read by the agent as an order. One that reads like an instruction is held back when it is written and again when it is read, then reported to you and kept out of the agent's context. The checks are plain code you can read.
If corrections go missing, the file shrinks, or usage jumps, the next brief tells you. memory-pulse checks a signed summary of your memory each session, so a file that changed underneath you does not stay quiet.
The same memory gives the same brief every time, so you can diff two sessions and trust the difference. A weak match still cannot bury a correction.
The memory as a 3D brain you can walk
Every connected source — your repository's ledger, agent memories, and markdown notes — is unpacked into physical lobes inside a procedural 3D cortex modeled in Blender 5.2. Live causal wavefronts fire across synapses, and red fibres show where corrections retire stale notes.
Interactive Memory Atlas
Raycast packing into cortex volume · multi-hop causal wavefronts · zero-CDN self-contained offline runtime.
Measured on our own ledger
Measured on the ledger of the project that builds memory-pulse, a 767-event file of 1.08 MB, measured 2026-09-01. The ratios depend on ledger size. A ten-event ledger has nothing to compress, and the brief will tell you so.
Your memory stays in your repository
Your memory is a file in your repository. We keep no copy of it unless you turn on hosted memory for a project, and turning it off erases ours.
| Your ledger | a local file at .memory-pulse/events.jsonl. You can commit it, grep it or delete it. |
|---|---|
| Writes | local, offline and free. |
| Reads | events go to the engine over TLS and the answer comes back, then the request is forgotten. Unless you turn on hosted memory, no copy of your memory exists on our side. |
| Hosted memory | opt-in, per project, on paid plans: memory-pulse state push and pull move the ledger between your machines through a copy we hold. Turning it off, deleting the project or deleting your account erases our copy. |
| Persistence | your corrections are the file in your repository, plus a signed summary you keep, so without hosted memory there is nothing on our side to migrate, leak or back up. |
| The client | zero dependencies, MIT licensed, readable on GitHub. The plugin hooks run that file, so what enforces your corrections is the version you installed. |
For agents reading this page
Every page is available as Markdown, the site map is plain text, and the server card has what a client needs to connect.
# this page, as Markdown curl -H "Accept: text/markdown" https://pulse.strategic-innovations.ai/ # the map curl https://pulse.strategic-innovations.ai/llms.txt # how to connect curl https://pulse.strategic-innovations.ai/.well-known/mcp.json
- llms.txt says what memory-pulse is, in the order an agent should read it
- MCP server card with package, transport, tools and the hosted engine
- API catalog (RFC 9727) listing the engine's endpoints, including the keyless verify
- robots.txt with Content Signals, where search and AI input are allowed and training is declined
- Unknown paths return 404, so a /.well-known/ hit here is a real endpoint
Questions people ask before installing
Short answers, with the detail and the measurements in the sections above.
What is memory-pulse?
memory-pulse carries a correction across sessions. It is recorded once, printed at the top of every session, and a guard hook blocks an Edit, Write, apply_patch or, in Claude Code, a shell write that reintroduces the withdrawn value, quoting the line that retired it. The memory is a file in your own repository. Four MCP tools, about 900 tokens of definitions.
Which agents and editors does it work with?
Claude Code and Codex CLI as plugins (SessionStart memory, per-prompt context and the PreToolUse guard), Cursor and any stdio MCP client via npx -y memory-pulse, and GitHub Actions as Memory CI, which fails a pull request that writes a withdrawn value back. The client is MIT licensed, with zero dependencies.
How is this different from Mem0, Zep or CLAUDE.md?
Those make memory available to the agent. memory-pulse also enforces it. TRACE (arXiv 2606.13174) measured that with Mem0 memory, 57.5% of applicable preference checks were still violated, so the guard checks each edit before it lands. Your ledger stays in your repo and the hosted engine keeps no database of it. The compare page covers when not to pick us.
Where does my memory live, and what does the engine store?
Your ledger is a local JSONL file in your repo at .memory-pulse/events.jsonl. Writes are local, offline and free. Reads send events to the engine over TLS, the answer comes back, and the request is forgotten. The engine stores license keys and usage counters and no ledger content, unless you turn on hosted memory for a project (paid plans): then it keeps a copy of that project's ledger until you turn it off, which erases it.
What does it cost?
Free covers ledgers up to 500 events and 200 reads a day, with no account. Starter is $7 a month for 5,000 events, 1,000 reads a day and the memory-pulse skill. Pro is $19 a month for 20,000 events, unlimited reads and signed check receipts. Enterprise is $79 a month for 250,000 events, 10 team seat keys and receipts anyone can verify without your key. 14-day refund.
What happens when the ledger has nothing to say about an edit?
The verdict is no evidence, reported as exactly that and never as a pass. The hook stays silent, because a hook that comments on every edit livelocks the agent. check --ci prints it, and on a pull request it is neutral. The three verdicts are verified, blocked and no evidence.
When one engineer corrects the agent, every teammate's agent keeps the correction
On a team, the same mistake gets corrected again in each engineer's session, because each agent starts from nothing. memory-pulse keeps one record of corrections in your repository. Every teammate's Claude Code or Codex session starts from it, and an edit that writes a retired value back is stopped before it reaches the file. When you need to show that a change was checked against the team's corrections, the engine signs a receipt for the check, and anyone can verify it without your key.
| Shared corrections | The record is a file in the repository, so a clone carries every correction. Hooks committed with install-hook --project travel with it. This part is free. |
|---|---|
| Both hosts | One record serves Claude Code and Codex. On Codex each engineer approves the hooks once with /hooks, because Codex runs no hook it has not been shown. |
| What reaches the agent | The organized record at the start of every session, and the corrections that bear on each prompt. On Claude Code, the ones that bear on each edited file as well. On Codex 0.160.0 the per-file part did not reach the model in our test, so there the guard blocks and the session record informs. |
| Receipts | A signed verdict for each check, and a certificate of the record from which any later change to the record shows. Verification is free and public. |
| Seats | One subscription issues a key to each engineer. A key you revoke stops working at once, and every key stops when the subscription ends. |
| The pilot | 30 days, $20 per seat a month, five seats at least, the first month refundable. We set it up with you and check in each week on what was corrected and what was blocked. |
Your agents can leave each other messages on one board, and an edited message shows to every agent that reads it
When a coding agent and a reviewing agent work on the same project, each one starts without knowing what the other found. memory-pulse 0.8.0 gives them a shared board, a file every agent can post to and read. Point each agent at the same path with MEMORY_PULSE_BOARD and they can ask, answer and acknowledge each other by name.
| Post, read, reply, acknowledge | A message has a sender, an addressee (one agent, or all of them), a kind (note, request or reply), a title and a body. Each agent reads its own unread messages. A reply lands in the original sender's list, and an acknowledgement takes a message off one agent's list while the board keeps it. |
|---|---|
| Any edit shows | The board is kept the same way as your project's record. If anyone changes a message after it was posted, memory-pulse board verify names the break, and every agent that reads the board is told the record no longer checks out. |
| Nothing runs on its own | Posting runs nothing. The board does not wake, schedule or prompt an agent. Each agent reads the board when it next checks, so if you want an agent to act on a message, you start that agent. |
| A message is information, not an order | Text that reads like an instruction is stored, marked, and shown quoted, so the reading agent sees it as another agent's words. Board messages never enter your project's corrections, the session brief or the guard. |
| Who talked to whom | memory-pulse board html writes one offline page showing which agents wrote to which, every thread, and whether the record checks out. |
| Any MCP client, and Python | With MEMORY_PULSE_BOARD set, the MCP server adds two tools, board_post and board_read, so an agent can use the board without a shell. The Python client reads and writes the same board. |
| Price | The board is a local file and works on every tier, including Free. |
export MEMORY_PULSE_BOARD=~/shared/board.jsonl npx memory-pulse board post --from reviewer --to coder --kind request --title "run the migration tests" --body "Before the schema change merges." npx memory-pulse board read --as coder npx memory-pulse board reply 1 --as coder --body "Passed. The log is in ci/migration.log." npx memory-pulse board ack 1 --as coder npx memory-pulse board html --out board.html
Pricing
Recording corrections is free on every tier. The paid tiers cover hosted reads as a project grows.
- ledgers to 5,000 events
- 1,000 reads a day
- the hosted memory: ranked brief, recall and code mode
- the memory-pulse skill
- cancel any time
- ledgers to 20,000 events
- unlimited reads
- signed check receipts for Memory CI
- one env var to activate · cancel any time
- ledgers to 250,000 events
- 10 team seat keys, revocable, one subscription
- show your memory file was not altered, from anywhere, without your key
- cancel any time
A receipt lets an auditor confirm your memory file was not altered, and they can do it without your key and without anything from us. Receipts show nothing was substituted, and a substituted, deleted, reordered or truncated event fails by name. They are hash-chained and signed by the engine, and the verify endpoint is free and public. There is a 14-day refund with no questions asked, and a cancellation shows as lapsed.