🦛 Hippo

The secret to good memory isn't remembering more. It's knowing what to forget.

Works with:  Claude Code, Codex, Cursor, OpenClaw, OpenCode, Pi, any CLI agent
Imports from: ChatGPT, Claude (CLAUDE.md), Cursor (.cursorrules), any markdown
Storage:     SQLite backbone + markdown/YAML mirrors. Git-trackable and human-readable.
Dependencies: Zero runtime deps. Requires Node.js 22.5+. Optional embeddings via @xenova/transformers.

AI agents forget everything between sessions. Existing solutions just save everything and search later. That's a filing cabinet, not a brain.

Your memories are also trapped. ChatGPT knows things Claude doesn't. Cursor rules don't travel to Codex. Switch tools and you start from zero.

• Multi-tool developers. You use Claude Code on Monday, Cursor on Tuesday, Codex on Wednesday. Context doesn't carry over. Hippo is the shared memory layer across all of them.
• Teams where agents repeat mistakes. The agent hit the same deployment bug last week. And the week before. Hippo's error memories and decay mechanics mean hard lessons stick and noise fades.
• Anyone whose CLAUDE.md is a mess. Your instruction file grew to 400 lines of mixed rules, preferences, and stale workarounds. Hippo gives that structure: tags, confidence levels, automatic decay of outdated info.
• People who want portable AI memory. No vendor lock-in. Markdown files in your repo. Import from ChatGPT, Claude, Cursor. Export by copying a folder.

npm install -g hippo-memory

# Single project
hippo init

# All your projects at once (recommended)
hippo init --scan ~

--scan finds every git repo under your home directory, creates a .hippo/ store in each one, and seeds it with lessons from your commit history. One command, instant memory across all your projects.

After setup, hippo sleep runs automatically at session end (via agent hooks) and does three things:

1. Learns from today's git commits
2. Consolidates memories (decay, merge, prune)
3. Shares high-value lessons to the global store so they surface in every project

# Manual usage
hippo remember "FRED cache silently dropped the tips_10y series" --tag error
hippo recall "data pipeline issues" --budget 2000

• Configured embedding models now work end to end. hippo embed, hybrid search, and physics search all respect embeddings.model from .hippo/config.json.
• Safe rebuild on model change. If you switch embedding models, rerun hippo embed. Hippo now rebuilds cached embeddings and resets physics state so old vectors are not mixed with the new model.

• Multi-project auto-discovery. hippo init --scan [dir] finds all git repos under a directory and initializes each one. Seeds with a full year of git history by default. One command to set up memory across all your projects.

• Auto-share to global. hippo sleep now promotes high-value memories to the global store automatically. Universal lessons travel across projects; project-specific memories stay local. No manual hippo promote needed.

• Auto-learn from git. hippo init seeds the store with 30 days of commit history. hippo sleep captures today's commits before consolidation. New users get instant memory; existing users get continuous learning. Both skippable with --no-learn.

• Adaptive decay for intermittent agents. Memories now decay based on how often the agent actually runs, not wall-clock time. A weekly agent's memories persist ~7x longer automatically. Three modes via decayBasis in .hippo/config.json: "adaptive" (default), "session", or "clock".

• OpenClaw backup cleanup. Plugin updates no longer leave hippo-memory.bak-* directories that cause duplicate plugin ID errors. Cleanup runs automatically at boot.

• Security: command injection fixed. OpenClaw plugin now uses execFileSync (no shell). All user input is passed as array args, eliminating shell injection vectors.
• 25+ bug fixes across search, embeddings, physics, MCP server, store, and CLI: NaN propagation, token budget accuracy, atomic writes, FTS/LIKE escaping, Buffer-based MCP parsing, protocol compliance, and more. See CHANGELOG for the full list.

• Configurable global store. Set $HIPPO_HOME or use XDG ($XDG_DATA_HOME/hippo) to put the global store wherever you want. Falls back to ~/.hippo/ if neither is set.

