Memory & Context

hermes-agentTools & Integrations

Hermes Agent is Nous Research's own agent: a terminal UI plus a single gateway process that carries the same conversation into Telegram, Discord, Slack, WhatsApp, Signal and Email, with a cron scheduler, isolated subagents, and seven terminal backends from local and Docker to Modal and Vercel Sandbox. Its distinguishing piece is a closed learning loop — the agent curates its own memory on periodic nudges, creates skills after complex tasks, and searches past sessions through FTS5 with LLM summarization — which means the state that makes it useful accumulates under `~/.hermes`, outside your version control, and needs occasional pruning. It is an assistant you run and configure rather than a library you build on: the README documents `hermes` subcommands and slash commands, not an embedding API, so it is a poor fit if you wanted an agent loop to call from your own code. Putting a shell-capable agent behind chat platforms also makes the command-approval and DM-pairing settings load-bearing rather than optional.

claude-memMemory & Context

It hooks into the agent's lifecycle, captures every tool call, and has a small model — Claude Haiku by default, on your existing subscription or key — compress the stream into titled observations that are injected back at the next session's start; search goes through MCP tools staged from cheap index lines to full detail. Storage is local SQLite with an optional vector index, installs are documented beyond Claude Code for OpenCode, Cursor and Codex CLI, and a private tag keeps marked text out of storage. Adopt it knowing what it is: a resident daemon plus Bun and Python tooling rather than a passive plugin, compression that spends real model quota every session, and a project that went through thirteen major versions in its first year.

Mem0Memory & Context

Extracts durable facts from a conversation and retrieves the relevant ones on later runs, instead of replaying an ever-growing transcript into the context window. Useful wherever an assistant should remember a user between sessions. What gets stored is model-decided, so verify the extraction quality on your own data before relying on it.

MemPalaceMemory & Context

Most memory systems make an agent decide what was worth remembering and store its summary, which means a detail nobody thought important is gone by the time it matters. MemPalace takes the other route: conversations are kept verbatim, and the structure goes into the index rather than the content — people and projects become wings, topics become rooms, the original text sits in drawers — so a search can be aimed at part of the archive instead of run flat against everything. It runs on your machine, exposes itself over MCP so a coding agent can search it directly, and can sit on Chroma, SQLite, Milvus, Qdrant or Postgres. Mining is something you run, not something that happens by itself.

GraphitiMemory & Context

Most memory layers overwrite: a new fact replaces the old one and last year's answer becomes unrecoverable. Graphiti instead marks the old relationship as no longer holding, with the dates attached, so both what is true now and what was true then remain queryable — and it separates when something happened from when the system learned about it, which is what keeps late-arriving information from rewriting history. Retrieval combines vector similarity, full-text search and graph traversal. The costs are concrete: a graph database has to run alongside your stack, and every ingest calls a model to extract entities and relationships.

Planning with FilesMemory & Context

A long task fails in a particular way: the agent had a plan, the context was cleared or compacted, and what comes back is an agent confidently finishing a different job. This skill moves the plan out of the conversation and onto disk — one file for the plan, one for what has been found, one for what is done — and puts them back in front of the agent on every turn. Because the plan is a file, it outlives a clear, a crash and a compaction, and you can read it yourself while the run is going. An optional gate stops the agent declaring completion until the plan says so. The maintainers publish blind A/B results, which is more than most skills offer.

LettaMemory & Context

Treats the context window like RAM and everything else like disk, with the agent itself deciding what to page in and out. That framing makes indefinitely long-running agents tractable. It is a more opinionated commitment than bolting a memory library onto an existing stack.

DistillyTools & Integrations

When the person who knew why the system is like that leaves, the documentation they wrote turns out to be the small half of what they knew. Distilly is an attempt at the other half: you give it their messages, documents, interviews or public writing, and it produces a profile of the observable pattern — how they decided things, what they insisted on, how they said it — packaged as a skill an agent can load. The maintainers are careful about what it claims, and so should you be: the output is grounded in the material you supplied and does not claim to be the person. The obvious caution is consent, since the material it works from is usually someone else's.

HindsightMemory & Context

Storing an agent's conversations and searching them back is the easy half. The hard half is that the same thing gets said ten times in slightly different words, and a later correction has to win over an earlier statement. Hindsight is built around that: related facts are merged into a single belief that carries its evidence and updates as new evidence arrives, so a change of mind reads as an update rather than as two contradictory records. Retrieval runs four strategies at once — meaning, keywords, relationships and time — because a question about what changed last month is not answered by similarity. It is a server you run rather than a library you import, with an MCP interface and clients in several languages.