MemPalace vs agent-brain, ai-memory, Hindsight and Claude-Mem: Which Memory Do You Need?

Your coding assistant remembers that PostgreSQL was chosen. Does it also remember why, which alternative failed, whether that decision is still current, and what the next assistant should do?

Those are different memory problems. An archive preserves what was said. A project memory records what remains useful. A handoff transfers unfinished work. A reflective memory system tries to derive new observations from experience.

MemPalace is interesting because its starting point is preservation: keep the original conversation text and retrieve it rather than replacing the record with a model-generated summary. But that does not make every other memory architecture unnecessary—or prove that the next agent will act correctly. [1]

I reviewed the source, ran 16 isolated checks on actual temporal-graph and lexical-search helpers, and compared its design with agent-brain and the ai-memory, Hindsight and Claude-Mem tools covered in our previous articles. This is a task-oriented comparison, not a new five-product performance leaderboard.

Disclosure: Sync Studios/WeCanSync is part of my professional work. I am making that connection explicit when discussing agent-brain’s WeCanSync-hosted product site. An affiliated tool gets the same scrutiny of source, limits and evidence—not a preferred result.

1. What MemPalace actually stores

MemPalace describes its organization using a familiar metaphor:

Wings: people, projects or other broad scopes.
Rooms: topics within that scope.
Drawers: stored original content that can be retrieved.

The default retrieval backend is embedded ChromaDB. The reviewed development source also offers optional storage adapters, including exact-vector SQLite and server-backed alternatives. Changing the backend changes deployment and data paths; “local-first” does not mean every configuration is local. [1]

The central benefit is traceability. A summary may preserve “use PostgreSQL” while losing the discussion of transaction isolation, migration constraints or a failed alternative. Retrievable source text gives the agent—and the human reviewing it—a way to inspect those details.

The trade-off is equally real: retaining more original text means more sensitive material to protect, more old assumptions to distinguish from current decisions, and more content that can be mistakenly injected into the next prompt. Preservation is not selection, and retrieval is not verification.

Do not read the “verbatim” description as “the project has no derived structures.” The same source includes a temporal entity-relationship graph, hybrid retrieval logic and optional processing paths. Verbatim storage describes the source-preservation strategy, not every internal feature. [1][5]

2. Which MemPalace version was reviewed?

There are two different snapshots to keep straight:

Latest GitHub release observed: v3.11.0, commit 602d796c699cabba2971982cd9dccbbf46abfe79.
Default development branch inspected and used for the checks: 84582fb055a6429261f9c779da86c0561ec80adc. Its package metadata declares 3.12.0. That is not a claim that a 3.12.0 release was installed or published. [3][4]

The v3.11.0 notes describe audit/repair tooling, optional multimodal EmbeddingGemma 2 support and embedding-model identity checks. Those are documented release capabilities, not features exercised by my small fixture. [3]

The raw-source pin matters because this is an active project: development behavior, the PyPI package and a released plugin may not be identical.

3. What “96.6%” means—and what it does not

MemPalace’s README reports 96.6% R@5 on 500 LongMemEval questions for its raw retrieval baseline. It separately reports 98.4% for a held-out hybrid configuration and describes optional LLM reranking. These are the project’s reported results, not my reproduced scores. I checked the stored raw-result arithmetic: 483 of 500 recorded recall_any@5 values are successes, matching 96.6%. Reading and aggregating a committed result file is not rerunning the benchmark. [1][2][30]

Here the headline is specifically session-level recall_any@5: at least one gold answer session appears in the first five results. It does not require retrieving all reference sessions. It is not “the assistant answers 96.6% of questions correctly.” A model can receive one relevant source and still miss the rest, misunderstand it or use an outdated fact. The raw harness creates a fresh collection per question, stores user-turn text by session and checks session IDs; it is not an end-to-end test of the complete palace, hooks or final answers. [26]

The project’s own documentation also withdraws the tempting “100% wins everything” interpretation. It acknowledges that the final improvement to a historical 100% result involved inspecting specific mistakes—teaching to the test—and warns that other products publish different metrics and splits. The old cross-product table remains a historical record, not a valid universal ranking. [1][2]

That means we should not line up MemPalace’s retrieval percentage against Hindsight’s answer-quality number, a Claude-Mem token-savings claim, agent-brain’s synthetic search suite or an ai-memory handoff test and declare a winner.

“Zero API calls” is a configuration claim, not zero computation. Local embeddings still require model files, storage and inference. The documentation says the first embedding operation downloads a model; offline operation needs the required assets already present. Also, init attempts LLM assistance by default, preferring local Ollama; --no-llm is the explicit opt-out, and setup can fall back to heuristics. “No LLM required” is accurate; “no LLM attempted by default” is not. [1][24]

Optional cloud reranking, remote storage or hosted embeddings introduces a separate data path and cost. The external-embedding path warns that document text leaves the machine; that warning is not equivalent to a blocking consent screen. Check the selected endpoint before ingesting private material. [25]

