Overview
Hippo is a memory layer for AI agents built on a claim in its own tagline: the secret to good memory is not remembering more, it is knowing what to forget. Most agent memory systems save everything and search later, which is storage with semantic search bolted on — it is why an agent can hit the same deploy bug four weeks running without ever concluding it should remember. Hippo instead models the hippocampus: memories decay over time, retrieval makes them stronger, and three layers (buffer, episodic, semantic) consolidate during a "sleep" pass.
It also fixes the portability problem. ChatGPT memories do not travel to Claude and `.cursorrules` do not travel to Codex; Hippo is one process behind every agent, with CLAUDE.md files, Cursor rules, ChatGPT exports, markdown and Slack history landing in a single SQLite store that any MCP or HTTP client can query. Storage is a SQLite backbone with markdown mirrors, so it is git-trackable and human-readable, and there are zero runtime dependencies — embeddings are opt-in and nothing is auto-installed.
The repo leads with receipts rather than adjectives: R@5 of 74.0% on the 500-question LongMemEval retrieval benchmark using BM25 alone with no embeddings; 10 of 10 staged incident scenarios beating transcript replay; zero outbound HTTP on a 1000-event ingestion smoke test, proven with a fetch spy that throws rather than a hardcoded zero; and 926 tests against a real database with no mocks. One earlier informal magnitude claim on its sequential-learning benchmark was retracted in v1.7.9 while the mechanism stayed shipped.
What it does
- Biological memory model: decay by default, strengthening through retrieval, and buffer / episodic / semantic consolidation during `hippo sleep`
- One SQLite store per project with markdown mirrors — git-trackable, human-readable, zero runtime dependencies
- Works with Claude Code, Codex, Cursor, OpenClaw, OpenCode, Pi and any MCP client; imports CLAUDE.md, `.cursorrules`, ChatGPT exports, Slack and markdown
- Errors decay slower than ordinary observations, so a failure tagged once resurfaces whenever the agent re-enters that part of the code
- Provenance on every row (`kind`, `scope`, `owner`, `artifact_ref`), making right-to-be-forgotten a single API call
- Multi-tenant support with scrypt-hashed API keys and an audit log on every mutation
Getting started
Node.js 22.5+ is the only prerequisite. `hippo init` auto-detects your agent framework and wires itself in — patching CLAUDE.md, AGENTS.md or `.cursorrules` as appropriate.
Install and initialise everything at once
`--scan` finds every git repo under your home directory, creates a `.hippo/` store in each, and seeds it with lessons from the last 30 days of commit history.
npm install -g hippo-memory && hippo init --scan ~Or start with a single project
Run it from the repo you want to give memory to. It reports which agent hook it installed.
cd my-project
hippo initRecord and recall by hand
Tagging something as an error makes it decay slower, so the lesson keeps surfacing. `--budget` caps the tokens a recall is allowed to return.
hippo remember "FRED cache silently dropped the tips_10y series" --tag error
hippo recall "data pipeline issues" --budget 2000Opt in to Codex session capture
Init prints this command when it detects Codex; it wraps the codex launcher only when you ask for it, and is reversible.
hippo hook install codex
# undo with: hippo hook uninstall codexLet it consolidate
`hippo sleep` runs at session end via the auto-installed hooks: it learns from the day's commits, imports new CLAUDE.md MEMORY entries, consolidates and prunes, deduplicates near-identical memories keeping the stronger copy, and shares high-value lessons to a global store.
hippo sleepCommands and code are distilled from the project's own documentation — always check the official repo for the latest.
When to use it
- Stop a coding agent from re-hitting the same bug by tagging the failure once and letting it resurface on every return to that code
- Carry one set of memories across Claude Code, Cursor and Codex instead of maintaining three separate rule files
- Keep agent memory local and inspectable — SQLite plus markdown mirrors that you can commit and diff
- Run a multi-tenant memory service with per-tenant isolation, hashed API keys and a mutation audit log
How Hippo compares
Hippo alongside other open-source agent memory tools AI/TLDR tracks, ranked by GitHub stars.
| Tool | Stars | What it does |
|---|---|---|
| Claude-Mem | ★ 93.6k | Persistent memory layer for coding agents: it captures what an agent does during a session, compresses it into semantic summaries, and injects the relevant parts back into later sessions. |
| Mem0 | ★ 65.1k | A memory layer that you add to existing LLM agents to extract, store, and recall user facts and preferences across sessions using vector, graph, and key-value backends. |
| MemPalace | ★ 59k | Local-first agent memory that stores conversations verbatim instead of summarising them, with a structured palace index, pluggable vector backends and an MCP server. |
| OpenViking | ★ 36.5k | A context database that stores an agent's memories, resources, and skills as one browsable viking:// filesystem with three-tier (abstract/overview/details) on-demand loading. |
| Graphiti | ★ 30.8k | A library that builds a temporal knowledge graph from an agent's conversations and data so facts can be tracked and queried as they change over time. |
| Cognee | ★ 30.6k | A graph-native memory engine that turns raw documents and conversations into a queryable knowledge graph for agents that need to build lasting knowledge. |
| Supermemory | ★ 29.6k | A memory and context engine that ingests information across tools and sessions and can run fully locally, acting as a second brain for AI applications. |
| Hippo | ★ 742 | Memory for coding agents, modelled on the hippocampus — decay by default |