MemPalace: The Free AI Memory System That Actually Remembers Everything

Every AI agent you use has the memory of a goldfish. Months of conversations, hundreds of decisions, thousands of analyzed files, and yet every new session starts completely fresh. This is the single biggest bottleneck holding back autonomous AI agents in professional workflows, from B2B outreach to software development. MemPalace, an open-source project released on April 5, 2026, takes a radical approach: store absolutely everything, summarize nothing, and make any piece of information retrievable with just 170 tokens loaded at startup.

The project hit 38,000 GitHub stars in under a week, sparking both excitement and controversy in equal measure. Behind the system lies an architecture inspired by a 2,500-year-old mnemonic technique, reimagined for modern language models. Here is the full breakdown.

One of the most surprising things about MemPalace is who built it. Milla Jovovich, the actress best known for the Resident Evil franchise, partnered with Ben Sigman, a software engineer and crypto entrepreneur, to create this system. Jovovich is not just a celebrity face for the project: she is its architect, while Sigman handles the engineering.

The idea was born from a frustration shared by millions of ChatGPT and Claude users: after months of daily AI conversations, every new session starts from scratch. Jovovich described accumulating hundreds of hours of rich conversations with language models, only to have none of them remember the previous session. The frustration ran deeper because existing solutions, whether paid or open source, relied on an LLM to summarize what matters, inevitably losing nuance and context along the way.

The name MemPalace references the Method of Loci, an ancient Greek mnemonic technique where you associate information with rooms in a mental building. The bet Jovovich and Sigman are making is that this spatial metaphor, proven effective for the human brain, can also organize AI memory more effectively than a flat vector dump.

The launch was explosive: 5,400 GitHub stars in 24 hours, then 21,700 in three days, and over 38,000 within a week. Brian Roemmele, an influential figure in the AI community, publicly stated he deployed MemPalace for 79 of his employees, calling the system a "masterpiece." But this meteoric rise also attracted scrutiny, particularly around the benchmark claims we will examine later.

Persistent memory has become the number one bottleneck for AI agents in production. Whether you are using Claude Code, ChatGPT, Cursor, or a custom agent via MCP, every new session starts with a blank slate. Current solutions fall short in different ways.

Context files like CLAUDE.md or AGENTS.md grow rapidly until they consume a significant portion of the context window. AI-generated summaries inevitably lose critical details because the model decides what is "important." Cloud-based paid solutions like Mem0 (19 to 249 dollars per month) or Zep (starting at 25 dollars per month) add external dependencies and recurring costs that scale with usage.

For a B2B SaaS that uses agents to automate outreach, handle customer support, or analyze campaign data, this amnesia translates into repeated mistakes, inconsistent recommendations, and a loss of context that frustrates end users. Picture an outreach agent that forgets the 200 objections it analyzed yesterday, or a support agent that cannot recall which solutions worked last week. The productivity cost is enormous, and this is precisely the problem MemPalace sets out to solve.

MemPalace is an MIT-licensed open-source memory system that gives language models persistent memory across sessions. Unlike alternatives that summarize and filter your data, MemPalace stores everything verbatim, word for word, then organizes it using a hierarchical architecture inspired by the Method of Loci.

The Method of Loci, also known as the memory palace technique, is a mnemonic strategy dating back to ancient Greece. The principle involves associating information with spatial locations in a mental building. MemPalace translates this concept into semantic storage for AI.

The system runs on two local technologies: ChromaDB for vector storage and semantic search, and SQLite for the temporal knowledge graph. No external APIs are called in standard mode. Your data never leaves your machine.

Getting started takes three commands:

bash

pip install mempalace
mempalace init ~/projects/myproject
mempalace mine ~/projects/myproject

Data organization in MemPalace follows a spatial hierarchy that improves search accuracy by 34% compared to flat vector search alone.

Wings are the top level. Each project or person gets its own wing in the palace. If you manage multiple outreach campaigns, each client can have a dedicated wing containing the full history of conversations, decisions, and results.

Rooms divide each wing into sub-topics. In a "Client X Emelia Campaign" wing, you might have rooms for targeting, sequence writing, A/B test results, objections encountered, and successive optimizations.

Halls are cross-cutting corridors that span all wings. They categorize memory types: hall_facts for locked decisions, hall_events for sessions and milestones, hall_discoveries for breakthroughs, hall_preferences for habits and opinions, and hall_advice for recommendations.

Tunnels create connections between different wings. When two projects share a similar challenge, a tunnel automatically links the relevant rooms.

Closets store compressed summaries in AAAK format (roughly 30x compression), while Drawers preserve the original verbatim files, never deleted.

