116,000 Stars vs. One Binary: claude-mem and palace-rs, Fact by Fact

claude-mem is the most popular memory plugin for AI coding agents. At the time of writing it has 116,434 GitHub stars.

palace-rs does the same job. It has 10.

Stars tell you what people clicked. They don't tell you what you have to install, what runs in the background, who writes your memories, or whether anyone measured if the thing finds the right memory. So I went through both projects' own READMEs, docs and source and wrote down what each one actually does.

Every claim below links back to something you can open. No guesses.

What you install

claude-mem (from its README and package.json, v15.18.1):

Node.js ^20.19.0 || >=22.12.0
Bun >=1.1.31, "JavaScript runtime and process manager"
uv, "Python package manager for vector search"
Chroma, enabled by default (CLAUDE_MEM_CHROMA_ENABLED: 'true'), run locally as chroma-mcp through uvx
A worker, "a local HTTP service managed by Bun", that takes tool activity from hooks, runs the observer, and serves the viewer and search

That's a JavaScript runtime, a second JavaScript runtime, a Python toolchain, a vector database and a long-running HTTP service.

palace-rs (from its README, v0.20.0):

One binary, one SQLite file, no API keys, no cloud.

No Python, no vector database, no Docker. One palace executable and one palace.db file.

Embeddings run on your CPU through ONNX Runtime. There's no server process to keep alive. The install script downloads the release binary, verifies its SHA-256 checksum, and you run palace install to wire up your agents.

Who writes your memories

This is the biggest difference, and it's a design choice, not a detail.

claude-mem uses an LLM to write your memory. In its own words:

Hooks in your agent hand each tool call (what it reads, edits and runs) to a small local worker.
A second agent turns that activity into short observations, and writes a summary when the session ends.

The default settings in SettingsDefaultsManager.ts are CLAUDE_MEM_PROVIDER: 'claude' and CLAUDE_MEM_MODEL: 'haiku'. So what ends up in memory is a model's summary of what happened, not what happened.

That second agent also has to be paid for by someone. The README lists three options: the hosted "claude-mem observer" (a 30-day free trial that asks for a payment method), your own OpenRouter or Gemini key, or your Anthropic plan. It then says:

With the observer, memory runs off-plan, so you get up to 100% more usage from your plan.

Read that the other way round: when memory runs on your plan, it's using your plan. And when the trial ends, "memory automatically falls back to your Anthropic plan unless you subscribe."

palace-rs stores text verbatim and uses no LLM.

Code, notes, and conversations are stored as written, not as an LLM summary that loses detail.

No API key, no model calls, no second agent, no subscription. Recall is hybrid search (BM25 fused with cosine similarity over local embeddings) plus intent-aware ranking. A local cross-encoder reranker is optional. Nothing in the memory path costs tokens to create.

Does it find the right memory?

A memory tool has one job: when the agent needs something from last week, return it.

palace-rs publishes its numbers. On LongMemEval s_cleaned (470 evaluated questions, each over a haystack of about 50 sessions and 115k tokens), stored the way Palace actually stores conversations:

Metric	palace-rs
R@1	0.915
R@5	0.987
R@10	0.996

From the README's method notes: "No LLM at any stage, no GPU." The one ranking weight picked on LongMemEval data was chosen on a different split (m_cleaned) and frozen before the run. Per-question-type results are published too, including the weakest category.

It also ships a coding-agent eval (51 questions like "why did we choose bundled sqlite?") that runs with one command:

cargo test --test coding_agent_eval -- --nocapture

The README says plainly that this eval is partly tuned, and prints the untuned numbers next to the tuned ones.

claude-mem's README publishes no retrieval benchmark. There's no LongMemEval score, no recall@K, no eval command. The token figures it does give ("~50-100 tokens/result" for the index, "~500-1,000 tokens/result" for full details) come with its own disclaimer:

The ratio is not a measured recall or end-to-end saving.

So for the most-starred memory tool in this space, there's no published number for how often it returns the right memory. For the 10-star one, there is, with the command to reproduce it.

Recall that doesn't depend on the agent remembering to search

Both tools use hooks. palace-rs installs four:

Session start injects your standing rules, recent diary entries for this project (from any agent), and the top memories of the project.
Prompt submit searches Palace with your actual question and injects matching memories before the agent answers (Claude Code and Codex).
Post tool use recalls related memory while the agent greps and reads files, so earlier decisions surface without a search.
Stop asks the agent to write a diary entry and record decisions if the session did real work but saved nothing.

All hooks fail open: if the palace is missing or empty, the agent works as normal. Every result carries its wing, room, source file, drawer id and score breakdown, so you can see where an answer came from.

Facts that change over time

palace-rs has a temporal knowledge graph: subject → predicate → object, with a valid-from date. When a fact changes, the agent invalidates the old one and adds the new one, so the timeline keeps both. palace_conflicts flags facts that look stale or contradictory.

Privacy

claude-mem:

"Anonymous usage analytics are on by default." Its telemetry page says it uses PostHog and calls it "on by default (opt-out)". You turn it off with npx claude-mem telemetry disable (or DO_NOT_TRACK).
The installer "asks you to sign in to claude-mem in your browser (email magic link)".
Screenshots are "kept by default" under ~/.claude-mem/media-v1/.

palace-rs:

No telemetry. palace gain statistics are written to your local database only.

The only network calls are the one-time model download from Hugging Face and, if you turn it on, your own Palace Server in remote mode.

No account, no sign-in, no analytics. Back up with palace export or by copying palace.db. Delete everything by removing ~/.palace.

Side by side

	claude-mem 15.18.1	palace-rs 0.20.0
Language	TypeScript	Rust
What you run	Node + Bun + uv/Python + Chroma + HTTP worker	One `palace` binary
Storage	SQLite + Chroma	One SQLite file
What's stored	Observations and summaries written by an LLM observer (default: Claude Haiku)	Your files, chats and notes, verbatim
LLM / API key needed	Yes (hosted observer, your key, or your Anthropic plan)	No
Published retrieval benchmark	None in README	LongMemEval R@5 0.987, no LLM
Telemetry	On by default (PostHog), opt-out	None
Account / sign-in at install	Yes (email magic link)	No
License	Apache-2.0	MIT
GitHub stars	116,434	10

The point

claude-mem is popular, and it covers a lot of agents. But popularity isn't architecture, and it isn't a benchmark.

If you want memory that:

is one binary you can audit,
stores what happened rather than a model's summary of it,
costs zero tokens to write,
sends nothing anywhere,
and comes with recall numbers you can reproduce,

that's palace-rs, today.

Don't trust the stars. Don't trust me either. Every quote above is from the projects' own pages. Open them and check.

# macOS / Linux curl -fsSL https://raw.githubusercontent.com/AncientiCe/palace-rs/main/scripts/install.sh | sh # Windows irm https://raw.githubusercontent.com/AncientiCe/palace-rs/main/scripts/install.ps1 | iex palace install