jevmemjevmem

Shared project rules and memory for AI coding agents in Claude Code, Cursor and Codex.

What is jevmem?

Claude remembers you. jevmem makes your project's rules stick, across your agents and your teammates. jevmem saves your project's decisions, rules and failed approaches from your chats to one file in your repo, JEVMEM.md, that Claude Code, Cursor and Codex read, and checks Claude's commands against those rules before they run. Your teammates get the same file through git. It works beside Claude Code's own auto memory and adds what that doesn't have: the guard, a shared file in git, and the other tools. It is open source (MIT), built on TypeSafe AI's Jev, in Anthropic's Claude plugin directory and on the MCP Registry, and it works with Claude Desktop over MCP.

Last updated: · jevmem 0.7.8 · Install · Source on GitHub

Watch the film

Three ways teams use it #

1. The guard: a rule Claude checks before it acts #

Your team decided "don't hand-edit db/migrations/: those files are generated". Three weeks later, in a fresh session, Claude is about to edit one. Before the edit runs, jevmem checks it against the rules in JEVMEM.md, and Claude Code stops and asks you first, with the rule:

Claude wants to edit a generated migration, jevmem finds the team's rule in JEVMEM.md, and Claude Code asks you before the edit runs.Claude wants to edit a generated migration, jevmem finds the team's rule in JEVMEM.md, and Claude Code asks you before the edit runs.

jevmem: this may break a saved rule: "Don't hand-edit db/migrations/: those files are generated." (JEVMEM.md)

In our tests (0.7.7, checked by hand), a change a rule forbids was left in the code in 0 of 15 sessions with jevmem on. The guard checks Claude's commands, file edits and file writes in Claude Code, and jevmem trust lets a rule you wrote block the call instead of asking (the guard).

2. The team: one file, shared through git #

On Monday you tell Claude "we use pnpm, not npm". jevmem saves it as a line in JEVMEM.md, and you commit it with your code. On Tuesday your teammate pulls and opens the repo in Cursor: with the jevmem plugin, the agent looks up the project's rules before a task, and the pnpm line is there, because it travelled with the code through git. Codex reads the same file over MCP when the agent asks, and in Claude Code the guard checks an npm install against the rule before it runs.

On Monday you tell Claude Code we use pnpm, not npm; jevmem saves it to JEVMEM.md, committed with your code; on Tuesday your teammate's Cursor agent looks up the rules and finds it.On Monday you tell Claude Code we use pnpm, not npm; jevmem saves it to JEVMEM.md, committed with your code; on Tuesday your teammate's Cursor agent looks up the rules and finds it.

3. No repeated mistakes #

You tried caching the API responses in memory, it broke the build, and you kept Redis. jevmem saves that as a failed approach, with the reason. Next month, when a prompt comes near it, Claude gets it back as "Already tried: …" with the reason, and in Cursor and Codex the agent finds it when it looks up the project's memory, so an idea you already ruled out stays ruled out. In our tests, an approach that had already failed was repeated in 0 of 15 sessions with jevmem, against 3 of 15 without.

An in-memory cache broke the build; jevmem saves it as a failed approach with the reason; next month Claude gets it back as Already tried.An in-memory cache broke the build; jevmem saves it as a failed approach with the reason; next month Claude gets it back as Already tried.

Beside Claude Code's memory #

Claude Code keeps notes of its own, auto memory, on your machine. jevmem runs beside it and adds the parts a team needs:

Claude Code's auto memory jevmem
Saves from your chats Yes Yes: decisions, rules, failed approaches, bugs, to-dos
Where it keeps them Notes on one machine, under ~/.claude/projects/ JEVMEM.md in your repo, shared through git
Checks commands and edits against your rules before they run No Yes, the guard
Works in Claude Code Claude Code, Cursor, Codex, Claude Desktop

Run both: the guard leaves auto memory's own notes alone (0.7.7), and the two side by side, measured, are below.

In numbers #

In real Claude Code sessions on three small test projects, with jevmem and without it:

My own test sets, each number from one run; none is an independent benchmark. Method and results

What was measured #

The method and the limits of each number: Does jevmem work?

How it works #

You chat as usual. When you decide something, jevmem writes it as one line in a file in your repo, and brings the right lines back next session.

You say it, Jev decides, jevmem writes one line to JEVMEM.md, and next session Claude gets the lines that matter.You say it, Jev decides, jevmem writes one line to JEVMEM.md, and next session Claude gets the lines that matter.

  1. You decide something in a chat: "We use Postgres."
  2. jevmem asks Jev by TypeSafe AI, a model that answers yes/no questions with probabilities, whether it's worth keeping.
  3. If it is, jevmem writes one line to JEVMEM.md in your repo.
  4. Next session, the lines that matter for your prompt go back to Claude.

