Project memory for AI coding agents

Your coding agents keep solving the same bugs twice.

You write down the big decisions; the hundred small fixes vanish — until now. Rainman captures the routine fixes and decisions that usually disappear between sessions, and brings them back the moment the problem returns.

$ pip install rainman-memory watch it work ↓

local by default · MIT · 300+ tests · zero dependencies · secrets redacted · every memory has provenance

the aha moment — one bug, two sessions, three weeks apart

~/your-project

Illustrative replay of a real Rainman workflow — the failure→fix pairing and error-conditioned recall it shows are reproducible from the repo.

how it works — three steps, no step four

1 · install once

pip install rainman-memory

Then rainman setup. Two minutes, one time. Automatic with Claude Code, via MCP in Cursor/VS Code/Windsurf, via a git hook anywhere else.

2 · just work

Rainman takes the notes.

Rainman captures the routine fixes and decisions that usually disappear between sessions — you never write anything down.

3 · next time

The answer is already there.

When the same problem returns, your agents get the old fix instantly — instead of solving it all over again.

one memory, everywhere

any LLM

No vendor lock-in.

Rainman never talks to a model. Teammates on Claude, GPT or Gemini share the same project memory — it belongs to your repo, not to an AI vendor.

every agent

All your agents, one memory.

Built for many agents working at once — safe concurrent reads and writes to the same store. One agent’s fix becomes every agent’s knowledge.

local & cloud

It travels with the repo.

Memory lives in a .rainman/ folder and commits to git — every clone gets it: laptop, cloud dev environment, CI.

what “automatic” means in your tool

Claude Codefully automatic — lifecycle hooks learn as you work
Cursor · VS Code · WindsurfMCP recall + shared project memory
any editorgit-based auto-learning via a post-commit hook

the ledger — why notes and CLAUDE.md aren’t enough

The problem with your agent’s memory is you.

An honest week in your repo: nine things broke and got fixed. You wrote up the outage and one decision — of course you did. The other seven live only in the right-hand column, which is the one your agents read from next week:

when what broke & got fixed your notes rainman
Mon 09:14 TimeoutError: QueuePool limit of size 5 reached postmortem logged
Mon 16:40 KeyError: 'next_cursor' on the last page never written down logged
Tue 11:02 AssertionError: test_billing_rollover, some mornings only never written down logged
Tue 15:27 TypeError: datetime is not JSON serializable never written down logged
Wed 10:31 ExpiredSignatureError: mobile clocks drift decision logged
Wed 17:55 ModuleNotFoundError: in the container, not locally never written down logged
Thu 12:08 KeyError: 'STRIPE_TEST_KEY' during CI collection never written down logged
Fri 09:47 UnicodeEncodeError: 'charmap' can’t encode '✓' never written down logged
Fri 14:33 Timeout: lock still held by the test that failed never written down logged
what your agents can remember next week 2 / 9 9 / 9

reproducible · deterministic · no LLM in the loop

Coverage is the ceiling.

When an old error recurs, can retrieval surface the old fix? Grep over your notes works almost perfectly on what you wrote — it just can’t read a note that was never written. Rainman recalls from what the hooks captured, conditioned on the error itself. No query. No discipline.

Fig. 1 — lazy-notes bench

12/12 recurring incidents surfaced in our reproducible local benchmark

old fix in the top-5 when its error recurred — by how often you write down routine fixes

Rainman — auto-learned store, 60 junk cards included grep your notes — curated, noise-free file

Deterministic bench: 12 incidents whose errors later recur; the notes file is curated and noise-free while Rainman’s store carries 60 auto-learn junk cards; result holds at 200. The honest part: at 100% diligence it’s a tie — the advantage is coverage, not ranking. Nobody keeps 100% diligence. Reproduce: eval/local_demo/lazy_notes_bench.py.

Outside signal, same direction: Databricks’ coding-agent benchmark concluded “model choice is only one piece of the puzzle” — their best harness sent ~3× less context per turn at equal quality. Independent study; Rainman wasn’t part of it. Read it →

how it compares

Different tools, different trade-offs.

Every approach below genuinely works for someone. Here is where each one spends and saves — so you can pick honestly.

