Projectmem

Projectmem takes a different position from most AI memory tooling. Mem0 and Letta are memory stores — you put things in, you get things out, and the value depends on what your application does with them. Projectmem is built around a narrower claim: your coding agent should know what already failed in this repository, and it should be told at the moment that matters. That moment is the commit. `pjm precheck` reads the failure history of your staged files before the commit lands and names the dead ends you already tried plus decisions that have gone stale. Pair it with the git hooks — every revert becomes a failed attempt, every fix commit a fix event — and you get automatic capture with zero manual logging. That combination is the real product. The MCP server, the 17 tools, the dashboard, `pjm score`: those are delivery and measurement around it. The delivery side is genuinely well thought through. One MCP server entry serves every project because there is no `--root` and no cwd pinning, which is the thing that usually forces you into per-repo configuration. The transport is stdio, so there is no database and no persistent server to keep alive. Memory is a plain `events.jsonl` you can grep. `pjm doctor` looks where code lives — `~/Developer`, `~/code`, cloud folders, every drive on Windows — and flags a client still pinned to a single repo, which the vendor calls the most common reason a new project stays invisible to your agent. Cross-project memory at `~/.projectmem/global/` carries library gotchas between repositories: the vendor's example is an SQLAlchemy async-session leak learned once getting injected before line one of the next project. The token math is published rather than asserted. A session without memory burns 5,000–20,000 tokens re-reading source files; reading distilled memory over MCP costs about 800–1,500; markdown-only Universal Mode sits around 2,500; `pjm wrap` pre-injection is 500–2,000 depending on the budget you set. There is also a compounding effect the vendor is honest about: when the warning lands, the agent skips a failed debugging round it would otherwise have spent about 3,000 tokens on. Where it does not fit. The capture layer is git hooks, so projects outside git get nothing — and commit hygiene matters, because squashing, rebasing and force-pushing degrade the event log. Setup needs Python plus a hand-edited MCP client config. Everything lives on your machine, so moving laptops means moving files yourself. And the headline numbers — up to 50%+ tokens saved, roughly 12 hours of debugging saved per month — are produced by the vendor's own `pjm score`, not independently measured. Treat them as a measurement framework you can run yourself rather than a third-party benchmark. The honest framing is that Projectmem makes a modest, verifiable claim rather than a broad one: it reduces repeated mistakes in git repositories, it proves it with a score you can compute, and it costs nothing and sends nothing anywhere. If