Knows You Like a Colleague
Every AI conversation starts the same way: re-explaining your projects, re-stating your preferences, re-describing decisions you already made. Native memory helps — Claude stores ~150 items, ChatGPT ~50 — but it's siloed to one provider and disappears when you switch.
One Memory System, Everywhere
Gnosis gives every AI assistant the same persistent memory — across 14+ clients including Claude, ChatGPT, Gemini, Cursor, VS Code, Copilot CLI, and any MCP-compatible tool. Switch from Claude to ChatGPT? Your memories come with you. Open Cursor after a Claude Code session? It already knows your project.
Memories aren't flat text blobs. Each one is typed — fact, decision, task, preference, or file path — with structure that makes retrieval precise. Tasks track progress with markdown checkboxes that surface automatically across sessions. Preferences shape your AI's behavior from turn one.
Your data stays yours
Gnosis is designed so you're never locked in:
- One-click JSON export — download your entire memory corpus at any time, in a format you can inspect, back up, or take somewhere else
- No proprietary formats — memories are structured JSON with standard vector embeddings. Not tied to a proprietary index or storage system
- Import from other services — planned support for bringing data from Claude.ai, ChatGPT, and plain text (see roadmap)
Full data sovereignty means you can leave at any time with everything you built. We'd rather earn your continued use than trap you.
Finds What Matters, Fast
The hard problem with AI memory isn't storage — it's discovery. How does your AI know what you've stored without reading everything? Most memory systems solve this by dumping random samples into context and hoping something relevant shows up. That wastes tokens and misses what matters.
A Map, Not a Grab Bag
At session start, Gnosis returns a topic landscape — a structured map of your entire knowledge graph. Your AI sees topic clusters with counts, type distributions, active tasks with progress, and your behavioral preferences. Every token carries signal. Nothing is random. Nothing is wasted.
When your AI needs specifics, semantic search finds memories by meaning — not keywords. A search for "database performance" finds memories about query optimization even if they never use the word "performance." Results arrive in under 100ms — faster than one LLM thinking token.
Preview-then-retrieve: how search stays efficient
Gnosis returns compressed previews, not full memories. Your AI scans 32 previews in roughly 400 tokens, picks the ones it needs, and retrieves only those in full:
- Breadth first — 32 previews in ~400 tokens vs 3,000–5,000 tokens for 10 traditional RAG chunks. An order of magnitude less context for better coverage
- Depth on demand — your AI reads previews, identifies the 2–3 it actually needs, and retrieves only those. The AI decides what to read, not the system
- Deep search — comprehensive queries return up to 100+ results with cross-encoder reranking for maximum recall
The key insight is who decides what to read. In traditional RAG, the system guesses which chunks are relevant. In Gnosis, your AI makes that choice.
Consolidation — executive summaries from dozens of memories
When a topic accumulates enough memories, your AI can distill them into an executive summary. The summary surfaces near the top of future searches, giving new sessions instant context without reading every individual memory.
Think of it as the difference between reading 30 meeting notes and reading a well-written project brief. Both contain the same information. One takes 30 seconds.
Quality You Don't Manage
Most AI memory systems store everything and hope for the best. The result is a corpus full of vague notes, near-duplicates, and context-free fragments that pollute future conversations. Cleaning up after a sloppy memory system is worse than not having one at all.
99.8% Grade B+ or Better — With No Server-Side AI
Gnosis has no server-side LLM filtering your memories. Instead, deeply refined MCP tool descriptions guide your AI toward writing structured, specific, searchable memories in the first place. The quality comes from the protocol, not from surveillance. Audited across 2,095 memories.
This works even with small 8B-parameter models. The tool descriptions encode creation guidelines, topic conventions, and quality heuristics directly into the schema — the same schema every LLM reads before deciding what to write. Good structure is the path of least resistance.
Two-tier deduplication
Your memory corpus stays clean without manual maintenance:
- Hash fast-path — exact text matches caught instantly by content hashing. Zero overhead, zero false positives
- Semantic similarity — new memories are embedded and compared against existing ones. Near-duplicates are caught and the AI is given the existing memory to update instead
- Conservative thresholds — the system would rather store a near-duplicate than silently drop new knowledge. Better safe than silent
The corpus gets more accurate over time as redundant entries are caught and consolidated — growing in quality, not noise.
Full transparency — no black box
Every operation is visible in your conversation. Every memory_add call shows you what was stored. Every search result comes back where you can read it. If your AI stores something wrong, you see it and correct it on the spot.
The correction replaces the bad memory at the source. No orphaned data, no conflicting versions. The system gets more accurate over time because mistakes are caught where they happen — not discovered three weeks later when the AI confidently repeats something wrong.
Private By Architecture
When you evaluate a memory service, ask one question: "Can the operator read my data?" If the answer is "they won't" instead of "they can't," that's a policy. Policies change — with new ownership, legal pressure, or a single rogue employee.
"Can't, Not Won't"
Your memories are encrypted at rest using AES-256 with per-user keys derived from your credentials. Keys exist only in memory during active sessions — never written to disk, never stored in a database, never accessible to an admin panel. There is no master key. We cannot decrypt your memories. This is enforced by cryptography, not policy.
Gnosis acts as a GDPR data processor — it stores what your AI tells it to store, never making editorial decisions on its own. There is no server-side LLM deciding what's "important enough" to keep. No invisible filtering. No content surveillance. What goes into your memory is between you and your AI.
What encryption means for compliance
The encryption architecture provides concrete legal protections beyond the security benefit:
- GDPR Article 34(3)(a) — encrypted data breaches do not require individual user notification
- US state safe harbors — multiple state breach notification laws exempt encrypted data
- Privacy by design — GDPR Article 25 compliance is architectural, not bolted on after the fact
The encryption was designed from day one to support SOC 2 and HIPAA certification. The remaining work is auditing and certification, not redesign.
Full data sovereignty
Your data stays under your control at every stage:
- Export anytime — one-click JSON download of your entire memory corpus
- Delete permanently — account deletion removes data from production within 30 days, backups within 90
- Take it somewhere else — encrypted content is storage-agnostic. Keys are derived from your identity, not tied to the hosting system
We hold the data. You hold the keys. If you leave, the data you leave behind is ciphertext we can't read.
Coming Soon
Gnosis is in active development. These are honest priorities, not promises with dates.
Shared Collections
Team knowledge bases with contributor roles. Public knowledge packs for framework docs and API references. Stored once, linked by many.
Artifacts
Attach files, images, and documents to memories. Searchable summaries with preview-then-retrieve — full files only when your AI needs them.
Agent Identities
Separate memory namespaces for different AI personas under your account. Each agent gets its own memory space while you retain visibility.
REST API
Direct HTTP access beyond MCP. Build custom integrations, dashboards, or agentic workflows that read and write memories programmatically.