hy·per·mne·sia n.

unusually vivid or complete memory; abnormally sharp recall of the past.

Your coding agent forgets.
This is its memory.

Hypermnesia is a local-first memory system for Claude Code, Cursor, and Google Antigravity. It captures codebase decisions from real sessions, decays stale context, and hydrates future sessions with surgical precision.

Download macOS App (Universal) Try Live Memory Playground →

macOS 14+ • 100% On-Device SQLite • Zero App Telemetry

Brain MRI Replay Monitor

148

Confirmed Memories

96.4%

Healthy & Fresh

1,240

Times Hydrated

142

Live Pulses

Interactive Simulation

See Context Hydration in Action

Select sample prompt scenarios to see how Hypermnesia injects targeted memories vs a memoryless agent guessing blindly.

Select Agent Prompt Scenario:

Or Type Custom Prompt:

✓ WITH HYPERMNESIA
[HYPERMNESIA HYDRATED CONTEXT - 2 Memories Injected]
• [decision] Auth tokens use Ed25519 asymmetric signatures (retired HMAC in v0.2.1)
• [convention] Store local session database in ~/Library/Application Support/Hypermnesia

Agent Output: "Adding profile auth endpoint. Using Ed25519 token validation per decision #142, placing session storage in standard ~/Library path..."

✕ MEMORYLESS AGENT
[NO CONTEXT INJECTED]

Agent Output: "I'll create a standard JWT auth endpoint with HMAC-SHA256 and store state in /tmp/app.db..." ❌ (Violates project convention & retired HMAC decision)

Continuous Pipeline

How Hypermnesia works

Automatic transcript capture, typed memory extraction, contradiction retirement, and confidence decay keep your agent's context accurate and sharp.

01 / CAPTURE

Session Hooks

Editor hooks checkpoint transcript slices without blocking your agent. Out-of-band processing ensures zero session lag.

02 / CLASSIFY

Typed Extraction

Pluggable LLM classifier (Gemini 3.5 Flash default, fallback `claude -p`) extracts typed memories: decision, convention, intent, fact, concern.

03 / CURATE

Dedup & Contradictions

Jaccard deduplication merges near-duplicates. Newer contradicting captures retire older ones automatically; weak writes land as drafts.

04 / DECAY

Graceful Staleness

Memories age through Fresh → Aging → Stale → Dormant unless revalidated by active session usage.

05 / HYDRATE

Context Injection

Relevance-ranked, confidence-gated memories are injected into new agent sessions automatically.

Overnight Intelligence

Memory Dreams

While your machine sleeps, Hypermnesia reflects across past sessions to mine epiphanies and draft reusable skills.

Overnight Reflection Journal

Inspired by overnight learning loops, Memory Dreams consolidates daily agent transcripts while your machine is idle on power. Every entry records exact API calls and cost estimates.

✦ Mines Hidden Epiphanies: Discovers non-obvious architecture patterns across multi-day coding sessions.
✦ Drafts Reusable Skills: Identifies repeated friction and drafts custom skills for your agent.
✦ Human Consent & Budget Control: Off by default. Dreams never auto-confirm memories; drafts land in your inbox for one-tap review.

Multi-Client Integration

One-command setup for all your tools

Works across Claude Code, Cursor, Google Antigravity, and any stdio Model Context Protocol client. Launch the app once and the hypermnesia command is ready in your terminal.

# One command wires hooks, memory guide, and background drain for Claude Code:

$ hypermnesia setup --with-mcp

# Wire Cursor MCP tools and sessionStart / stop hooks:

$ hypermnesia install-cursor-mcp

$ hypermnesia install-cursor-hooks

# Wire Google Antigravity CLI, IDE, and app conversation hooks:

$ hypermnesia install-antigravity-mcp

$ hypermnesia install-antigravity-hooks

# Add Hypermnesia stdio MCP server to any Model Context Protocol config:

JSON { "mcpServers": { "hypermnesia": { "command": "hypermnesia", "args": ["mcp"] } } }

Measured & Honest

Evaluation Benchmarks

Tested on synthetic tasks and real codebase conventions to measure hydration impact objectively.

Convention Recall (All Tasks) 15 / 24 Solved (62.5%)

Memoryless Baseline: 3 / 24 (12.5%)

Explicit Requirement Tasks 12 / 12 Solved (100%)

Memoryless Baseline: 0 / 12 (0%) — Matches Paste-to-Prompt Oracle

"Automatic hydration solved 15/24 convention tasks vs 3/24 for memoryless baseline, and 12/12 on explicit requirements. The full harness, raw logs, and cases where memory hurt are committed in evals/RESULTS.md."

Scriptable Interface

Interactive Terminal Simulator

Click commands below to test real CLI output behavior in real time.

zsh — hypermnesia cli simulator

Try Command:

Frequently Asked

Questions & Answers

Hypermnesia writes your `CLAUDE.md` — `hypermnesia export --markdown` renders a project's confirmed memory as a committable `MEMORY.md`. The difference is everything around that file: memories decay unless they keep proving useful, carry applied/overridden evidence counters, are retired by newer contradicting captures, and are injected by relevance instead of as one ever-growing preamble. A hand-tended `CLAUDE.md` goes stale silently; here staleness is a first-class, visible state.

The retrieval part is deliberately boring (FTS5 + embeddings). The interesting parts sit around it: capture is automatic from real sessions; memories are typed (`decision`, `convention`, `intent`), contradictions are detected at capture time; and decay + belief decide whether a memory is still trustworthy, not just similar. On explicit-memory tasks, hydration matched a paste-the-fact-into-the-prompt oracle.

The database is local SQLite; zero app telemetry. Exactly two things leave your device: transcript slices sent to your configured classifier (Gemini API key or `claude -p`), and stored summaries when using `ask` or `audit --deep`.

Dreams are off by default. Enabling them shows cost estimates first. The budget is capped to one classifier call per project per night while idle on power. Every entry records its estimated cost. Dreams never confirm memories or install skills on their own: drafts go through the review inbox, and skills stage for explicit install with one-tap uninstall.

Measured: yes, once — memory injection broke 1 of 18 adversarial control tasks that the baseline passed. Mitigations are structural: overridden memories lose belief, stale ones fall below the injection floor until revalidated, and risky writes land as drafts for review.

Your coding agent forgets.This is its memory.