4. What I actually exercised

I ran the pinned development source in a disposable Python container with:

Networking disabled and the source mounted read-only.
An unprivileged user, dropped capabilities and resource limits.
A temporary SQLite database containing only manually supplied synthetic facts.
No mocked model replies, no embedding model and no assistant credentials.

Result: 16 checks passed, zero failed. They covered:

Creating, storing and reading a real SQLite relationship.
Recording source-drawer provenance.
Returning no claim before a fact’s validity begins.
Deduplicating an identical current fact.
Superseding a fact while preserving history.
Selecting the old fact before the change and only the successor at the exact boundary.
Rejecting an inverted validity interval.
Round-tripping an Arabic entity and value.
Treating a quoted SQL-like entity name as data.
Reopening the database without losing the expected state.
Unicode lexical tokenization and a small BM25 positive/negative control.

These checks show that specific storage, temporal-query and lexical primitives behaved as expected. They do not show that an AI automatically extracts the right facts, that semantic retrieval reaches the reported benchmark score, or that every integration works.

I did not install MemPalace into my live assistants, import personal chat logs, run its full upstream suite, test Chroma/vector recall, or execute a head-to-head agent-brain/Hindsight comparison.

The fixture source and machine-readable results are published with this article. The graph’s behavior is grounded in the actual implementation, not a simulated API response. [5]

5. MemPalace versus agent-brain

Different center of gravity

MemPalace starts from retrievable source history. agent-brain starts from a coding-workflow collector and project memory: sessions, token/cost statistics, and entries typed as decisions, conventions, task state or facts. It exposes memory operations through MCP and supplies project context at supported session-start boundaries. [7][8][18]

That makes agent-brain a useful candidate when the questions are:

What are my assistants costing across projects and sessions?
Which project convention or decision should the next session inherit?
Was a memory save acknowledged and attributed to the correct session?
Is this entry stale relative to the repository or superseded by a later decision?

It is not the same promise as a searchable verbatim archive of everything that was said.

The public Memory V2 documentation describes explicit session attribution, write receipts, recovery, preserved decision history and BM25 retrieval. It explicitly says this does not add embeddings, a vector database or automatic deletion. The documented schema upgrade is deliberate, with backups and aligned binaries; installing a new executable alone is not proof that every V2 feature is active. [22]

Current release: personal memory is free; team/cloud is separate

The live agent-brain release metadata reported 0.5.12. Its matching public source is in the WeCanSync fork, pinned here at 7d0dc5c6aff9d4c8eaefd4c5336bdbeae7f74cd1. Personal memory became free and accountless in v0.5.7, while still requiring explicit consent. The current personal-memory gate checks that configuration exists, memory is consented and the project is not disabled—not a Pro tier. [18][19][20]

This resolves an initially misleading comparison: the older upstream snapshot linked by the site was still Pro-gated, but it was not the source of the current distributed release. Its old seven-day Pro grace helper does not impose an expiry on current personal memory.

Team memory remains tied to an account and membership of a paying team’s project. Contribution/sharing needs its separate consent. The cloud dashboard and enterprise backend are distinct offerings; I could not verify a public paid price and will not invent one. This is source/documentation verification, not a live assistant or paid-service test. [18][19][20][21]

A particularly important privacy distinction: the public source separates numeric telemetry from a memory-content pipeline. Team memory sharing can send selected memory entries to a service under a separate project consent. “The statistics payload contains no prompts” does not mean “no text can ever leave in any feature.” [8][21]

Use the current docs to distinguish local personal memory, dashboard linking, team-memory access and contribution consent. Stored memory, retained logs, exports and any remote team service all deserve separate review.

Practical verdict

Choose MemPalace for an evaluation of source-preserving recall. Choose an agent-brain evaluation for coding activity visibility and project-state continuity. If using both, designate which system owns authoritative decisions and avoid injecting the same context twice.

The public agent-brain CLI is MIT-licensed; that does not make its hosted service or every commercial feature unrestricted. I have not benchmarked its retrieval or audited the private service. [23]

6. How it compares with our earlier memory-tool posts

The directly relevant previous articles are ai-memory, Hindsight and Claude-Mem. Each addresses a different part of the problem.

ai-memory: shared project knowledge and explicit handoffs

Our ai-memory article focused on readable project knowledge and transferring unfinished work between coding assistants.

Its approach uses Markdown pages as the source of truth, a derived search index and typed handoffs. That is a different starting point from storing original conversations as the main retrieval substrate. It is useful when you need a shared, editable project wiki and an explicit “continue this task” protocol. The project is MIT-licensed; optional model-backed features and host-specific capture still need configuration. [27]

Our earlier v3.1.2 test used a real MCP connection in an isolated environment to verify synthetic writes, scoped search, persistence and a handoff that could only be claimed once. That was a bounded functional test—not a semantic-recall leaderboard or a guarantee that every current integration behaves identically. I did not rerun that release for this article.

