Encrypted Memory for AI Agents.

AES-256-GCM encryption with zero-knowledge architecture. Every note and memory is encrypted client-side before it ever leaves your device. The server stores only ciphertext — not even ExoVault can read your data. Per-field encryption with fresh random IVs, PBKDF2 key derivation (600K iterations), and a wrapped Master Encryption Key that never touches the network.

Plain text on disk — if your machine is compromised, everything is exposed. No encryption layer, no access control. Your entire knowledge base is one bad actor away from full exposure.

Hybrid search combining 70% semantic (vector cosine similarity via pgvector HNSW indexes over 1536-dimensional embeddings) with 30% keyword scoring (weighted: title 3x, tags 2x, content 1x). Thousands of notes searched in milliseconds. Configurable similarity thresholds, automatic fallback to recency when embeddings aren't available, and stopword filtering for precision.

File scanning with manual index files and tree commands. The author of the Obsidian approach admits searching thousands of notes is 'impossible' — so they build workarounds: flat index files that Claude scans sequentially, MOC (Map of Content) pages, and session-start hooks that dump folder trees. It works for hundreds of notes but degrades linearly.

Built for multi-agent from day one. Atomic lockfile-based token refresh (O_EXCL, 10s stale detection) ensures only one agent refreshes credentials at a time. Per-agent usage tracking with agent IDs, session logging, and token cost accounting. Claude, GPT, Cursor, and custom agents all share the same encrypted memory through the MCP protocol.

Single Claude Code session operating on files. No coordination between agents, no shared state. If you run Cursor and Claude Code simultaneously, they'll stomp on each other's changes. There's no concept of concurrent access or conflict resolution.

Five structured memory types (fact, skill, preference, constraint, task) with importance scores (1–5), confidence ratings (1–5), provenance tracking (which agent wrote it, from which session, and why), optional expiration dates, and access counting. Retrieval uses a blended heuristic: 60% semantic similarity + 20% importance + 15% recency + 5% confidence.

Everything is a markdown file with the same status. A fleeting shower thought sits next to a verified technical fact. There's no way for the agent to distinguish importance, confidence, or relevance — it's all just text in folders.

A queryable knowledge graph with typed relations (wiki_link, derived_from, contradicts, refines, supersedes, and more). Wiki-links from Obsidian imports are preserved as first-class graph edges. Multi-hop traversal follows connections up to 5 hops deep. Agents can query backlinks, follow relation chains, and discover connections between memories and notes automatically.

Wiki-links in Obsidian create implicit connections, but they're just text patterns — no typed relations, no traversal API, no way for agents to follow connections programmatically. If the link target is renamed or moved, the connection silently breaks.

Cloud-native with Supabase PostgreSQL backend. Configure the MCP server on any device — your encrypted vault is there instantly. Session tokens auto-refresh across devices, and atomic locking prevents concurrent refresh conflicts. Works from any machine with Node.js.

Requires Obsidian Sync ($4/mo), git workflows, or iCloud/Dropbox to access from another machine. Each device needs Claude Code installed and configured separately, with no guarantee of consistent state across machines.

Durable memory with idempotent writeback using external write IDs (prevents duplicate entries from agent retries). An async embedding pipeline chunks content, generates vector embeddings, and indexes them for semantic retrieval. Every memory tracks its provenance — which agent, which run, which reasoning chain produced it — so you can audit and trust what your agents remember.

The agent leaves 'breadcrumbs' as notes in MOC files for future sessions — clever, but fragile. These notes live in the same folder as your content and can be accidentally edited, moved, or deleted. There's no indexing pipeline, no deduplication, and no way to verify what the agent 'learned' is still accurate.

Import your Obsidian vault directly — upload a .zip and ExoVault parses your markdown files, preserves wiki-links as queryable note relationships, encrypts everything on arrival, and makes it all semantically searchable. Your existing knowledge graph transfers intact, enhanced with vector search and encryption.

You build the system from scratch: create folders, write a CLAUDE.md (often 2000+ lines), establish naming conventions, build index files, and manually maintain MOC pages. The initial setup cost is significant and the conventions are bespoke to each user.