shodh-memory vs mem0 vs Zep vs MemGPT: Which AI Agent Memory System Should You Use?

AI agents need memory. But which memory system should you actually use? In 2026, four serious options exist: shodh-memory, mem0, Zep, and MemGPT (now Letta). Each takes a fundamentally different approach to the same problem.

This is not a marketing page. Every system has strengths and trade-offs. The right choice depends on your constraints — where your agent runs, how much you care about privacy, whether you need cognitive features or just a key-value store with vectors.

The Contenders

shodh-memory

mem0

Zep

MemGPT / Letta

Head-to-Head Comparison

Privacy & Data Sovereignty

This is where the architectures diverge most sharply.

**shodh-memory** runs entirely offline. Embeddings are computed locally using MiniLM-L6-v2 via ONNX Runtime. No API calls, no network requests, no data leaving your machine. You can run it on an air-gapped system or a Raspberry Pi in a factory.

**mem0** requires external APIs for embeddings. Every memory you store sends data to OpenAI or Cohere's servers. Your agent's memories — user preferences, conversation history, learned patterns — all leave your infrastructure.

**Zep** is cloud-first. The managed service stores your data on Zep's infrastructure. Self-hosting is possible but requires multiple services. Either way, the system was designed around cloud assumptions.

**MemGPT/Letta** depends on the LLM backend. If you're using OpenAI, your memories pass through their API. If you're running a local LLM, you can keep everything offline — but you need significant GPU resources.

**Verdict:** If privacy matters — edge deployments, healthcare, defense, financial services — shodh-memory is the only system designed for it from the ground up.

Cognitive Capabilities

This is where "memory system" means different things to different projects.

**shodh-memory** implements five neuroscience mechanisms: Hebbian learning (connections strengthen on co-access), biologically plausible decay (exponential → power-law), three-tier promotion (working → session → long-term), spreading activation in the knowledge graph, and consolidation during maintenance cycles. Every constant is calibrated from published neuroscience research.

**mem0** provides store-and-retrieve with vector similarity. It recently added graph memory, but there's no decay, no learning, no consolidation. Memories are static once stored.

**Zep** has temporal awareness and knowledge graphs, making it more sophisticated than mem0. But it lacks Hebbian learning, biologically plausible decay, or tier-based promotion. The graph is structural, not cognitive.

**MemGPT/Letta** takes a radically different approach: it uses the LLM itself to manage memory. The LLM decides what to remember, what to forget, and what to page into context. This is powerful for reasoning but expensive — every memory operation costs LLM inference tokens.

**Verdict:** shodh-memory for cognitive depth, MemGPT for LLM-native approaches, Zep for managed simplicity with graphs, mem0 for basic store-retrieve in Python.

Performance

**shodh-memory** runs everything locally with Rust-level performance. Sub-microsecond graph lookups, sub-millisecond writes, 34-58ms semantic search. No network round-trips.

**mem0** and **Zep** are network-bound. Every operation involves at least one API call — often two (embed + store/search). Expect 100-500ms per operation minimum, plus the cost of external service calls.

**MemGPT** is the slowest by design. Every memory operation involves LLM inference, which can take seconds. The trade-off is intelligence — the LLM makes smart decisions about what to remember.

**Verdict:** shodh-memory wins on raw performance by orders of magnitude. MemGPT trades performance for intelligence. mem0 and Zep are bounded by network latency.

Edge & IoT Deployment

Can you run it on a robot? A drone? A Raspberry Pi in a factory?

**shodh-memory:** Yes. Designed for it. ARM64 cross-compilation, ~30MB binary, no runtime dependencies. Runs on Pi Zero with <200MB RAM.

**mem0:** No. Requires internet for embedding APIs.

**Zep:** No. Cloud-first architecture.

**MemGPT/Letta:** Only with a local LLM, which requires substantial GPU resources. Not viable on resource-constrained devices.

**Verdict:** shodh-memory is the only option for edge/IoT/robotics deployments.

Developer Experience

**mem0** wins on initial simplicity. `pip install mem0ai`, import, call `.add()` and `.search()`. If you're already in the Python/LangChain ecosystem, it's the fastest path to "working."

**Zep** has polished SDKs and a managed service. If you want to pay for someone else to run the infrastructure, Zep is the easiest path.

**shodh-memory** requires installing a binary (npm, pip, or cargo) and running a server, but provides an MCP server that integrates directly with Claude Code and Cursor. The REST API has 60+ endpoints covering every operation.

**MemGPT/Letta** has the steepest learning curve. The virtual context management paradigm is powerful but requires understanding how paging works and how the LLM manages memory state.

When to Choose What

**Choose shodh-memory when:**

**Choose mem0 when:**

**Choose Zep when:**

**Choose MemGPT/Letta when:**

The Bigger Picture

The fact that four different projects exist with four different architectures tells you something: the industry hasn't converged on how AI memory should work. We're still in the early days.

shodh-memory bets that neuroscience has already solved this problem — that Hebbian learning, decay curves, and three-tier architectures are the right foundation because they've been validated by 75 years of biological memory research. The other systems bet on simpler approaches (mem0), cloud infrastructure (Zep), or LLM-native management (MemGPT).

In five years, one of these approaches will dominate. Our bet is on the one that mirrors how memory actually works.