Against MemPalace: prioritize ai-memory when the durable artifact is an editable project page and a handoff; prioritize MemPalace when you need to retrieve the original wording and surrounding conversation. Neither substitutes for reviewing whether a remembered decision is still valid.

Hindsight: retain, recall and reflect

Our Hindsight article examined a more model-assisted memory system: retain, recall and reflect, with richer retrieval and derived observations rather than only a searchable transcript archive. [28]

That design can be attractive when an application needs an agent to synthesize experience across many interactions. It introduces additional model work and operational complexity: a self-hosted database does not make the configured LLM local. Current documentation supports both remote providers and local routes; the chosen route determines privacy and inference cost. [28]

Against MemPalace: the trade-off is preservation-first retrieval versus a system designed to extract and reason over accumulated memory. I am not reusing the older post’s benchmark superlatives as proof that Hindsight wins today—or using MemPalace’s different metric to claim the reverse.

Hindsight’s open-source code is MIT-licensed. “MIT” is not “no inference bill.” [28]

Claude-Mem: coding-session capture and progressive disclosure

Our Claude-Mem article focused on capturing coding-session observations and retrieving context in layers rather than dumping a large archive into every prompt.

The current project describes local SQLite/FTS5 plus Chroma-based hybrid search, hooks/integrations and progressive disclosure. It also includes provider and hosted-service options; an integration’s data path must be checked rather than inferred from the core’s local database. Its current public README identifies Apache License 2.0; the older article’s MIT label should not be carried forward as the current license. [29]

Against MemPalace: Claude-Mem is closer to a capture-and-context-injection workflow, while MemPalace emphasizes retaining retrievable original material. The choice depends on whether you want compressed observations, exact source history or both.

The older post’s “10×” framing is not a universal saving. Savings depend on the comparison baseline, what is captured, what is fetched and whether the task succeeds. I did not reproduce it here.

7. Practical costs and privacy boundaries

Capture must actually happen

MCP makes tools available; it does not guarantee the assistant calls them. A documented hook is not proof that it is installed, trusted or supported by every host.

MemPalace documents auto-save paths for Claude Code, Codex and Cursor, while other clients have different setup routes. agent-brain similarly documents assistant-specific integration steps. Validate capture with a disposable marker and a fresh session before relying on it to preserve important work. [1][8]

Do not install several auto-capture systems indiscriminately. You can otherwise duplicate transcripts, summaries and injected context without noticing which one is current.

Local storage can still feed a cloud prompt

Even if the memory store never makes a remote API call, its retrieved text may be included in a prompt sent by the host assistant to a cloud model. Local database privacy and end-to-end workflow privacy are not the same claim.

Verbatim storage also retains mistakes, private details and potentially hostile instructions copied from files or tools. Treat retrieved memories as quoted evidence, not higher-priority instructions. Preserve provenance and verify consequential claims against the current source of truth.

“Free” still has boundaries

MemPalace: MIT software with a local no-LLM retrieval path; compute, backups, model downloads and optional remote services remain costs. [1][14]
agent-brain: local statistics and consent-enabled personal memory are free/accountless in the reviewed current release. Paid team/cloud features are separate; exact paid pricing was not publicly verified. [18][19][20]
ai-memory: an MIT project with a no-required-LLM baseline and optional additional processing. [27]
Hindsight: MIT code, with the actual LLM/provider and deployment resources to budget. [28]
Claude-Mem: Apache-2.0 code, while model execution and optional hosted products have their own terms. [29]

Finally, do not expose an embedded memory database as an unauthenticated internet service. MemPalace’s security guidance explicitly distinguishes its default embedded Chroma client from a separately operated Chroma HTTP server and advises private/authenticated deployment for the latter. That is an operational boundary, not an assertion that every local memory store is secure. [6]

8. My selection rule

Start with the artifact you want to preserve:

“Show me exactly what we discussed.” Evaluate MemPalace’s verbatim retrieval.
“Carry my project’s decisions and track assistant activity.” Evaluate agent-brain’s project memory and statistics, checking the exact release and consent mode.
“Let another coding assistant continue this unfinished task.” Evaluate ai-memory’s project pages and claim-once handoffs.
“Derive observations from experience and reason across them.” Evaluate Hindsight’s model-assisted memory pipeline.
“Capture coding-session context and load it progressively.” Evaluate Claude-Mem’s supported workflow for your host.

Then test the same held-out cases: an old decision replaced by a new one, a misleading near-match, information that should remain project-scoped, a secret that must not be captured, missing evidence and a question with no answer. Measure correct final behavior, freshness, source traceability, latency and total cost—not only whether a search returns something plausible.

My conclusion: MemPalace is a useful preservation-first candidate, not a universal replacement for the tools we already covered. The best memory is not the one that retains the most text. It is the one that gives the next agent the right evidence, at the right time, under the right permissions.

Sources