• OpenClaw error capture filtering. The autoLearn hook now applies three filters before storing tool errors: noise pattern filter, per-session rate limiting (max 5), and deduplication. Prevents memory pollution from infrastructure noise.
• Orphaned embedding pruning. hippo embed removes cached vectors for deleted memories.
• Cross-platform path handling. OpenClaw plugin uses path/posix for consistent .hippo detection on Unix with Windows-style paths.

• Reward-proportional decay. Outcome feedback now modulates decay rate continuously instead of fixed half-life deltas. Memories with consistent positive outcomes decay up to 1.5x slower; consistent negatives decay up to 2x faster. Mixed outcomes converge toward neutral. Inspired by R-STDP in spiking neural networks. hippo inspect now shows cumulative outcome counts and the computed reward factor.
• Public benchmarks. Two benchmarks in benchmarks/: a Sequential Learning Benchmark (50 tasks, 10 traps, measures agent improvement over time) and a LongMemEval integration (industry-standard 500-question retrieval benchmark, R@5=74.0% with BM25 only). The sequential learning benchmark is unique: no other public benchmark tests whether memory systems produce learning curves.

• Active invalidation. hippo learn --git detects migration and breaking-change commits and actively weakens memories referencing the old pattern. Manual invalidation via hippo invalidate "REST API" --reason "migrated to GraphQL".
• Architectural decisions. hippo decide stores one-off decisions with 90-day half-life and verified confidence. Supports --context for reasoning and --supersedes to chain decisions when the architecture evolves.
• Path-based memory triggers. Memories auto-tagged with path:<segment> from your working directory. Recall boosts memories from the same location (up to 1.3x). Working in src/api/? API-related memories surface first.
• OpenCode integration. hippo hook install opencode patches AGENTS.md. Auto-detected during hippo init. Integration guide with MCP config and skill for progressive discovery.
• hippo export outputs all memories as JSON or markdown.
• Decision recall boost. 1.2x scoring multiplier for decision-tagged memories so they surface despite low retrieval frequency.

• Auto-sleep on session exit. hippo hook install claude-code now installs a Stop hook in ~/.claude/settings.json so hippo sleep runs automatically when Claude Code exits. hippo init does this too when Claude Code is detected. No cron needed, no manual sleep.

• Working memory layer (hippo wm push/read/clear/flush). Bounded buffer (max 20 per scope) with importance-based eviction. Current-state notes live separately from long-term memory.
• Session handoffs (hippo handoff create/latest/show). Persist session summaries, next actions, and artifacts so successor sessions can resume without transcript archaeology.
• Session lifecycle with explicit start/end events, fallback session IDs, and hippo session resume for continuity.
• Explainable recall (hippo recall --why). See which terms matched, whether BM25 or embedding contributed, and the source bucket (layer, confidence, local/global).
• hippo current show for compact current-state display (active task + recent session events), ready for agent injection.
• SQLite lock hardening: busy_timeout=5000, synchronous=NORMAL, wal_autocheckpoint=100. Concurrent plugin calls no longer hit SQLITE_BUSY.
• Consolidation batching: all writes/deletes happen in a single transaction instead of N open/close cycles.
• --limit flag on hippo recall and hippo context to cap result count independently of token budget.
• Plugin injection dedup guard prevents double context injection on reconnect.

• Hybrid search blends BM25 keywords with cosine embedding similarity. Install @xenova/transformers, run hippo embed, recall quality jumps. Falls back to BM25 otherwise.
• Configure a custom embedding model with embeddings.model in .hippo/config.json. If you change models later, rerun hippo embed so Hippo rebuilds cached embeddings and physics state for the new vector space.
• Schema acceleration auto-computes how well new memories fit existing patterns. Familiar memories consolidate faster; novel ones decay faster if unused.
• Multi-agent shared memory with hippo share, hippo peers, and transfer scoring. Universal lessons travel between projects; project-specific config stays local.
• Conflict resolution via hippo resolve <id> --keep <mem_id>. Closes the detect-inspect-resolve loop.
• Agent eval benchmark validates the learning hypothesis: hippo agents drop from 78% trap rate to 14% over a 50-task sequence.

