Claude Code Memory Loss: Comparing Five Memory Solutions

> Problem: Claude Code forgets—but "amnesia" is not one problem; it is five different symptoms. > Solutions: Native capabilities / MemPalace / Hermes Agent / Superpowers / Everything Claude Code > Evaluation dimensions: Cold-start recovery, long-conversation fidelity, precise recall, cost accounting

---

1. Decompose the Problem First: Amnesia Is Actually Five Diseases

When people complain about Claude Code forgetting, they rush to install a plugin. But "amnesia" is one label covering five distinct symptoms. Misdiagnosis leads to worse outcomes because the treatment doesn't match the disease.

1. Cross-Session Amnesia You asked Claude to change the login logic yesterday; today's new session acts like it never heard of it. Project context resets to zero and you start over from "what are we working on?"

2. Context Rot (Long-Session Decay) After ~200 turns in one session, Claude starts hallucinating—citing files that don't exist, forgetting constraints you stated explicitly. Quality degrades noticeably past 50% context window usage; hallucination rates spike past 70%.

3. Precision Recall Gap You say "handle it the way we did before"—but Claude can't tell whether "before" means the architecture decision from three weeks ago or yesterday's temporary patch. It has a vague impression but cannot find the exact source.

4. Team Knowledge Silos You and your colleagues each talk to Claude separately, each building your own set of "tacit understandings" that never gets shared. Your colleague's Claude doesn't know your naming conventions; yours doesn't know the performance trap they discovered.

5. User Modeling This is the reverse requirement: you don't want Claude to forget—you want it to *remember you*: your preferences, habits, why you chose option B over A last time. Not project context, but the person.

Five symptoms, five different treatment directions.

---

2. One Ruler: The Four-Dimension Benchmark

Before comparing, ground rules. Only four things matter:

| Dimension | What it asks | |-----------|--------------| | Cold-start recovery | Can Claude understand the project instantly in a new session? How many rounds of "re-introduction"? | | Long-conversation fidelity | After 200 turns, does Claude still remember the constraint from turn 5? | | Precise recall | When you say "last time's approach," can Claude locate the specific file, code, decision? | | Cost accounting | Are the extra tokens, latency, and maintenance of the memory system worth it? |

---

3. Option 1: Native Claude Code (Free Baseline)

Claude Code isn't completely memoryless. It has three native layers:

1. CLAUDE.md — Place a CLAUDE.md in the project root; Claude reads it automatically at startup. Write project rules, architecture overview, coding conventions. Around 150–200 lines works best; past 300 lines adherence drops.

2. Auto Memory (v2.1.59+) — Claude decides what's worth remembering, stored in ~/.claude/projects/<project>/memory/. A MEMORY.md file, first 200 lines read at startup. The obvious problem: what Claude "thinks" is important may differ from what you think. No search, no retrieval, no structure. You're relying on luck.

