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.
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:
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.
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.
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:
- Tried a change the project forbids: in 0 of 18 sessions with jevmem, against 10 of 18 without.
- Claude followed the project's earlier decisions: in 66 of 72 sessions with jevmem, 28 of 72 without (about 9 in 10, against 4 in 10).
- Repeated an approach that had already failed: in 0 of 15, against 3 of 15.
- Saving: about 19 cents per 1,000 messages and under a fifth of a second to decide, in the background: Claude doesn't wait for it.
- Bringing lines back: about a third to half a second on each prompt, which Claude waits for; the time and the cost grow with the file.
- Next to Claude Code's own auto memory (0.7.7, 558 sessions on three new projects): Claude followed a line taught in an earlier session in 47 of 54 sessions with auto memory alone, 40 with jevmem alone and 45 with both; after reading every miss by hand, 49, 40 and 48. With jevmem on, no change a rule forbade was left in the code (0 of 15, checked by hand, against 1 of 15 with auto memory alone). Details.
- To be fair: a
CLAUDE.mdyou keep up to date by hand did about as well (67 of 72), and better on one convention nothing in the prompt points at (3 of 3 against 0 of 3). jevmem keeps a file like it up to date for you, and since 0.7.1 marks such rules always-on, so they reach every session: 18 of 18 on six held-out tasks written for that gap, against 14 of 18 with 0.7.0.
My own test sets, each number from one run; none is an independent benchmark. Method and results
What was measured #
- The sessions above: 24 tasks in three small projects, 3 runs each, in real Claude Code 2.1.281 sessions with
claude-sonnet-5, on 2026-09-28 and 2026-09-29 (no memory and CLAUDE.md, jevmem). - The guard caught 66 of 68 rule breaks, with 3–4 false asks in 206 fine calls, on a held-out set of 274 tool calls, run once on 0.6.0 and once on 0.6.1 on 2026-09-30 (0.6.0, 0.6.1).
- Deciding what to save takes 0.16 s and costs $0.00019 per message, and was right on save or skip for 98.5% of 66 held-out turns (jevmem 0.7.7, one run, 2026-11-08, results).
- A local model in Jev's place was tried once, on 2026-10-02, with Ollaya 0.9.0 on an Apple M4 with 16 GB: on the same 66 turns Jev was right on save or skip for 65/66 at a median of 0.23 s a turn,
winnow:e4bfor 60/66 at 28.5 s, andlaya:typed-decisionsfor 19/66. One run each, on one Mac (Jev, winnow:e4b, laya:typed-decisions; more in the FAQ).
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 decide something in a chat: "We use Postgres."
- jevmem asks Jev by TypeSafe AI, a model that answers yes/no questions with probabilities, whether it's worth keeping.
- If it is, jevmem writes one line to
JEVMEM.mdin your repo. - 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.
- In the Claude app: Plugins → Discover → jevmem → Add.
- Install the CLI the plugin runs:
npm install -g jevmem - 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 #
- How do I make Claude Code remember project decisions across sessions?
- How does jevmem compare with CLAUDE.md, Claude Code's auto memory and other memory tools?
- What is Jev used for in coding agents, and how does jevmem use it?
- Can Claude Code check commands against my project's rules before they run?
- How do I use jevmem in Cursor, Codex or Claude Desktop?
- How do I install jevmem?
- Does jevmem work?
- What leaves my machine?
- Do I need a key, what does it cost, can it run on a local model, and what are the limits?
- What changed in each version?
The limits, in short #
- jevmem needs a TypeSafe API key (where to get one, and the install steps).
- Message text is sent to TypeSafe to be scored, with common secrets scrubbed first (what leaves your machine).
- It is automatic in Claude Code and, since 0.7.4, in Cursor (as a Cursor plugin since 0.7.6, whose rule sits in every chat), automatic in Codex while
jevmem watchruns, and in Claude Desktop only when the agent calls it; in Cursor, bringing lines back is still the agent's call (what each tool does). - Rules every task must follow reach every session only when they are marked always-on (0.7.1), by Jev's reading or yours (jevmem next to CLAUDE.md).
- The guard is a backstop, not a sandbox (what it misses).
- The side pane is Claude Code only, 2.1.299 or newer: Cursor has no pane, and Claude Code for VS Code draws none yet (the pane).
Every limit, with the numbers: the FAQ.