hippo init auto-detects your agent framework and wires itself in:

cd my-project
hippo init

# Initialized Hippo at /my-project
#    Directories: buffer/ episodic/ semantic/ conflicts/
#    Auto-installed claude-code hook in CLAUDE.md

If you have a CLAUDE.md, it patches it. AGENTS.md for Codex/OpenClaw/OpenCode. .cursorrules for Cursor. No manual hook install needed. Your agent starts using Hippo on its next session.

It also sets up a daily cron job (6:15am) that runs hippo learn --git and hippo sleep automatically. Memories get captured from your commits and consolidated every day without you thinking about it.

To skip: hippo init --no-hooks --no-schedule

Your memories shouldn't be locked inside one tool. Hippo pulls them in from anywhere.

# ChatGPT memory export
hippo import --chatgpt memories.json

# Claude's CLAUDE.md (skips existing hippo hook blocks)
hippo import --claude CLAUDE.md

# Cursor rules
hippo import --cursor .cursorrules

# Any markdown file (headings become tags)
hippo import --markdown MEMORY.md

# Any text file
hippo import --file notes.txt

All import commands support --dry-run (preview without writing), --global (write to ~/.hippo/), and --tag (add extra tags). Duplicates are detected and skipped automatically.

Extract memories from raw conversation text. No LLM needed: pattern-based heuristics find decisions, rules, errors, and preferences.

# Pipe a conversation in
cat session.log | hippo capture --stdin

# Or point at a file
hippo capture --file conversation.md

# Preview first
hippo capture --file conversation.md --dry-run

Long-running work needs short-term continuity, not just long-term memory. Hippo can persist the current in-flight task so a later continue has something concrete to recover.

hippo snapshot save \
  --task "Ship SQLite backbone" \
  --summary "Tests/build/smoke are green, next slice is active-session recovery" \
  --next-step "Implement active snapshot retrieval in context output"

hippo snapshot show
hippo context --auto --budget 1500
hippo snapshot clear

hippo context --auto includes the active task snapshot before long-term memories, so agents get both the immediate thread and the deeper lessons.

Manual snapshots are useful, but real work also needs a breadcrumb trail. Hippo can now store short session events and link them to the active snapshot so context output shows the latest steps, not just the last summary.

hippo session log \
  --id sess_20260326 \
  --task "Ship continuity" \
  --type progress \
  --content "Schema migration is done, next step is CLI wiring"

hippo snapshot save \
  --task "Ship continuity" \
  --summary "Structured session events are flowing" \
  --next-step "Surface them in framework hooks" \
  --session sess_20260326

hippo session show --id sess_20260326
hippo context --auto --budget 1500

Hippo mirrors the latest trail to .hippo/buffer/recent-session.md so you can inspect the short-term thread without opening SQLite.

When you're done for the day (or switching to another agent), create a handoff so the next session knows exactly where to pick up:

hippo handoff create \
  --summary "Finished schema migration, tests green" \
  --next "Wire handoff injection into context output" \
  --session sess_20260403 \
  --artifact src/db.ts

hippo handoff latest              # show the most recent handoff
hippo handoff show 3              # show a specific handoff by ID
hippo session resume              # re-inject latest handoff as context

Working memory is a bounded scratchpad for current-state notes. It's separate from long-term memory and gets cleared between sessions.

hippo wm push --scope repo \
  --content "Investigating flaky test in store.test.ts, line 42" \
  --importance 0.9

hippo wm read --scope repo        # show current working notes
hippo wm clear --scope repo       # wipe the scratchpad
hippo wm flush --scope repo       # flush on session end

The buffer holds a maximum of 20 entries per scope. When full, the lowest-importance entry is evicted.

See why a memory was returned:

hippo recall "data pipeline" --why --limit 5

# --- mem_a1b2c3 [episodic] [observed] [local] score=0.847
#     BM25: matched [data, pipeline]; cosine: 0.82
#     ...memory content...

Input enters the buffer. Important things get encoded into episodic memory. During "sleep," repeated episodes compress into semantic patterns. Weak memories decay and disappear.

New information
      |
      v