Rainman notes / CLAUDE.md claude-mem cloud memory APIs vendor built-in memory
how memories get captured automatically, from your agents’ work (hooks / MCP / git) you write them by hand AI compresses each session API calls you wire in automatic, inside one vendor
cost to remember zero — no LLM calls, no API free (your discipline) LLM tokens per session paid API + tokens bundled, vendor-priced
where your data lives plain files in your repo plain files in your repo local embeddings DB their cloud vendor’s cloud
tied to one AI vendor? no — MCP + git hook, any LLM no several agents supported no (via their SDK) yes
recalls the fix by error signature yes — failure→fix cards, error-conditioned recall grep, if you wrote it down summary recap semantic search opaque
retrieval you can audit deterministic math + reproducible benchmark ctrl-F embeddings embeddings / LLM no visibility
runtime dependencies zero — Python stdlib none Node + vector store SDK + service n/a

Based on each project’s public documentation, July 2026. These are different jobs more than competing products — session recap, hosted memory platforms and project-local recall can coexist. Corrections welcome — open an issue.

pricing

Free today. More coming soon.

The full memory engine is open-source and free forever — everything you need to start right now. Two more plans are on the way.

available now

Free

$0forever

for every developer

  • The full memory engine, on your machine
  • Recall, auto-learn, failure→fix cards
  • Works with Claude Code, Cursor, Zed, VS Code…
  • Local audit log & policy
  • No LLM calls, no network calls — you control what’s committed and pushed
pip install rainman-memory

Pro

Your personal, cross-project memory — synced across your machines without touching any repo.

Coming soon

join the waitlist →

Team

A private memory server for your org — nothing committed to the repo; permissions, SSO, tamper-evident audit.

Coming soon

join the waitlist →

q & a — real questions from the first week

Asked by actual developers.

Does it work with Cursor / VS Code / Windsurf — or only Claude Code?

Both, differently. Claude Code gets the fully automatic experience (lifecycle hooks learn as you work). MCP editors — Cursor, VS Code, Windsurf, Zed — get the same shared memory through the standard recall/remember tools (rainman setup --host cursor writes the config). Any other editor can auto-learn through a git post-commit hook.

What if teammates use different LLMs — Claude, GPT, Gemini?

That’s the core design. Rainman never talks to a model: memory is plain files ranked with plain math, exposed over MCP. Teammates on different AI tools read and write the same project memory. It belongs to your repo, not to an AI vendor.

We work locally and in the cloud. Does memory follow?

Project memory lives in a .rainman/ folder and commits to git — so every clone has it: laptop, cloud dev environment, CI. Your personal cross-project memory doesn’t ride in any repo; syncing that across machines is the upcoming Pro plan.

Can several agents use it at the same time?

Yes — the store is built for concurrent access (file locking, atomic writes), so parallel agents on one project read and write safely. One nuance: agents pick up new memories when they start a session or recall — it’s a shared notebook, not a live broadcast into a mid-conversation agent.

Hooks run automatically. Why should I trust that?

Fair question — hooks are code that runs on your machine. What we do about it: the hook config is written to settings.local.json (machine-local, never committed — since v0.1.2), the hooks themselves are small open-source adapters with zero dependencies beyond Python’s stdlib, and releases are Sigstore-signed with an SBOM. Don’t want hooks at all? Run MCP-only: claude mcp add rainman -- python -m rainman serve gives recall/remember with no automatic execution.

Does any of my code or data leave my machine?

Rainman makes no LLM calls and no network calls — you control what’s committed and pushed. Auto-learned content passes secret redaction (pattern-based — honest caveat: patterns aren’t perfect), sensitive paths are skipped, and org policy can enforce extra redaction and path denylists that projects can’t override. For client-sensitive repos you can disable auto-learn entirely and add memories manually.

Won’t the memory fill up with junk over time?

That’s the failure mode we engineered against: a salience gate keeps trivia out at write time, near-duplicates merge, unrecalled noise decays (rainman consolidate), the store is capped, and recall has a relevance floor — if nothing relevant exists, it returns nothing rather than confident noise.

Is this production-mature?

It’s v0.1.x from a solo developer — early, and we won’t pretend otherwise. What you get today: 300+ tests, a published threat model, signed releases, and a reproducible benchmark. Our own advice: try it on a non-sensitive repo first, and judge it by what it recalls in week two.

Why not just keep a MEMORY.md and grep it?

Genuinely fine — if you keep writing it. Our benchmark’s honest finding: grep over notes retrieves what you wrote nearly perfectly; its ceiling is what you wrote down, and at realistic discipline that was 25% of recurring incidents vs 12/12 for auto-capture. The advantage isn’t smarter search — it’s that nobody has to remember to write.