The 34% improvement comes purely from structural organization, with no additional algorithmic complexity. ChromaDB handles the vector search; MemPalace provides the structure that cuts through noise.

The most striking innovation in MemPalace is its progressive four-layer loading system, which boots a session with just 170 tokens while retaining full access to the entire memory vault.

Layer L0 (Identity) loads roughly 50 tokens containing baseline identity: who you are, what the main project is, which critical conventions apply. This layer is always present in the system prompt.

Layer L1 (Critical Facts) adds approximately 120 tokens of essential facts compressed in AAAK format. For example, a five-person team structure with roles and expertise fits in a single line: TEAM: PRI(lead) | KAI(backend,3yr) SOR(frontend). This format remains natively readable by every LLM without any decoder.

Layer L2 (Room Recall) loads context specific to the active room, on demand. When working on campaign targeting, only memories from that room get injected.

Layer L3 (Deep Search) runs a full semantic search across the entire palace, triggered by the user or agent when a specific piece of information is needed.

The difference is staggering. For an outreach tool running hundreds of sessions daily, going from 507 dollars to 10 dollars per year in memory costs fundamentally changes the economics.

MemPalace does not just store facts. It tracks their validity over time. The temporal knowledge graph, built on SQLite, assigns each piece of information a validity window with a valid_from field and an ended field.

This feature solves a critical flaw in traditional context files: the accumulation of stale information. When your CLAUDE.md contains hundreds of lines, some months old, the model cannot distinguish still-valid decisions from ones that have been revised. MemPalace automatically invalidates expired facts.

For B2B outreach, this capability is especially valuable. Information about a prospect constantly evolves: job changes, new funding rounds, strategic pivots. An agent equipped with MemPalace can query the current state of a contact while retaining the complete history of the relationship.

python

# Temporal query: current state of a contact
mempalace search "John Smith current position" --temporal current

# Historical query: relationship evolution
mempalace search "John Smith" --temporal all

MemPalace introduces the concept of specialist agents, each maintaining an independent diary and domain-specific memory. This approach is particularly relevant for teams running multiple AI agents in parallel.

In the ~/.mempalace/agents/ directory, you can create specialized profiles. A reviewer agent accumulates code review patterns and bug histories. An architect agent retains design decisions and technical trade-offs. An ops agent memorizes deployments, incidents, and infrastructure configurations.

For a B2B sales team, this architecture translates naturally. A prospecting agent remembers objections by industry, high-performing hooks, and response patterns by vertical. An analyst agent retains campaign metrics, industry benchmarks, and identified correlations. A copywriting agent accumulates winning formulations, open rates by subject line type, and client style preferences.

Each agent builds its expertise session after session without polluting the others' memory. The result is genuine cumulative learning that current solutions simply cannot deliver.

MemPalace integrates natively with the MCP (Model Context Protocol) ecosystem, the open standard recently transferred to the Linux Foundation through the Agentic AI Foundation. This compatibility means the system works with every major MCP client without specific configuration.

For Claude Code, integration takes a single command:

bash

claude mcp add mempalace -- python -m mempalace.mcp_server

The MCP server exposes 19 tools that AI calls automatically: semantic search, memory storage, knowledge graph queries, and specialist agent diary management.

MemPalace also includes automatic hooks that fire every 15 interactions to extract and store topics, decisions, and code changes without manual intervention. A PreCompact hook emergency-saves memory before context compression, preventing any loss during extended sessions.

For local models like Llama, Mistral, or Gemma, wake-up mode loads the 170 critical-fact tokens directly into the system prompt, while CLI search enables on-demand queries. This multi-platform flexibility is a key strength: you are not locked into any single ecosystem, and you can use MemPalace with whichever model and client you prefer.

Integration through the Claude Code plugin marketplace makes adoption even simpler:

bash

claude plugin marketplace add milla-jovovich/mempalace
claude plugin install --scope user mempalace

Once installed, MemPalace works transparently in the background without changing your existing workflow.

MemPalace's performance on the LongMemEval benchmark deserves a nuanced look. In raw mode (verbatim storage with no external API), the system achieves 96.6% Recall@5 on 500 questions, making it the highest-performing free memory system available.

In hybrid mode, which adds LLM-based reranking via a cloud API (costing roughly 0.001 dollar per query), the score reaches 100%. This is the number the team initially highlighted in their marketing, triggering a legitimate backlash.

The community quickly identified that the perfect score was obtained after targeted fixes on the three specific questions that had previously failed. The team tested, identified failures, engineered corrections, and re-tested on the same questions to report a perfect score. Ben Sigman has since updated the messaging to feature the 96.6% score as the primary reference.