+-----------+
|  Buffer   |  Working memory. Current session only. No decay.
| (session) |
+-----+-----+
      |  encoded (tags, strength, half-life assigned)
      v
+-----------+
|  Episodic |  Timestamped memories. Decay by default.
|   Store   |  Retrieval strengthens. Errors stick longer.
+-----+-----+
      |  consolidation (hippo sleep)
      v
+-----------+
|  Semantic |  Compressed patterns. Stable. Schema-aware.
|   Store   |  Extracted from repeated episodes.
+-----------+

         hippo sleep: decay + replay + merge

Every memory has a half-life. 7 days by default. Persistence is earned.

hippo remember "always check cache contents after refresh"
# stored with half_life: 7d, strength: 1.0

# 14 days later with no retrieval:
hippo inspect mem_a1b2c3
# strength: 0.25  (decayed by 2 half-lives)
# at risk of removal on next sleep

Use it or lose it. Each recall boosts the half-life by 2 days.

hippo recall "cache issues"
# finds mem_a1b2c3, retrieval_count: 1 -> 2
# half_life extended: 7d -> 9d
# strength recalculated from retrieval timestamp

hippo recall "cache issues"   # again next week
# retrieval_count: 2 -> 3
# half_life: 9d -> 11d
# this memory is learning to survive

When you migrate from one tool to another, old memories about the replaced tool should die immediately. Hippo detects migration and breaking-change commits during hippo learn --git and actively weakens matching memories.

hippo learn --git
# feat: migrate from webpack to vite
#    Invalidated 3 memories referencing "webpack"
#    Learned: migrate from webpack to vite

You can also invalidate manually:

hippo invalidate "REST API" --reason "migrated to GraphQL"
# Invalidated 5 memories referencing "REST API".

One-off decisions don't repeat, so they can't earn their keep through retrieval alone. hippo decide stores them with a 90-day half-life and verified confidence so they survive long enough to matter.

hippo decide "Use PostgreSQL for all new services" --context "JSONB support"
# Decision recorded: mem_a1b2c3

# Later, when the decision changes:
hippo decide "Use CockroachDB for global services" \
  --context "Need multi-region" \
  --supersedes mem_a1b2c3
# Superseded mem_a1b2c3 (half-life halved, marked stale)
# Decision recorded: mem_d4e5f6

Tag a memory as an error and it gets 2x the half-life automatically.

hippo remember "deployment failed: forgot to run migrations" --error
# half_life: 14d instead of 7d
# emotional_valence: negative
# strength formula applies 1.5x multiplier

# production incidents don't fade quietly

Every memory carries a confidence level: verified, observed, inferred, or stale. This tells agents how much to trust what they're reading.

hippo remember "API rate limit is 100/min" --verified
hippo remember "deploy usually takes ~3 min" --observed
hippo remember "the flaky test might be a race condition" --inferred

When context is generated, confidence is shown inline:

[verified] API rate limit is 100/min per the docs
[observed] Deploy usually takes ~3 min
[inferred] The flaky test might be a race condition

Agents can see at a glance what's established fact vs. a pattern worth questioning.

Memories unretrieved for 30+ days are automatically marked stale during the next hippo sleep. If one gets recalled again, Hippo wakes it back up to observed so it can earn trust again instead of staying permanently stale.

Hippo now detects obvious contradictions between overlapping memories and keeps them visible instead of silently letting both masquerade as truth.

hippo sleep       # refreshes open conflicts
hippo conflicts   # inspect them

Open conflicts are stored in SQLite, mirrored under .hippo/conflicts/, and linked back into each memory's conflicts_with field.

Memories aren't presented as bare assertions. By default, Hippo frames them as observations with dates, so agents treat them as context rather than commands.

hippo context --framing observe   # default
# Output: "Previously observed (2026-03-10): deploy takes ~3 min"

hippo context --framing suggest
# Output: "Consider: deploy takes ~3 min"

hippo context --framing assert
# Output: "Deploy takes ~3 min"

Three modes: observe (default), suggest, assert. Choose based on how directive you want the memory to be.

