Stop re‑teaching
your agent.
The mistake your agent made on Monday is a memory by Tuesday. Hippo plugs into Claude Code, Codex, Cursor and any MCP client, keeps what worked, drops what turned out to be wrong, and replaces facts that changed.
98.0% R@5 on LongMemEval-S with a free local embedder (best of five settings).
R@1 0.41 to 0.62 (the Jev reranker eval, opens in new tab) with the opt-in Jev reranker, against the free local cross-encoder. Ranking only: no answer-rate win was shown.
npm install -g hippo-memory Works with
- Claude Code
- Codex
- Cursor
- OpenClaw
- OpenCode
- Pi
- any MCP client
an illustrated session · the hippo lines are real hippo output
How hippo remembers
Every lesson is a point of light. Use keeps it lit.
The mark is a hippocampus, the part of the brain that decides what to keep. Hippo applies the same rules to what your agents learn.
- Recalled. A memory that gets used grows stronger and lasts longer.
- Fading. Unused memories fade over a year, a default we have not tuned, then move to a dormant store you can restore.
- Marked wrong. A lesson that turned out wrong drops out of recall. Ban a value and it never returns.
The problem
Most AI memory saves everything and searches later.
That's storage with semantic search bolted on. It's why your agent kept hitting the same deploy bug last week. And the week before.
The system saw the failure four times. It had no way to know it should remember.
How it works
Memories decay. Retrieval makes them stronger.
The layers borrow from the brain as design inspiration. On our tests, decay made no measurable difference to recall and sleep cost a little. Outcome marks and supersession are what measured helpful.
New information lands here. Session-only, no decay.
Timestamped, decays by default. Retrieval strengthens it; errors stick.
Repeated episodes compress into stable patterns. The originals decay.
weak traces are forgotten; repeated ones consolidate during sleep
strength = decay over time, re-strengthened on every recall
Decay by default
Every memory fades on a one-year half-life unless it is used. We did not tune 365 days: it tied with 730 days and with decay off.
Retrieval strengthens
Use it or lose it. Each recall extends the half-life. Memories you reach for survive.
Errors stick
Tag a failure once. It decays slower and resurfaces every time you walk back into that code.
Sleep consolidates
On `hippo sleep`, three or more related episodes merge into one semantic pattern. The originals decay; the pattern survives. It keeps the store tidy; it has not been shown to improve recall.
Get started
Zero config. It wires itself in.
Install it, point it at your repos, and hippo auto-detects your agent framework and patches the right config file. Next session, your agent just uses it.
Detected and patched automatically
- Claude Code
- Codex
- Cursor
- OpenClaw
- OpenCode
The only memory layer that installs its own hooks. No manual wiring.
- 1 $
npm install -g hippo-memory - 2 $
hippo init --scan ~
Then hippo sleep runs at session end via the
auto-installed hook and consolidates what you learned.
Local-first
By default, your memory never leaves your machine.
Proven by a globalThis.fetch spy that throws on call, across the 1000-event ingestion smoke. Not a hardcoded zero. The default recall path makes no network call either; opt-in features such as the Jev reranker, the LLM reranker and the API embedders do.
Memories live in a local .hippo/ store you can read, grep, and git-track. No cloud, no account, no telemetry.
Right-to-be-forgotten is a single API call. Every row carries kind, scope, owner, and provenance.
Multi-tenant keys are scrypt-hashed with an audit log on every mutation. Tenant A cannot see tenant B, proven by a negative test.
And it's not locked to one tool.
Your ChatGPT memories don't travel to Claude; your .cursorrules don't travel to Codex. Hippo is one store behind all of them.
Receipts
Numbers, including the losses.
every claim links to its source
Compare
Learn what is wrong. Stop repeating it.
How hippo compares to the strongest tools in the category, on the features that define a memory lifecycle.
scroll for more tools →
Full 10-tool matrix on GitHub →
* Hippo's 98.0% (free local MiniLM, an optional install) and 99.8% (voyage-3-large, measured 2026-06-09) are on longmemeval_s_cleaned, per-question haystack, the split and metric of gbrain's published 97.6%. Each is the best of five settings in the benchmark scripts, not hippo recall; at 500 questions 98.0 and 97.6 are a tie. The June 2026 build scored 98.6. An older 86.8% on longmemeval_oracle used pooled (non-per-haystack) retrieval and is not comparable.
** Different metric: Memoria's 88.78% and EverMind's 83% are reported as overall accuracy with a reader LLM, not retrieval R@5. Higher denominator + LLM helps. Not directly comparable to retrieval-only R@5 numbers above.
Verdicts are shortened for scanning; the qualifier behind each Yes/No/Partial is in the full matrix.
Different tools answer different questions. Mem0 and Basic Memory implement "save everything, search later." MemPalace organizes spatially. gbrain, Zep, and Cognee extract typed entities into a knowledge graph. Letta lets the agent edit its own memory blocks. Memoria is Git-style version control over memory. EverMind is self-evolving Skill Memory. Hippo implements "learn what is wrong and stop repeating it."
FAQ
Questions, answered.
Is this just RAG?
No. RAG retrieves from a static corpus; hippo is a memory lifecycle. Memories decay on a half-life, retrieval strengthens them, errors stick, and sleep consolidates repeats into patterns. Mark a memory wrong and it stops coming back; a newer fact replaces the old one.
Does it need embeddings?
No. Recall runs on BM25 out of the box (74% R@5 on LongMemEval, BM25 only). Embeddings are an optional dependency for hybrid scoring; nothing is required at runtime.
Where does my data go?
Nowhere, unless you opt in. Everything is a local SQLite store with markdown mirrors: 0 outbound HTTP on the ingestion smoke, proven by a fetch spy. No cloud, no account, no telemetry. Opt-in features change that. hippo recall --reranker jev sends your query and your candidate memory text to TypeSafe, and the LLM reranker and the API embedders send text to the provider you configure. Each is off unless you turn it on.
Which agents does it work with?
hippo init auto-installs hooks for Claude Code, Codex, Cursor, OpenClaw, and OpenCode, and exposes an MCP server for any MCP client (Cursor, Windsurf, Cline, Claude Desktop).
How is hippo different from mem0, Letta, or Zep?
hippo optimizes the full memory lifecycle. mem0 and similar tools save and search; Zep and Cognee extract entities into a knowledge graph; Letta has the agent edit its own memory blocks. hippo learns what turned out wrong and stops repeating it, with outcome marks, supersession, conflict detection, and sleep consolidation, and it runs locally with zero runtime dependencies.
Is it production-ready?
It is MIT-licensed at v1.52.2, with 3,500+ tests against a real database and no mocked store. Multi-tenant isolation is proven by a negative test.
One command. Every repo gets memory.
Zero config. SQLite under the hood, zero runtime deps, works with every CLI agent you have.
npm install -g hippo-memory hippo init --scan ~