Claude Code Memory vs Mem0 vs Hindsight: Comparison

June 17, 2026

For Claude Code memory beyond native CLAUDE.md and Auto Memory, both Mem0 and Hindsight ship dedicated Claude Code plugins. Mem0 wins on community size (~58K GitHub stars) and time-to-value on the hosted tier. Hindsight wins on retrieval accuracy (94.6% on LongMemEval, top officially reproduced result on the Agent Memory Benchmark leaderboard, vs Mem0's 49.0% on an independent evaluation), MIT license, and deployment flexibility (Cloud, self-hosted, or auto-managed local daemon). Native works for many use cases first.

That's the short version. The rest of this article walks through each option in depth, names where each wins (including where Mem0 wins over Hindsight — there are real cases), provides a decision framework keyed to your situation, covers whether layering both makes sense, and walks through migration in both directions.

For the broader context of how Claude Code memory works overall, see the complete Claude Code memory guide. For the native-pattern workarounds that solve cross-project memory without an external backend, see the cross-project memory guide.

Quick Comparison Table

The fastest answer is the table:

Dimension	Native Claude Code	Mem0	Hindsight
Type	Local files	Hosted + OSS	Cloud + self-hosted (MIT) + local daemon
Cross-project memory	Manual workarounds	Native (multi-scope)	Native (multi-scope)
Retrieval	Index-based startup load + on-demand file reads	Vector semantic search (+ graph on Pro)	Multi-strategy (semantic + entity + temporal + graph)
Storage cap	`MEMORY.md` startup load capped at 200 lines / 25 KB	None	None
LongMemEval	N/A (not benchmarked)	49.0% (independent evaluation)	94.6% (AMB-reproduced)
Self-host option	N/A (it's local files)	OSS option available	Yes (one Docker command, MIT)
License	Anthropic's	Mixed OSS + commercial	MIT
Setup time	Zero (built in)	Plugin install + hosted sign-up (or self-host OSS)	Plugin install + pick a deployment
Cost model	Free	Per-request hosted; OSS free	Cloud (managed) or infrastructure-only (self-hosted/local daemon)
Community size	Anthropic ecosystem	Largest in agent memory (~58K GitHub stars)	Smaller but growing
Claude Code integration	Native	Official plugin (`mem0ai/mem0`)	Official plugin (`vectorize-io/hindsight`)
Maintenance	None	None for hosted; OSS = you operate	None for Cloud; minimal for self-host (embedded Postgres)

Three rows are doing most of the work in this comparison: cross-project memory (native requires workarounds; Mem0 and Hindsight have it natively), LongMemEval score (49.0% vs 94.6% — a meaningful gap), and deployment model (hosted vs self-host vs local-daemon flexibility).

Everything else follows from those three.

What Each Option Actually Is

Before the head-to-head, a fair picture of each. The depth here matters for the procurement decision later.

Native Claude Code Memory

Four CLAUDE.md scopes per Anthropic's official Claude Code memory docs — managed policy, user instructions (~/.claude/CLAUDE.md), project instructions (./CLAUDE.md or ./.claude/CLAUDE.md), and local instructions (./CLAUDE.local.md) — plus Auto Memory that captures session learnings to ~/.claude/projects/<project>/memory/ automatically, plus consolidation built on Anthropic's Dreams primitive. Dreams is documented as a Research Preview in the Managed Agents API: it "reads an existing memory store alongside past session transcripts, then produces a new, reorganized memory store: duplicates merged, stale or contradicted entries replaced with the latest value, and new insights surfaced." Claude Code's CLI integration that runs Dreams automatically in the background — often called Auto Dream — is described in MindStudio's coverage. The MEMORY.md index loads at startup (first 200 lines or 25 KB); topic files load on demand via Claude's standard file tools.

Per-repository by default — Anthropic's own users have filed feature requests for cross-project memory (#36561, #21854) that have been closed as duplicates without the feature shipping. Cross-project memory requires manual workarounds (user CLAUDE.md, symlinked .claude/rules/, user-level ~/.claude/rules/, or the --add-dir flag). Retrieval at startup is index-based — not vector semantic search.

For the full coverage of the native system including all four scopes, Auto Memory, the MEMORY.md startup load cap, and the documented limits, see the complete Claude Code memory guide.

Honest scope: handles personal preferences and project conventions well. Doesn't handle automatic cross-project capture or semantic retrieval depth.

Mem0

Hosted agent memory layer with the largest community in the agent memory space — ~58K GitHub stars, which is meaningful: more third-party content, more StackOverflow answers, more example integrations across agent frameworks. Mem0 ships multi-scope memory architecture (user, agent, session, app scopes) and a documented Claude Code plugin installable with /plugin marketplace add mem0ai/mem0 then /plugin install mem0@mem0-plugins.

Retrieval architecture: vector semantic search on the standard tier; graph entity retrieval added on the Pro tier (so two strategies on Pro vs four for Hindsight, but two is still meaningfully more than single-strategy alone).

Two deployment modes: hosted Mem0 (managed SaaS with per-request pricing) and OSS Mem0 (self-host the open-source version, which requires more infrastructure than Hindsight's embedded-Postgres setup — typically a separate vector database).

Honest acknowledgment: Mem0's first-mover position on Claude Code SEO is real, the community size is the largest in agent memory, and the hosted tier's time-to-value is the strongest in the category.

Hindsight

Memory layer with three deployment modes: Hindsight Cloud (managed by Vectorize), self-hosted (MIT-licensed, one Docker command, embedded Postgres pg0), or auto-managed local hindsight-embed daemon via uvx. The official Claude Code plugin installs with claude plugin marketplace add vectorize-io/hindsight then claude plugin install hindsight-memory and handles auto-recall on every prompt, auto-retain after every response, MCP knowledge tools, and a subagent skill backed by an isolated memory bank.

Multi-scope architecture (user_id, agent_id, session_id, org_id). Multi-strategy retrieval: semantic search + entity-based retrieval + temporal filtering + graph traversal — four parallel strategies that catch what single-strategy systems miss.

Auto-consolidating observations and refreshing mental models — the consolidation layer handles contradiction reconciliation across sessions, which is what differentiates "memory that compounds" from "memory that just accumulates."

94.6% on LongMemEval — top officially reproduced result on the Agent Memory Benchmark leaderboard. The benchmark and methodology are publicly documented.

Honest scope: shines on retrieval accuracy, deployment flexibility, and MIT-license freedom. Smaller community than Mem0. Not the right answer if you've already decided you want managed SaaS with the largest community ecosystem — for that, Mem0 is the better fit.

For the Hindsight + Claude Code integration architecture in depth, see Hindsight as a second brain backend — Claude Code is one of the three reference architectures covered.

Where Each One Wins

The honest head-to-head, with explicit sections for where each option pulls ahead.

Where Native Wins

Zero setup: it's built into Claude Code. No additional installation, no operational burden, no infrastructure decisions.
No additional dependencies: nothing to maintain, nothing to operate, no external service can go down
Project-bounded use cases: when your work is mostly project-isolated and you're willing to maintain CLAUDE.md by hand, native handles it
Privacy by default: memories stay on your filesystem; no data leaves your machine
Cost: free

When native is enough: solo developer, 1–5 projects, willing to maintain ~/.claude/CLAUDE.md and per-project CLAUDE.md manually, no cross-project semantic search needs. Per the cross-project memory guide, the four-pattern stack (user CLAUDE.md + symlinked rules + user-level ~/.claude/rules/ + --add-dir) covers a lot of real cases.

Don't reach for an external backend until native is genuinely insufficient. Most developers shouldn't.

Where Mem0 Pulls Ahead

Mem0 has real strengths Hindsight doesn't match.

Community size: ~58K GitHub stars, the largest community in the agent memory space. This translates to practical advantages — more third-party tutorials, more StackOverflow answers when you hit an integration question, more example code across agent frameworks, more chance the specific edge case you hit has been documented by someone else first.
Time-to-value on the hosted tier: minutes to first integration. The managed infrastructure means you skip operations setup entirely after the plugin install.
Claude Code plugin maturity: Mem0 shipped their Claude Code plugin alongside their detailed integration article. If you're reading their integration article, the path from there to working integration is well-documented and battle-tested.
Hosted managed simplicity: for teams that have decided they want managed SaaS rather than self-hosted or local-daemon infrastructure, Mem0's hosted offering is the more mature option in the category.

When Mem0 is the right choice: teams comfortable with SaaS dependency, organizations where time-to-value matters more than retrieval accuracy or cost at scale, deployments where the community size and ecosystem maturity translates to reduced support burden.

Where Hindsight Pulls Ahead

Retrieval accuracy: 94.6% on LongMemEval vs Mem0's 49.0% (independent evaluation). The gap reflects real architectural differences in retrieval coverage — Hindsight's multi-strategy retrieval (semantic + entity-based + temporal + graph traversal) catches memories that single- or two-strategy systems miss. For Claude Code use cases where exact recall matters (debugging insights from three months ago, architectural decisions on a specific subsystem, convention history across projects), the gap is meaningful in practice.
Deployment flexibility: three first-class modes — Hindsight Cloud (managed), self-hosted (one Docker command with embedded Postgres pg0, MIT license), or auto-managed local hindsight-embed daemon via uvx. The same plugin and the same memory API across all three.
Cost at scale: Mem0's hosted tier uses per-request pricing; Hindsight self-hosted is infrastructure-only. The economics flip for high-volume deployments — somewhere between hundreds of users and many thousands of memory operations per day, self-hosted Hindsight's total cost becomes meaningfully lower than per-request Mem0.
Multi-strategy retrieval depth: four parallel strategies vs Mem0's vector semantic search (or vector + graph on Pro). For specific Claude Code use cases (finding the right code-style memory across many projects; recalling an architectural decision from a specific time window) the strategy diversity matters.
Open source freedom: MIT license, no feature gating, no vendor lock-in. Auditable code matters for security-conscious deployments.
Multi-scope architecture: memories carry user_id / agent_id / session_id / org_id scopes, and consolidation runs across scopes. Anthropic's Dreams pipeline (which powers Claude Code's Auto Dream) does real consolidation work — dedup, latest-value replacement on contradictions, surfacing new insights — but operates on one memory store at a time. Combined with Claude Code's per-repository memory directory layout, that means each project's store gets consolidated in isolation. Hindsight's consolidation layer composes across scopes: cross-project insights tagged at user_id scope feed mental models that surface in every project, not just the one where they originated. That's the architectural primitive that the per-store Dreams pass doesn't expose.

When Hindsight is the right choice: teams that need retrieval accuracy, want deployment flexibility (cloud, self-host, or local daemon all valid options), need MIT-licensed code they can audit and extend, or operate at scale where per-request pricing on hosted alternatives becomes cost-prohibitive.

Decision Framework: Which One Fits Your Situation?

The procurement-stage diagnostic. Match your situation to the recommendation; the framework is keyed to the dimensions that actually drive the choice.

Situation	Recommendation
Solo developer, 1–5 projects, willing to write CLAUDE.md manually	Native (Patterns 1–4 from the cross-project memory guide)
Hosted SaaS preferred, time-to-value is priority, community size matters	Mem0
Need high retrieval accuracy, prefer managed or self-host	Hindsight (Cloud or self-hosted, same accuracy either way)
Multiple teams across an org, mixed SaaS-comfort levels	Mem0 for SaaS-comfortable teams; Hindsight for self-host-preferred or accuracy-critical workloads; Native for low-volume cases
Operating at scale where per-request pricing is cost-prohibitive	Hindsight self-hosted (infrastructure cost only)
Air-gapped, regulated, or data-sovereignty requirements	Hindsight self-hosted (MIT license, runs entirely in your infrastructure with embedded Postgres)
Want zero infrastructure but don't want to sign up for any cloud	Hindsight auto-managed local daemon (via `uvx`, with your own LLM provider API key)
Early evaluation, not sure which way to go	Try native first; if insufficient, evaluate one or both
Already invested in Mem0 elsewhere, just need Claude Code integration	Mem0 (consistency with existing infrastructure)
Already running Hindsight for other agent workloads	Hindsight (consistency + reuse the existing deployment)
Want maximum retrieval accuracy regardless of operational overhead	Hindsight (94.6% LongMemEval is the top officially reproduced result on the AMB leaderboard)

The honest meta-recommendation: most developers should try native first. The user-instructions file (~/.claude/CLAUDE.md) plus user-level rules (~/.claude/rules/) solves more cases than most developers realize. If native isn't enough, the choice between Mem0 and Hindsight comes down to your deployment model preference and your retrieval accuracy requirements.

Can You Use Both?

Some real deployments layer multiple backends. The pattern is rarer than the marketing implies, but it's not zero.

Pattern A: Mem0 Hosted for Personal + Hindsight for Production

Personal Claude Code memory uses hosted Mem0 — minimal infrastructure, immediate setup. Production agent deployments built on Claude Code use Hindsight (Cloud or self-hosted) — retrieval accuracy and deployment flexibility for production-grade requirements.

This pattern fits organizations where personal developer productivity and production agent infrastructure are governed by different teams with different deployment-model preferences.

Pattern B: Native for Project + External for Cross-Project

Per-project conventions live in ./CLAUDE.md and symlinked .claude/rules/ (native handles these well). Cross-project semantic memory and consolidation depth lives in Mem0 or Hindsight at user_id scope. The two layers compose: native handles project-scoped concerns; the external backend handles cross-project.

This is the most common composition. Per the complete Claude Code memory guide, the native system continues to work in parallel when an external backend is layered.

Honest Scope

Most developers shouldn't run two memory backends. The complexity rarely pays off for individuals, and the operational overhead of maintaining two memory layers exceeds the marginal benefit for almost every use case below organizational scale.

The pattern fits organizations with mixed requirements across teams or distinct personal-vs-production memory needs. Below that, pick one and stick with it.

Migration: How to Switch Backends

If you're already on one backend and considering another, here's the migration path in both directions.

From Native to Mem0

Export your ~/.claude/CLAUDE.md content as the starting personal-preferences corpus
Export per-project CLAUDE.md content if you want to import it as scope-tagged memories (some teams skip this and keep native per-project)
Install the Mem0 plugin: /plugin marketplace add mem0ai/mem0 then /plugin install mem0@mem0-plugins and follow their Claude Code integration documentation
Import as user-scoped memories for the cross-project layer
Keep native CLAUDE.md for per-project conventions

Migration cost: a few hours for the first integration; existing memory is exportable as markdown and importable as text.

From Native to Hindsight

Export ~/.claude/CLAUDE.md and ~/.claude/projects/<project>/memory/ content if you want to seed cross-project memory
Install the Hindsight plugin: claude plugin marketplace add vectorize-io/hindsight then claude plugin install hindsight-memory
Pick a deployment: Hindsight Cloud (sign in once), self-hosted (one Docker command with embedded Postgres), or auto-managed local daemon (via uvx with an LLM provider API key)
Confirm bank policy. The plugin defaults to a single shared bank (bankId: "claude_code", dynamicBankId: false), so cross-project memory works out of the box. Flip dynamicBankId: true for per-project isolation, or use directoryBankMap for explicit project→bank assignment
Native memory continues to work in parallel — Hindsight layers underneath rather than replacing

Migration cost: a few hours for plugin install. Embedded Postgres for self-host means no separate database to provision. No scope policy to configure unless you want per-project isolation — the default already shares.

From Mem0 to Hindsight

Mem0's data is exportable via their API; pull the existing memory corpus
Map each Mem0 record to Hindsight's observation schema (content, context, metadata, tags, entities, observation_scopes) and POST to Hindsight's Retain endpoint, which accepts batched items and supports async: true for large corpora. There's no automatic Mem0-schema parser — the mapping is mechanical, but you write it
The consolidation pass on the imported corpus may produce different mental models than Mem0's processing did — this is a feature, since Hindsight's consolidation depth (auto-consolidating observations + refreshing mental models that reconcile contradictions) is one of the architectural reasons people switch
Run both plugins in parallel during transition for lowest risk; cut over after validating the imported memories work

Migration cost: a few days for a serious cutover; the cost is primarily in validation, not in data extraction.

From Hindsight to Mem0

Hindsight's data is exportable via the bank-memories list and get endpoints (observations, history, and metadata are all reachable); self-hosted deployments also have direct Postgres access to the underlying tables
Migrating to Mem0 requires schema mapping — Mem0's data model differs from Hindsight's, particularly in the consolidation-layer representation
Cost is in matching their schema, not in extracting data
Same parallel-run pattern applies during transition

Migration cost: a few days for serious cutover plus the schema-mapping engineering work specific to Mem0's data model.

Conclusion

Native Claude Code memory, Mem0, and Hindsight are three legitimate options for Claude Code memory backends. Each wins in different situations; the right choice depends on your deployment model preferences, retrieval accuracy requirements, and operational profile.

Three things to remember:

Try native first. ~/.claude/CLAUDE.md plus user-level ~/.claude/rules/ handles cross-project memory for more developers than the marketing for external backends would suggest. The cross-project memory guide walks through all four native patterns.
Mem0 wins on time-to-value, community size, and hosted simplicity. ~58K GitHub stars is the largest community in agent memory. The hosted tier's operational simplicity is real. If you've decided you want managed SaaS for your Claude Code memory backend, Mem0 is the mature option.
Hindsight wins on retrieval accuracy, deployment flexibility, and MIT license. 94.6% vs 49.0% on LongMemEval reflects real architectural differences in retrieval coverage. For Claude Code use cases where exact recall, cost at scale, audit-ready code, or data sovereignty matter, Hindsight is the choice. Three deployment modes — Cloud, self-hosted, or auto-managed local daemon — cover the spectrum from "managed for me" to "runs entirely in my infrastructure."

For broader context: the complete Claude Code memory guide covers the full memory system including the documented limits. The cross-project memory guide covers the native workarounds in depth. For the broader memory framework landscape beyond these three options, the comparison of all 8 major memory frameworks walks through the field. For the foundational concepts of agent memory, what is agent memory is the starting point.

FAQ

Which memory framework is best for Claude Code? It depends on your situation. Native Claude Code memory is enough for many solo developers willing to write CLAUDE.md manually. Mem0 wins on time-to-value, community size, and hosted simplicity. Hindsight wins on retrieval accuracy (94.6% vs Mem0's 49.0% on LongMemEval), deployment flexibility (Cloud, self-hosted, or local daemon), and MIT-licensed auditability. The decision framework table above maps situations to recommendations.

How does Hindsight compare to Mem0 for Claude Code? Both ship multi-scope memory architecture and dedicated Claude Code plugins (mem0ai/mem0 and vectorize-io/hindsight respectively). Mem0 has the larger community (~58K GitHub stars), more mature ecosystem, and stronger time-to-value via the hosted tier. Hindsight has higher published retrieval accuracy (94.6% vs 49.0% on LongMemEval), MIT license vs Mem0's mixed OSS + commercial model, three deployment modes (Cloud, self-hosted with embedded Postgres in one Docker command, or auto-managed local daemon via uvx), and an auto-consolidation layer with refreshing mental models that reconcile contradictions.

Should I use native Claude Code memory or an external backend? Try native first. The four-pattern stack from the cross-project memory guide handles more cases than most developers realize. Reach for an external backend (Mem0 or Hindsight) when the symptoms become consistent: re-explaining context that should be remembered, MEMORY.md past its 200-line / 25 KB startup load window, index-based retrieval missing topic files due to vocabulary mismatch, or maintaining the native stack across many projects breaking down.

What's the cost difference between Mem0 and Hindsight? Mem0's hosted tier uses per-request pricing — predictable for steady workloads, can grow large at scale. Mem0 OSS is free but you operate it yourself (typically requires a separate vector database). Hindsight has three deployment modes: Cloud (managed pricing), self-hosted (MIT-licensed, infrastructure-only — embedded Postgres in a single container, no separate database service required), and auto-managed local daemon (your machine, your LLM provider API key). For high-volume deployments, self-hosted Hindsight has the most favorable cost economics.

Does Mem0 have semantic retrieval for Claude Code? Yes. Mem0 ships vector-embedding-based semantic retrieval as the primary retrieval strategy, with knowledge graph entity retrieval added on the Pro tier. Hindsight ships multi-strategy retrieval (semantic + entity-based + temporal + graph traversal), which catches some queries that single- or two-strategy systems miss. For Claude Code use cases involving recall across long time windows or across many entities, the strategy diversity matters more.

Can I self-host memory for Claude Code? Yes — both Mem0 (via OSS) and Hindsight ship self-hostable options. Hindsight's self-host story is one Docker command with embedded Postgres (MIT license). Mem0's OSS option requires more configuration and typically a separate vector database. For self-host-by-default deployments, Hindsight's setup is meaningfully simpler.

Which has better cross-project memory: Mem0 or Hindsight? Both ship multi-scope memory architecture, which is the structural answer to cross-project. Memories tagged at user_id scope surface across every project automatically. The retrieval depth differs (94.6% Hindsight vs 49.0% Mem0 on LongMemEval), so for use cases where finding the right cross-project memory matters, Hindsight's retrieval pulls ahead. For ease of getting cross-project memory working at all, either backend solves the architectural gap natively.

How accurate are Mem0 and Hindsight at memory retrieval? LongMemEval is the canonical agent memory retrieval benchmark. Published scores: Hindsight 94.6% (top officially reproduced result on the Agent Memory Benchmark leaderboard), Mem0 49.0% (independent evaluation). The gap reflects architectural differences in retrieval coverage.

Can I use both Mem0 and Hindsight together? Some organizations do — typically Mem0 for personal developer productivity (hosted simplicity) and Hindsight for production agent infrastructure (retrieval accuracy and deployment flexibility). Most individuals shouldn't run two backends; the operational overhead exceeds the marginal benefit. The "can you use both" pattern fits organizations with distinct personal-vs-production memory needs or mixed SaaS-comfort across teams.

How do I migrate between Mem0 and Hindsight? In either direction: export the existing memory corpus from the current backend, install the target plugin, import the observations, configure the scope policy, and run both in parallel during transition for lowest risk. The Mem0-to-Hindsight migration costs more in validation (because Hindsight's consolidation may produce different mental models from the imported corpus). The Hindsight-to-Mem0 migration costs more in schema mapping (Mem0's data model differs from Hindsight's). Both migrations are days, not weeks.

What's the community size difference between Mem0 and Hindsight? Mem0 has the largest community in the agent memory space at ~58K GitHub stars. Hindsight's community is smaller but growing. The practical implications: more third-party content for Mem0, more StackOverflow coverage for Mem0, more pre-existing example code for Mem0. For teams that weight community-driven support burden heavily, Mem0 has the edge.

Is Mem0 or Hindsight better for production agents? Different angles. For production with hosted-SaaS deployment model and time-to-value priority: Mem0. For production with retrieval-accuracy priority, self-host or sovereignty requirements, or cost-at-scale concerns: Hindsight. The two aren't substitutes — each is the better answer in a different production profile. The decision framework table above maps situations to recommendations.

Next reads: the complete Claude Code memory guide for the full memory system explainer, cross-project memory guide for the native workaround patterns, Hindsight as a second brain backend for the Claude Code integration architecture, and the comparison of all 8 major memory frameworks for the broader memory landscape.