3. /compact — Manually compress conversation history to free the context window. But compression means losing detail. CLAUDE.md survives (it's re-read from disk), but in-session intermediate decisions, temporary constraints, and discussions all evaporate.

| Dimension | Rating | |-----------|--------| | Cold-start recovery | ⭐⭐⭐ CLAUDE.md provides basic context, needs manual upkeep | | Long-conversation fidelity | ⭐⭐ /compact extends life, but detail loss is severe | | Precise recall | ⭐ Auto Memory has no search capability | | Cost accounting | ⭐⭐⭐⭐⭐ Free, zero overhead |

Best for: small personal projects, people willing to maintain CLAUDE.md manually. Not for: precise recall, team collaboration, long-term memory scenarios.

---

4. Option 2: MemPalace (Memory Specialist)

MemPalace is an open-source Claude Code memory plugin. Core philosophy: memory is not a byproduct of CLAUDE.md—memory is a first-class citizen.

Architecture: two-layer memory + silent hook capture

• CLAUDE.md layer: auto-read at startup, ~150 lines, holds the most important context
• .memory/state.json layer: full memory store, searchable in-session via MCP tools

Capture via hooks:

• Stop hook: after every Claude reply, Haiku reads the conversation and extracts Architecture / Decisions / Patterns / Gotchas / Progress / Context
• PreCompact hook: rescues key information before context compaction
• SessionEnd hook: final archival

Clever details:

• Jaccard deduplication: no duplicate memories stored
• Confidence decay: Progress memories decay in 7 days, Context in 30
• LLM auto-merge: overlapping memories merge automatically, expired ones pruned
• Line budget: CLAUDE.md kept to ~150 lines, prioritized for importance

| Dimension | Rating | |-----------|--------| | Cold-start recovery | ⭐⭐⭐⭐ SessionStart injects prior-session memory + CLAUDE.md | | Long-conversation fidelity | ⭐⭐⭐⭐ PreCompact hook rescues pre-compaction info | | Precise recall | ⭐⭐⭐⭐ Two-layer structured memory, MCP search | | Cost accounting | ⭐⭐⭐ Haiku summarization calls + local SQLite, controlled cost |

Best for: developers needing original-text retrieval, precise recall, cross-session continuity. Not for: shared team memory or user behavior modeling.

---

5. Option 3: Hermes Agent (User Modeling)

Hermes Agent is not a Claude Code plugin—it's a Nous Research project on cross-session long-term memory. It represents an important direction: user modeling.

Core idea: Claude should remember not "project context" but "who the user is."

Mechanism:

• Tracks user preferences, decision patterns, interaction history across sessions
• Periodically summarizes user behavior patterns via a "reflection" mechanism
• Builds a user profile—not the creepy kind, more like "this person writes aggressive tests," "this person prototypes first, refactors later"

Status: Hermes remains a research direction, not a mature product. The GitHub repo is active, but there's no official Anthropic plugin integration yet.

| Dimension | Rating | |-----------|--------| | Cold-start recovery | ⭐⭐⭐⭐ Quickly restores "your style" from the user profile | | Long-conversation fidelity | ⭐⭐⭐ Doesn't fix within-session rot; fixes cross-session consistency | | Precise recall | ⭐⭐⭐ Inference from behavior patterns, not exact-text retrieval | | Cost accounting | ⭐⭐ Extra model for profile maintenance, large token overhead |

Best for: early adopters wanting long-term user modeling and a "learns me over time" experience. Not for: teams needing production today. Right direction, wrong timing.

---

6. Option 4: Superpowers (Engineering Discipline)

Superpowers is not a memory system—at least, creator Jesse Vincent wouldn't define it that way. It's a development methodology framework encoding TDD, YAGNI, structured debugging, and other engineering disciplines. Yet it has surprising effects on cold-start recovery and long-conversation fidelity.

Core mechanisms:

• Socratic brainstorming: Claude doesn't start coding; it asks "what are you actually trying to build?" and clarifies requirements, constraints, edge cases through dialogue
• 2–5 minute atomic tasks: each sub-agent does one thing, with tiny context
• Fresh subagent context: every task launches a new sub-agent with clean context, carrying no historical baggage
• RED-GREEN-REFACTOR enforced TDD: write code before tests? Superpowers deletes it

Why it "treats amnesia":

• Cold start: every session begins with structured requirement clarification—not vague "you said change the login logic," but a precise spec like "auth flow needs OAuth2 + local password + 2FA"
• Long fidelity: atomic tasks keep each sub-agent's context at 30–40% utilization, far from the 70% danger line
• Precise recall: every task has a plan document; reviews can trace exactly whether the implementation matches the plan

Superpowers doesn't make Claude "remember"—it makes Claude not need to remember as much, by splitting work into small blocks that each carry their own context.

| Dimension | Rating | |-----------|--------| | Cold-start recovery | ⭐⭐⭐⭐⭐ Socratic clarification refines requirements from scratch each time | | Long-conversation fidelity | ⭐⭐⭐⭐⭐ Atomic tasks + fresh subagents keep utilization low | | Precise recall | ⭐⭐⭐⭐ Plan documents + review checkpoints | | Cost accounting | ⭐⭐⭐⭐ TDD costs tokens, but avoids larger refactor/debug costs |

Best for: teams already using Claude Code for engineering projects who want discipline and predictable output. Not for: rapid prototyping or exploratory coding. Enforced TDD will feel "slow."

---

7. Option 5: Everything Claude Code (Full-Featured Harness)

Everything Claude Code (ECC) is a full-featured harness—it does everything; memory is just one layer.

Memory-related architecture:

• SessionStart hook: loads prior-session context and memory
• Stop + SessionEnd hooks: persist patterns and lessons to durable memory
• PreCompact hook: strategically saves key information before compaction
• PreToolUse / PostToolUse hooks: capture observations around every tool call

Continuous Learning v1 (skill-based): Stop hook extracts coding patterns, stored in ~/.claude/skills/learned/, ~50–80% coverage.

Continuous Learning v2 (instinct-based): PreToolUse/PostToolUse hooks with 100% coverage; each learning unit is an "instinct" with confidence 0.3–0.9; the /evolve command aggregates 3+ related instincts into a reusable Skill.

The problem with ECC: memory is a byproduct, not the core design. Memory is one layer of a four-layer architecture (Agent → Skill → Hook → Learning), drowned in a sea of agent orchestration, skill management, hook automation, continuous learning, validation gates, parallelization, and sub-agent coordination.

| Dimension | Rating | |-----------|--------| | Cold-start recovery | ⭐⭐⭐ SessionStart + skill loading, but heavy startup overhead | | Long-conversation fidelity | ⭐⭐⭐⭐ Multi-path saves, but high complexity | | Precise recall | ⭐⭐⭐ Memory exists but structure is complex, retrieval path long | | Cost accounting | ⭐⭐ Too many features; high token and maintenance cost |

Best for: those already using a discipline framework (e.g., Superpowers) who want to add a memory layer along the way. Not for: installing ECC purely for memory—using a cannon to kill a mosquito.

---

8. Spectrum: From Byproduct to Specialist

The five options aren't "which is better" but "which disease they treat":

| Option | Positioning | Memory Type | Best Symptom | |--------|-------------|-------------|--------------| | Native | Byproduct | Static rules + auto notes | No budget, small projects | | MemPalace | Specialist doctor | Structured two-layer memory | Precise recall, cross-session continuity | | Hermes | Research direction | User behavior modeling | "Learns me over time" (future) | | Superpowers | Engineering discipline | Methodology-driven workflow | Long fidelity, cold-start recovery | | ECC | Full harness | Bolt-on continuous learning | Incremental upgrade for harness users |

---

9. Final Recommendations

Regular users: master native Claude Code first

• Write a good CLAUDE.md (150–200 lines: architecture + conventions + key decisions)
• Learn to use /compact
• Maintain a project notes file manually (Markdown, written by you, not AI-generated)

Need exact-text retrieval: look at MemPalace

• Install the MemPalace plugin and let it capture silently
• Actively ask Claude to record key decisions to .memory/state.json
• Search history via MCP tools across sessions

Already using a discipline framework: Superpowers / ECC come along naturally

• Superpowers' TDD workflow inherently reduces "what needs to be remembered"
• ECC's continuous learning is icing, not the cake

Want long-term user modeling: watch the Hermes direction, but don't ship it yet

• Right direction, premature timing
• Follow Nous Research's progress

---

10. What the Community Is Really Arguing About

The debates on Hacker News and Reddit about Claude Code memory aren't really "which plugin is better." The real argument: should AI coding memory be implicit (the AI decides what to remember) or explicit (humans define memory structure)?

• Auto Memory (implicit): AI self-summarizes; simple but uncontrollable
• MemPalace / Superpowers (explicit): humans define memory structure and engineering discipline; controllable but requires investment

My judgment: at the current stage, explicit beats implicit—not because implicit isn't good enough, but because LLMs' "self-summarization" is still unreliable. Once models can judge "what's worth remembering" with 95% accuracy, implicit will win. For now, humans setting the rules is safer.

---

11. The Official Track Is Catching Up; the Third-Party Window May Be Short

Anthropic is already improving native Claude Code memory:

• v2.1.59 added Auto Memory
• The hooks system keeps expanding (8 event types)
• The community plugin ecosystem is exploding (176+ plugins, 20+ hooks)

Implication: the window for third-party memory plugins may not be long. Once Anthropic ships native structured memory + precise recall, standalone plugins like MemPalace lose independent value.

But Superpowers and ECC won't be replaced by official features—because their core value isn't "memory," it's "methodology." Anthropic can make memory work; it won't choose TDD, YAGNI, or Socratic brainstorming for you.

---

12. Future Form: Memory Becomes Infrastructure

• Short term (6 months): explicit memory plugins (MemPalace-like) and discipline frameworks (Superpowers-like) coexist
• Mid term (1–2 years): official structured native memory in Claude Code; third-party plugins pivot to vertical scenarios (user modeling, team sharing)
• Long term (3+ years): memory becomes infrastructure—you won't "install a memory plugin," just like you don't "install a TCP/IP plugin" to go online

The real competitive question isn't "who remembers more," but "who remembers what's right."

---

References

• Claude Code official docs: memory.md, hooks.md
• MemPalace GitHub (yuvalsuede/memory-mcp)
• Hermes Agent (Nous Research)
• Superpowers (obra/superpowers) — Jesse Vincent
• Everything Claude Code (affaan-m/everything-claude-code) — Affaan Mustafa
• claude-mem (thedotmack/claude-mem)
• Claude-Recap (hatawong/claude-recap)
• claude-memory-engine (HelloRuru/claude-memory-engine)
• claude-hooks (mann1x/claude-hooks)
• cmr-memory (agynio/claude-map-reduce-memory)
• token-savior (Mibayy/token-savior)
• Hacker News discussion: Claude Code plugins ecosystem (2026-04)
• Agentconn in-depth review