Skip to content

Self-Improving Agent Frameworks vs. Smart Memory Management: The Tooling Landscape

Research date: Aug 13, 2026. Star counts are from the GitHub API on the research date and change daily. Several repos in this niche show anomalously high counts; see the data-quality note before trusting any number here.

Short answer

No — a self-improving agent framework is not the same thing as smart memory management, but in the Claude Code / Codex CLI ecosystem the two have almost completely merged in practice.

Self-improvement needs more than a memory store. It needs:

  • a capture loop (hooks / plugins / MCP that observe the session),
  • a distillation step (compressing raw transcripts into facts, decisions, skills),
  • a retrieval step (injecting the right context on the next run),
  • an application step (the agent actually changes its own behavior: its prompt, memory blocks, skills, or tools), and
  • ideally a verification/refinement loop (evidence-backed edits that can be rolled back).

Smart memory management is the storage + retrieval substrate underneath (episodic transcripts, semantic facts, procedural skills, temporal knowledge graphs). Every practical "self-evolving" tool for Claude Code / Codex is memory-first: the self-improvement they deliver today is mostly "it remembers better and refactors its own context." Only a few projects (Letta, Prime Agent) go further and let the agent rewrite the harness itself.

So the framing to use when evaluating tools: memory is the substrate, self-improvement is the loop built on it.

The memory taxonomy used below

Layer What it stores Where it appears in tools
Working / session memory Current task context CLI transcript, CLAUDE.md injection
Episodic memory Session history, tool-use observations claude-mem, claude-memory-compiler
Semantic memory Facts, preferences, project rules mem0, Zep/Graphiti, EverOS
Procedural memory Skills, reusable workflows superpowers, anthropics/skills, MemOS
Self-improvement loop Refining the above over time letta-code, prime-agent, OpenViking

What you asked for, mapped

