Each names the one binding constraint that picks the tool, the primary pick (which may sit in another family when the case spans more than one), and the runner-ups worth knowing.
Personal assistant that knows you over time
Binding constraint: Build an evolving model of a person, not a pile of facts — answer 'what would this user actually want / believe here.'
Pick
Honcho — The only tool in the reasoning family. Its background deriver infers preferences, beliefs, and contradictions and lets you query them in natural language — the gap between recalling a stated fact and predicting a reaction.
Runner-up
- Memobase — If you only need a structured profile (name, prefs, attributes), not reasoning — cheaper and more predictable, weaker on nuance.
From Agentic Memory: Use-Case Playbook 2026 · last verified 2026-07-01
Multi-agent system with shared or perspectival memory
Binding constraint: Model 'what does agent A know vs agent B,' or 'what does the support persona think the customer wants.'
Pick
Honcho — The peer primitive (agents and ideas can be peers, many-to-many sessions) is the only native model of perspective.
Runner-up
- Mem0 — A shared store with clean agent_id/run_id isolation — but no perspective modeling.
From Agentic Memory: Use-Case Playbook 2026 · last verified 2026-07-01
Production B2B / customer-support agent at scale
Binding constraint: Multi-tenant isolation + compliance (SOC2/HIPAA) + customer 'current state' (plan, tier, tickets) that changes.
Pick
Supermemory — SOC2/HIPAA (Scale tier), connectors, context fencing, sub-300ms, multi-tenant.
Runner-up
- Zep (Graphiti) — If temporal state (a customer's current plan/tickets that drift) is the heart of it.
Hard no: Cognee — no SOC2/HIPAA as of mid-2026, disqualifying for regulated data.
From Agentic Memory: Use-Case Playbook 2026 · last verified 2026-07-01
Cost-sensitive, high-volume ingestion
Binding constraint: Lots of data, tight budget.
Pick
Memori — Drops the vector DB and runs on SQL + LLM extraction — ~80–90% cheaper infra than vector-backed stores.
Runner-ups
- OpenViking — Tiered L0/L1/L2 loading gives ~80–90% token savings on reads. Pick this when cost is per-call tokens, not infrastructure.
- Honcho — Also cheap at $2/1M ingested if managed is acceptable.
From Agentic Memory: Use-Case Playbook 2026 · last verified 2026-07-01
Project tracking — always-current state, ingest everything, no end date
Binding constraint: Supersession. The hard part isn't storing state, it's making sure last month's status never resurfaces as current.
Pick
Hand-curation is the honest default — you own supersession by editing the living doc yourself.
A curated LLM wiki (Obsidian/PARA-style) is the correct architecture here, because you curate and overwrite the living document. A memory product only wins when one of the runners-up's unique property becomes the pain.
Runner-ups
- Zep (Graphiti) — When hand-curation can't keep up: its core feature — validity windows (valid_at/invalid_at) with automatic supersession — IS 'always current state.' It can also answer 'how did this project's scope drift over the quarter,' which a wiki can't unless you wrote that history by hand.
- ByteRover — When you want to keep editable markdown but add retrieval: its Domain→Topic→Subtopic tree is wiki-shaped, git-friendly, hand-editable.
- DiffMem — When you want git-versioned markdown AND automatic change-tracking without a graph DB: it stores memory as git-diffable markdown (no vector DB, no embeddings) and answers 'how has this fact changed?' from git history, with a current-state focus that keeps stale status from resurfacing as current.
Why not Cognee here: it accumulates a corpus but is weaker at 'this new fact replaces that old one.' Supersession is Zep's lane.
From Agentic Memory: Use-Case Playbook 2026 · last verified 2026-07-01
Deep research / time-bounded decision — ingest more than fits in an LLM, reason with HITL
Binding constraint: Corpus ingestion + multi-hop reasoning toward a conclusion.
Pick
Cognee — ECL pipeline ingests 38+ formats into an ontology-grounded graph with 14 retrieval modes including multi-hop — the GraphRAG engine the 'won't fit in one LLM' requirement demands. Pair with Hindsight's reflect to synthesize.
Runner-up
- Hindsight — reflect walks all memories to form cross-cutting conclusions and retains full turns including your agent's tool calls, so the research trail is itself queryable. Pick Hindsight alone when the bottleneck is an agentic loop where synthesis and 'what did we already try' dominate.
If you must pick one: Cognee when the bottleneck is ingesting/structuring data; Hindsight when it's an agentic loop. Boundary: for a static document pile needing only grounded Q&A (no ongoing agent), a NotebookLM-style tool is overkill's opposite — a memory product is overkill.
From Agentic Memory: Use-Case Playbook 2026 · last verified 2026-07-01
Coding agent / dev assistant
Binding constraint: Exact-token recall (function names, error codes, variable names — semantic search fails here) + capturing decisions before a long session is compacted.
Pick
ByteRover — The pre-compression hook grabs 'we decided X / Y didn't work' before the context window summarizes it away, and markdown lives next to code in git.
Runner-ups
- RetainDB — If exact-symbol retrieval precision is the specific pain — hybrid BM25 + vector + rerank gives exact-token recall that semantic search misses.
- Engram — If you want a single-binary, agent-agnostic option explicitly built to survive context compaction: a zero-dependency Go binary over one SQLite file, FTS5 read path with no ML inference, working across Claude Code / Codex / Cursor / Gemini CLI via MCP.
From Agentic Memory: Use-Case Playbook 2026 · last verified 2026-07-01
Voice agent / latency-critical
Binding constraint: Retrieval can't stall a live conversation.
Pick
ByteRover — Cache/FTS primary read path is LLM-free and sub-100ms; the LLM is a last-resort fallback only (and can be kept local).
Runner-up
- Supermemory — Sub-300ms if you want managed richness and can spend the latency budget.
From Agentic Memory: Use-Case Playbook 2026 · last verified 2026-07-01
Self-improving agent that learns how to do tasks
Binding constraint: Procedural learning — get better at a recurring task, update behavior from past wins.
Pick
LangMem — The only one with explicit procedural memory + prompt optimization from episodic successes (native if you're on LangGraph).
Runner-ups
- PowerMem — Distills past interactions into reusable Skill records and injects them across Claude Code, Codex, OpenCode, and Cline — procedural memory you adopt without switching agents.
- MemRL — If your agent can emit reward signals: MemRL's RL filter keeps only strategies with verified positive outcomes, improving memory selection from experience with a frozen backbone (no fine-tuning) — a different mechanism than LangMem's prompt rewriting. Research codebase (source install, no pip package yet), so budget integration effort.
From Agentic Memory: Use-Case Playbook 2026 · last verified 2026-07-01
Offline / air-gapped / privacy-absolute (legal, medical, journaling, edge)
Binding constraint: No network, no third party, ideally no LLM call at all.
Pick
ByteRover — Local markdown; the cache/FTS primary read path is LLM-free and sub-100ms, with the LLM only as a last-resort fallback (keepable local) — nothing leaves the device.
Runner-ups
- Memori — If local-but-LLM-assisted is acceptable — SQL on a local file, no vector DB.
- Vestige — The zero-LLM purist option: a single self-contained Rust binary (SQLite+FTS5 + local USearch HNSW, optional SQLCipher encryption at rest) with a cognitive decay/consolidation model and no LLM call at all — nothing leaves the device. AGPL-3.0, so confirm license fit before embedding in a commercial product.
From Agentic Memory: Use-Case Playbook 2026 · last verified 2026-07-01