Agent Memory Systems — 7-Way Comparison

MetaClaw · OpenSpace · Hermes · Mem0 · Letta · Zep · SimpleMem
swarm.ing research · April 2026

⚡ TL;DR — Three Paradigms

1. Self-Evolving Agent Frameworks (skills + memory + evolution loop): MetaClaw (proxy + RL weight updates), OpenSpace (MCP skill engine), Hermes (full agent with curated memory)

2. Standalone Memory Layers (bolt-on to any agent): Mem0 (vector + graph, 48k★), Zep/Graphiti (temporal knowledge graph), SimpleMem (semantic compression, +64% over Claude-Mem)

3. Agent Runtime with Memory OS: Letta (MemGPT — self-editing memory, LLM-as-OS)

For swarm.ing: Combine OpenSpace (skill evolution via MCP) + Mem0 or SimpleMem (factual memory layer) + steal Letta's self-editing pattern for your ContextManager.

Full Comparison Matrix
DimensionMetaClaw 🦞OpenSpace 🧬Hermes 🪶Mem0 🧠Letta 🖥️Zep ⏱️SimpleMem 📦
Identity
OriginAIMING Lab, UNC Chapel HillHKUDS, Univ. of Hong KongNous ResearchMem0.ai (YC, $24M raised)UC Berkeley → Letta IncZep AI (Graphiti engine)AIMING Lab, UNC
TypeProxy + RL meta-learnerMCP skill engineFull agent frameworkStandalone memory layerAgent runtime (LLM OS)Temporal memory serviceMemory compression lib
GitHub ★~3.2k~5k+~8.8k~48k TOP~38k~4k~3.2k
LicenseMITMITMITApache 2.0Apache 2.0Apache 2.0MIT
Memory Architecture
Memory ModelSkillBank (behavioral) + Contexture (factual, v0.4). Dual: skills + factsSQLite SkillStore with lineage DAG. Skills ARE the memoryMulti-layer: curated facts + FTS5 session index + Honcho user model + skillsTri-store: vector + knowledge graph + KV. User/session/agent scopes WIN3-tier OS: Core (in-context, editable) → Recall → Archival WINTemporal KG via Graphiti. Nodes=entities, edges with time validity WIN3-stage: Compression → Synthesis → Intent-Aware Retrieval
Self-Editing?Auto via LLM evolver + background consolidationAuto FIX/DERIVED/CAPTUREDAgent adds, replaces, consolidates. Security scanningAdaptive — corrects existing memoriesCore innovation — agent edits own context blocks WINAuto entity extraction + temporal edgesOnline synthesis merges fragments at write time
TemporalSkill versioningLineage DAG + timestampsSession timestamps + FTS5Creation timestamps onlyEdit timestamps. No temporal reasoningFirst-class — valid_from/to/invalid_at WINAbsolute timestamps on units
Knowledge GraphNoSkill lineage graphNo (file-based)Yes — Neo4j/Memgraph WINNo (structured blocks)Core IS a temporal KG WINNo (triple-indexed units)
Retrieval & Efficiency
RetrievalTop-k skill retrievalBM25 + embedding → LLM selectFTS5 + LLM summarizationVector + graph + rerankingAgent-driven tool callsGraph walk + semantic tripletsIntent-aware parallel multi-view WIN
Token Efficiency10-20% compression46% savings (GDPVal) WINProgressive L0→L1→L290% fewer vs full-contextVirtual context pagingEpisode summaries~550 tokens for 43.24% F1 WIN
Skill Evolution
EvolutionDual-loop: Fast (skill synth) + Slow (RL LoRA) WINFIX/DERIVED/CAPTURED × 3 triggersSelf-improving loop every 15 tool callsMemory updates onlyLetta Code: skills + subagents + continual learningGraph evolves with episodesNo skill evolution
Weight Updates?Yes — cloud LoRA via Tinker WINNoNo (Atropos offline)NoNoNoNo
Communityopenclaw-skillsopen-space.cloud WINagentskills.io + Skills HubN/AEmergingN/AN/A
Integration
IntegrationProxy wrapping OpenClaw agentsMCP server → any SKILL.md agent WINStandalone + OpenClaw importSDK bolt-on to ANY framework WINFull runtime — agents inside LettaSDK/API bolt-onpip + MCP server
CF Workers FitPersistent proxy neededMCP→ToolRegistry. SQLite→D1 WINExternal via TailscaleAPI calls from DO→Mem0External — heavy runtimeAPI from DO→Zep CloudEmbed in DO possible
Benchmarks
Key ResultK2.5: 21→40.6%. +185% file-check4.2× income. 70.8% quality. -46% tokens8.8k★, 142 contributors+26% over OpenAI Mem. -90% tokens#1 on Terminal-Bench63.8% LongMemEval WIN+64% over Claude-Mem WIN
When to Use Each

MetaClaw

  • Model weights improve over time
  • 24/7 personal agent + idle RL
  • OpenClaw-based stack

OpenSpace

  • Bolt-on skill evolution via MCP
  • Token cost reduction priority
  • Community skill sharing

Hermes

  • Complete standalone agent
  • Multi-platform messaging
  • Rich personal memory

Mem0

  • Memory for existing agent
  • User personalization at scale
  • Graph relationships needed

Letta

  • Agents curate own memory
  • Unlimited virtual context
  • Full agent runtime

Zep

  • Temporal reasoning critical
  • Trading/compliance/audit
  • Multi-hop graph queries

SimpleMem

  • Max token efficiency
  • Lightweight pip/MCP
  • Cross-session personal memory

🏗️ swarm.ing Recommendation

Skill Layer: OpenSpace via MCP → ToolRegistry. FIX/DERIVED/CAPTURED maps to SKILL.md. Skill DB → D1.

Factual Memory: SimpleMem for per-user context (~550 tokens). Or Mem0 if you need graph relationships.

Temporal Layer: Zep/Graphiti for trading temporal reasoning — position history, stop-loss changes, fact validity windows.

Patterns to steal: Letta's self-editing memory → ContextManager. Hermes's L0→L1→L2 progressive disclosure. MetaClaw's OMLS idle scheduler for future LoRA.

All 7 validate: harness engineering > model selection. The moat is in the orchestration.