You asked for tools that let a user collect, augment, categorize, share, and manage memory. Against that checklist:

  • Collect — every hooks/plugin tool below (claude-mem, claude-memory-compiler, obsidian-*).
  • Augment — tools that re-derive context and add knowledge: mem0 (memory updates on add), Graphiti (temporal fact extraction), EverOS (self-evolving reuse).
  • Categorize — knowledge-graph or file-folder structure: OpenViking (viking:// filesystem), Zep (entities/facts/episodes), obsidian-* (Markdown vault), MemOS (memory cubes).
  • Share — Markdown files in a vault or git repo (EverOS, letta-code MemFS, obsidian-*), cloud sync (claude-mem → cmem.ai), multi-agent memory (MemOS, Zep).
  • Manage — edit/delete/correct: MemOS (feedback-driven correction), letta-code (/doctor, /palace), Graphiti (temporal invalidation).

Catalog: drop-in self-evolution for Claude Code / Codex CLI

Group A — Plugins, hooks, and skills that bolt onto an existing CLI

These are the true "drop-in on top of Claude Code or Codex" tools.

claude-mem — thedotmack/claude-mem

  • Stars: ~90,500 · TypeScript · Apache-2.0
  • What it is: persistent memory compression for Claude Code (and OpenCode, Antigravity CLI, OpenClaw). Installed via npx claude-mem install or the plugin marketplace. Five lifecycle hooks (SessionStart, UserPromptSubmit, PostToolUse, Stop, SessionEnd), a local worker with SQLite + FTS5 + Chroma hybrid search, 4 MCP search tools with a 3-layer progressive-disclosure workflow, and a mem-search skill.
  • Who backs it: solo author Alex Newman (@thedotmack); no VC backing. Participant in the Vercel OSS program; Trendshift-featured; listed in the "Awesome Claude Code" index.
  • Who endorsed it: community-maintained; also officially embraces the community CMEM token (token is 3rd-party, creator-endorsed) — worth knowing, since it signals a crypto-adjacent growth strategy rather than institutional backing.

claude-memory-compiler — coleam00/claude-memory-compiler

  • Stars: ~1,300
  • What it is: hooks that capture sessions and evolve a Claude Code memory that tracks your codebase.
  • Who backs it: solo developer (coleam00).

claude-code-auto-memory — severity1/claude-code-auto-memory

  • Stars: ~155
  • What it is: Claude Code plugin that automatically maintains CLAUDE.md files — the simplest "self-managing memory" pattern.

claude-memory-engine — HelloRuru/claude-memory-engine

  • Stars: ~132
  • What it is: hooks + markdown memory system, zero dependencies (popular with Chinese-speaking users).

obsidian-second-brain — eugeniughelbur/obsidian-second-brain

  • Stars: ~4,000
  • What it is: persistent memory for Claude Code and 6 other CLI agents, stored as plain Markdown in an Obsidian vault. You can read, edit, and version your agent's memory by hand.

obsidian-mind — breferrari/obsidian-mind

  • Stars: ~4,300
  • What it is: self-organizing Obsidian vault memory for Claude Code, Codex CLI, and Gemini CLI.

basic-memory — basicmachines-co/basic-memory

  • Stars: ~3,600
  • What it is: Markdown-first memory for AI conversations (MCP-based), a personal-knowledge-base flavor of agent memory.
  • Who backs it: BasicMachines, a small company ("basicmemory.com", Discord community).

mem0 (OpenMemory) — mem0ai/mem0

  • Stars: ~63,000
  • What it is: the "universal memory layer" — add/learn/retrieve API, memory compression engine, MCP integration, self-hostable (OpenMemory) or hosted.
  • Who backs it: Y Combinator S24; ~$24M raised; founders Taranjeet Singh (CEO) and Deshraj Yadav (CTO, ex-Tesla, EvalAI).
  • Who endorsed it: SOC 2 / HIPAA / GDPR compliance claims; 90k+ developers; MCP server widely installed.

Graphiti — getzep/graphiti

  • Stars: ~30,000 (companion getzep/zep: ~4,800)
  • What it is: temporal knowledge-graph memory for agents, with an official MCP server so Claude/Cursor can query it. Facts carry validity dates; contradictions invalidate old facts instead of piling up.
  • Who backs it: Zep, Inc. (founder Daniel Chalef), an enterprise memory company.
  • Who endorsed it: S&P Global Market Intelligence wrote an April 2026 report ("Zep tackles agent memory limitations through its temporal context graph"); named customers include Samsung, Zscaler, Twin Health; testimonials from Torq's VP of Product Ken Collins and AlphaSignal's Lior Sinclair.

Group B — Full self-evolving harnesses (replace the CLI, don't bolt onto it)

Letta / Letta Code — letta-ai/letta (~24,000★) + letta-ai/letta-code (~3,000★)

  • What it is: the MemGPT lineage (UC Berkeley Sky Computing). Letta Code is a stateful agent harness with memory blocks, skill learning, MemFS (git-based memory, syncable to a repo), sleep-time compute (offline reflection), /doctor and /palace memory management. Agents rewrite their own prompts, skills, and even harness mods.
  • Who backs it: Letta, an SF research lab; founded by MemGPT creators Charles Packer and Sarah Wooders; advised by Ion Stoica and Joey Gonzalez; backed by Jeff Dean, Clem Delangue (Hugging Face), Robert Nishihara (Ray), plus Sunflower Capital, Essence VC, and Felicis Ventures.
  • Who endorsed it: WIRED, Fast Company, TechCrunch coverage; case studies at Bilt, 11x, Kognitos, Hunt Club.

Prime Agent — PrimeIntellect-ai/prime-agent

  • Stars: ~14,800
  • What it is: self-improving Recursive Language Model (RLM) agent. The "Continual Harness" stores supplemental prompts, memories, skill descriptions, and subagent specs as durable state the agent refines via small evidence-backed updates (/refine), with snapshots for rollback. Persistent IPython control environment; skills are importable Python packages.
  • Who backs it: Prime Intellect, a decentralized-compute org (also behind PRIME-RL and the Verifiers open-source reward framework). Not a Claude Code/Codex plugin — a standalone harness, but conceptually the deepest "self-improving" option here.

OpenViking — volcengine/OpenViking

  • Stars: ~28,300 · AGPLv3
  • What it is: a "self-evolving Context Database" that unifies memory, RAG knowledge, and skills under a viking:// virtual filesystem. Content is tiered (L0 abstract / L1 overview / L2 detail) and loaded on demand to cut tokens; sessions asynchronously distill into long-term memory.
  • Who backs it: Volcengine, ByteDance's cloud division — the rare corporate-backed open-source entry in this niche.
  • Who endorsed it: Trendshift-featured; active Chinese + English community (Lark, WeChat, Discord).

EverOS — EverMind-AI/EverOS

  • Stars: ~12,000
  • What it is: local-first, Markdown-native memory layer ("portable memory for every agent"); conversations/agent trajectories stored as readable .md, indexed via SQLite + LanceDB, "self-evolving reuse." Markdown is the source of truth, so you can edit memory directly and git-version it.
  • Who backs it: EverMind AI (org; "evermind.ai"). Community via Discord/WeCom.

MemOS — MemTensor/MemOS

  • Stars: ~10,700
  • What it is: a "memory operating system" unifying store/retrieve/manage with multi-modal memory (text, images, tool traces), "memory cubes" for isolation and controlled sharing, and feedback-driven correction. Ships local/cloud plugins for OpenClaw and Hermes.
  • Who backs it: MemTensor, associated with the IAAR-Shanghai "Awesome-AI-Memory" list. Has an arXiv paper (2507.03724).
  • Who endorsed it: benchmark claims: OpenClaw task completion 36.6% → 50.9% with MemOS; LoCoMo 88.83; LongMemEval 89.20; leads OmniMemEval (14 commercial products, 10 datasets).

Group C — Skills frameworks and marketplaces (self-improvement as skill accretion)

These are the "skills" route to self-improvement rather than the "memory" route.

  • superpowers — obra/superpowers (~271,000★): Jesse Vincent's agentic skills framework + development methodology for Claude Code. The de-facto standard for a skill-based self-improving workflow.
  • anthropics/skills (~168,000★): Anthropic's official Agent Skills repo — the format that skills for Claude Code are built on.
  • agents — wshobson/agents (~39,000★): Will Shobson's multi-harness plugin marketplace for Claude Code, Codex CLI, Cursor, OpenCode, and GitHub Copilot.

⚠️ Data-quality note: treat star counts with suspicion

While researching, several repos in this niche report implausibly high star counts. Examples:

  • obra/superpowers at ~271k stars and anthropics/skills at ~168k — both are real, well-known projects, but counts in the 100k+ range are above even the most popular developer tools on the entire platform and are consistent with the wave of automated star-inflation that has been hitting agent/memory repos through 2025–2026.
  • Many short-lived repos (created 2026, e.g. affaan-m/ECC ~240k★, multica-ai/andrej-karpathy-skills ~202k★) top GitHub's search results for "claude memory" with near-zero credibility.

Practical reading: stars are a weak signal in this category right now. Prefer signals that are harder to fake: named VC backing (mem0, Letta, Zep), corporate backing (OpenViking), an arXiv paper (MemOS, Graphiti), analyst reports (Zep/S&P), or a visible single maintainer with a long commit history (claude-mem).

Bottom line

  • If you want a drop-in memory upgrade for Claude Code or Codex today, the strongest options are claude-mem (hooks + skills + MCP, ~90k stars, solo-maintained but mature) and, if you want your memory in Markdown you can read and edit, the Obsidian-vault tools or EverOS.
  • If you want a self-hosted knowledge layer with real categorization, look at OpenViking (filesystem metaphor) or Graphiti (temporal graph, MCP).
  • If you want the agent to actually rewrite its own harness, that's Letta Code or Prime Agent — and note they replace the CLI rather than layering on top.
  • Conceptual takeaway: self-improving ≠ smart memory. Memory is necessary but not sufficient; skills, planning, and a refinement loop are what turn "remembers more" into "gets better." Almost everything marketed as "self-evolving" for coding agents in mid-2026 is, on inspection, a very good memory system wearing that label.