Change your mind, and the old line is crossed out: kept for history, not sent to Claude. Your team gets the same file through git.

jevmem keeps decisions, rules, bugs, to-dos and dead ends (an approach that was tried and failed, with the reason).

- [superseded] We'll use SQLite as the primary store for now. → id:cuasaq
- [decision] Switch the primary store to Postgres 16.
- [constraint] Node 20 is the minimum supported version, and CI runs Node 20 and 22.
About these lines

Each line also carries a comment with its id, time and confidence, left out above. The full lines:

- [superseded] We'll use SQLite as the primary store for now. → id:cuasaq  <!-- id:21ycba ts:2026-09-26T13:46:34.703Z conf:1.00 by:cuasaq -->
- [decision] Switch the primary store to Postgres 16.  <!-- id:cuasaq ts:2026-09-26T13:46:35.240Z conf:1.00 -->
- [constraint] Node 20 is the minimum supported version, and CI runs Node 20 and 22.  <!-- id:tollba ts:2026-09-26T13:46:35.763Z conf:0.90 -->

Real lines from 0.5.7's default writer, which 0.5.8 to 0.5.10 did not change (the run, 2026-09-26). It kept one sentence of each turn: the Postgres turn also said "SQLite locks up under concurrent writes", and that reason was left out. Since 0.6.0 the line is made from the sentences Jev picks, the one that states the memory and the one that gives its reason (What's new). With writer set, an OpenAI or Anthropic model condenses the whole turn instead.

Install #

You need a TypeSafe API key, which jevmem's requests are billed to, and Claude Code 2.1.273 or later.

  1. In the Claude app: Plugins → Discover → jevmem → Add.
  2. Install the CLI the plugin runs:
    npm install -g jevmem
    
  3. In your project's folder, finish the setup in one go (it asks for your key without showing it, turns jevmem on in that folder, and checks the setup):
    jevmem setup
    

Start Claude Code in that project. If you start it before the setup is done, the plugin says once what is left; jevmem doctor checks the setup any time.

Other ways to install: the jevmem marketplace, npm, Cursor, Codex

From the jevmem marketplace:

npm install -g jevmem
claude plugin marketplace add Avinash-jetwani/jevmem
claude plugin install jevmem@jevmem
claude plugin install jevmem-pane@jevmem   # the side pane (0.7.5), optional
cd your-project && jevmem setup

With npm only (also sets up Cursor and Codex):

npm install -g jevmem
cd your-project
jevmem init --tool claude    # or cursor, codex, claude-desktop, all

In Cursor, the jevmem plugin (0.7.6) carries the hooks, the MCP server and the rule for every window: install it from the Cursor Marketplace once it is listed there, or copy this repository's cursor-plugin/ folder to ~/.cursor/plugins/local/jevmem and reload the window; then jevmem setup in each project (the steps). jevmem is also listed on cursor.directory; its Add to Cursor button installs the MCP server alone (recall, with the entry in docs/mcp.md), so saving still needs the plugin folder or jevmem init --tool cursor.

Already have a CLAUDE.md? jevmem import shows what it would add from it; --apply writes it.

Every step, and what to do if the plugin can't find the CLI: docs/install.md.

Works with #

Saving is automatic in Claude Code and, since 0.7.4, in Cursor, where Cursor's hooks save each finished agent turn (since 0.7.6 from the jevmem plugin for Cursor, or from the files jevmem init --tool cursor writes); and in Codex while jevmem watch runs. Cursor, Codex and Claude Desktop reach jevmem over MCP, a standard way for an AI tool to call another program, when the agent asks for it; the Cursor plugin's server runs in every window, while a project's own .cursor/mcp.json server starts off until you turn it on once (the step). In Cursor, on 10 held-out chats captured before the code (24 turns), the first run paired 21 of 24 turns whole, the prompt with the whole reply; a reader fix came from that run, and the second run paired 24 of 24, with what to save right in 21 of 24 (measured).

Saving Bringing it back
Claude Code Automatic, every turn Automatic, every prompt
Codex Automatic while jevmem watch runs When the agent asks, over MCP
Cursor Automatic, every finished agent turn (0.7.4; the plugin since 0.7.6) When the agent asks, over MCP (the plugin's server runs in every window; a project's own server needs one toggle in the Cursor app, the step)
Claude Desktop When you ask it to, over MCP When you ask it to, over MCP

The MCP server is on the MCP Registry as io.github.Avinash-jetwani/jevmem. Client setup: docs/mcp.md · docs/install.md.

The questions this site answers #

The limits, in short #

Every limit, with the numbers: the FAQ.