An important caveat: these benchmarks do not all measure the same thing. MemPalace measures retrieval recall, while Mem0 and Zep report end-to-end QA scores. Direct comparison is therefore imperfect. Nevertheless, MemPalace's value proposition remains remarkable: 96.6% performance at zero recurring cost.

No tool is perfect, and MemPalace is no exception. Here are the limitations worth knowing before adoption.

AAAK compression, presented as a major innovation, drops the benchmark score from 96.6% to 84.2%. The abbreviation-based compression format, while readable by LLMs, introduces measurable information loss. For use cases where accuracy is critical, raw mode remains the recommended choice.

The token savings claimed for AAAK are also disputed. Validation with an actual tokenizer showed that the README example went from 73 to 66 tokens, a compression ratio far below the advertised 30x. The team has acknowledged this error and is working on correcting the examples.

On the technical side, several open issues affect stability. A segfault on macOS ARM64 (issue 74), shell injection in hooks (issue 110), and ChromaDB version pinning problems (issue 100) are documented on the repository.

Contradiction detection, mentioned in the documentation, is not yet automatically integrated into knowledge graph operations. It exists as a separate utility, which limits its usefulness in production.

Finally, MemPalace requires Python 3.9+, MCP server configuration, and hook setup. For simple projects that only need coding conventions, a CLAUDE.md file remains more appropriate.

Beyond software development, MemPalace opens compelling possibilities for B2B professionals and sales teams integrating AI into their workflows.

For automated email outreach, an agent equipped with MemPalace remembers common objections by industry, the phrases that generated the best response rates, and the communication preferences of every prospect contacted. Session after session, the agent refines its recommendations without starting from scratch.

For campaign analysis, the temporal knowledge graph tracks metric evolution over time. Instead of manually reloading performance data at every optimization session, the agent instantly accesses the full history and identifies trends.

For SaaS customer support, specialist agents per product domain accumulate expertise on recurring issues, effective solutions, and edge cases. Every resolved ticket enriches the agent's knowledge base, progressively reducing resolution time.

For SEO content teams, a writing agent memorizes editorial guidelines, performance by article type, and requested corrections. The result is continuous quality improvement without repetitive briefing.

Consider a concrete example. A B2B agency manages 15 parallel email outreach campaigns for different clients. Each campaign has its own target personas, common objections, winning hooks, and performance metrics. Without persistent memory, the agency's agent must reload all this information at the start of every session. With MemPalace, each campaign gets a dedicated wing, cross-client best practices are accessible via halls, and specialist agents per client accumulate expertise that sharpens over weeks. The agent can instantly compare response rates between two similar campaigns in different industries, identify patterns that work, and apply those insights without a human needing to re-brief everything.

The AI agent memory market is still young, but several players are already competing for dominance. Here is how MemPalace positions itself against its main rivals.

Mem0, backed by Y Combinator and used by over 50,000 developers, offers a managed platform with both a cloud option and a self-hosted version. Its approach uses an LLM to extract and summarize relevant information from conversations. The advantage is integration simplicity and enterprise support. The downside is potential information loss during summarization and a monthly cost of 19 to 249 dollars.

Zep specializes in cloud-hosted temporal knowledge graphs. Its strength lies in understanding entities and their relationships over time, making it a powerful tool for complex agentic workflows. Pricing starts at 25 dollars per month, with a community self-hosted edition offering reduced features.

Hindsight, an open-source project, scored 91.4% on LongMemEval and stands out for its approach of learning from past sessions. It is free and local, but its integration ecosystem is less mature than MemPalace.

What sets MemPalace apart is the combination of fully local and free operation with a benchmark score that surpasses every paid alternative in raw mode. The trade-off is a more technical initial setup and a young ecosystem with documented bugs.

MemPalace represents a significant leap in persistent memory for AI agents, with a 96.6% LongMemEval score, fully local operation, and zero cost. The memory palace architecture delivers a 34% search accuracy gain through structural organization alone.

The project is young, however, with documented stability issues and initial marketing that required correction. Version 3.1.0 is production-usable for developers comfortable with Python and MCP, but non-technical teams will need to wait for more accessible integrations.

The broader trend is unmistakable: persistent memory is becoming an essential component of enterprise AI infrastructure. With MCP standardization under the Linux Foundation and the proliferation of autonomous agents, tools like MemPalace are no longer a luxury but a necessity. The fact that a free, local system rivals paid solutions costing hundreds of dollars per month sends a strong signal to the entire market.

For teams already using AI agents in their outreach or development workflows, MemPalace is worth at least a pilot test. The barrier to entry is zero, and the potential productivity gains are substantial.