Run hippo sleep and episodes compress into patterns.

hippo sleep

# Running consolidation...
#
# Results:
#    Active memories:    23
#    Removed (decayed):   4
#    Merged episodic:     6
#    New semantic:        2

Three or more related episodes get merged into a single semantic memory. The originals decay. The pattern survives.

Did the recalled memories actually help? Tell Hippo. It tightens the feedback loop.

hippo recall "why is the gold model broken"
# ... you read the memories and fix the bug ...

hippo outcome --good
# Applied positive outcome to 3 memories
# reward factor increases, decay slows

hippo outcome --bad
# Applied negative outcome to 3 memories
# reward factor decreases, decay accelerates

Outcomes are cumulative. A memory with 5 positive outcomes and 0 negative has a reward factor of ~1.42, making its effective half-life 42% longer. A memory with 0 positive and 3 negative has a factor of ~0.63, decaying nearly twice as fast. Mixed outcomes converge toward neutral (1.0).

Recall only what fits. No context stuffing.

# fits within Claude's 2K token window for task context
hippo recall "deployment checklist" --budget 2000

# need more for a big task
hippo recall "full project history" --budget 8000

# machine-readable for programmatic use
hippo recall "api errors" --budget 1000 --json

Results are ranked by relevance * strength * recency. The highest-signal memories fill the budget first.

Hippo can scan your commit history and extract lessons from fix/revert/bug commits automatically.

# Learn from the last 7 days of commits
hippo learn --git

# Learn from the last 30 days
hippo learn --git --days 30

# Scan multiple repos in one pass
hippo learn --git --repos "~/project-a,~/project-b,~/project-c"

The --repos flag accepts comma-separated paths. Hippo scans each repo's git log, extracts fix/revert/bug lessons, deduplicates against existing memories, and stores new ones. Pair with hippo sleep afterwards to consolidate.

Ideal for a weekly cron:

hippo learn --git --repos "~/repo1,~/repo2" --days 7
hippo sleep

Wrap any command with hippo watch to auto-learn from failures:

hippo watch "npm run build"
# if it fails, Hippo captures the error automatically
# next time an agent asks about build issues, the memory is there

hippo init detects your agent framework and patches the right config file automatically:

No extra commands needed. Just hippo init and your agent knows about Hippo.

If you prefer explicit control:

hippo hook install claude-code   # patches CLAUDE.md + adds Stop hook to settings.json
hippo hook install codex         # patches AGENTS.md
hippo hook install cursor        # patches .cursorrules
hippo hook install openclaw      # patches AGENTS.md
hippo hook install opencode      # patches AGENTS.md

This adds a <!-- hippo:start --> ... <!-- hippo:end --> block that tells the agent to:

1. Run hippo context --auto --budget 1500 at session start
2. Run hippo remember "<lesson>" --error on errors
3. Run hippo outcome --good on completion

For Claude Code, it also adds a Stop hook to ~/.claude/settings.json so hippo sleep runs automatically when the session exits.

To remove: hippo hook uninstall claude-code

## Project Memory (Hippo)

Before starting work, load relevant context:
hippo context --auto --budget 1500

When you hit an error or discover a gotcha:
hippo remember "<what went wrong and why>" --error

After completing work successfully:
hippo outcome --good

For any MCP-compatible client (Cursor, Windsurf, Cline, Claude Desktop):

hippo mcp   # starts MCP server over stdio

Add to your MCP config (e.g. .cursor/mcp.json or claude_desktop_config.json):

{
  "mcpServers": {
    "hippo-memory": {
      "command": "hippo",
      "args": ["mcp"]
    }
  }
}

Exposes tools: hippo_recall, hippo_remember, hippo_outcome, hippo_context, hippo_status, hippo_learn, hippo_wm_push.

Native plugin with auto-context injection, workspace-aware memory lookup, and tool hooks for auto-learn / auto-sleep.

openclaw plugins install hippo-memory
openclaw plugins enable hippo-memory

Plugin docs: extensions/openclaw-plugin/. Integration guide: integrations/openclaw.md.