How Memory.Wiki works
The personal knowledge hub for the AI era.
The problem
Every day, you get great answers out of an AI. Tomorrow, the AI doesn't remember any of them. The bookmark, the screenshot, the transcript copy you took, all of those break the next time the AI changes UI or rotates a share-link CDN. Your knowledge stays trapped inside individual chat sessions that no one (including you) can deploy back into another tool.
Andrej Karpathy described the same problem and ended up hand-maintaining a personal LLM Wiki. He chose to do it because no consumer surface offered the shape he needed: a place to dump raw answers, distill them into a clean wiki, and add a schema so retrieval stays cheap.
Memory.Wiki is that shape, built for everyone, with the AI doing 80% of the work.
Three layers
Memory.Wiki follows the same architecture Karpathy laid out (raw, wiki, schema), exposed as one product surface instead of three folders.
1. Raw, every captured artifact
The unedited stream. Pasted ChatGPT, Claude, or Gemini share URLs, dropped PDFs, code files, conversation transcripts, agent captures from Claude Code or Cursor. Every capture lands at memory.wiki/<id> as a permanent URL.
| Memory.Wiki | |
|---|---|
| Storage | documents table with a source field (paste, agent, import, share-url) |
| AI-fetchable | memory.wiki/raw/<id> and memory.wiki/raw/bundle/<id> return clean markdown with frontmatter for any LLM that fetches the URL |
| Idempotent | Capturing the same artifact twice doesn't duplicate; each doc has a stable id and an editToken for non-login flows |
2. Wiki, synthesized, navigable knowledge
Captures don't stay raw. They roll up into structured pages: bundles that group related docs around a topic, auto-synthesis that diffs new captures against existing wiki pages so you accept what's worth keeping, and per-hub artifacts (log, lint) that summarize what changed.
| Memory.Wiki | |
|---|---|
| Auto-synthesis | Diff-and-accept UI: new captures generate a proposed wiki update; you accept or skip. Confidence tags ([EXTRACTED], [INFERRED], [AMBIGUOUS]) make the model's certainty visible. |
| Bundles | Multi-doc artifacts conformant to Bundle Spec v1.0. Paste a bundle URL into any AI and it gets the entire grouped context in one fetch. |
| Hub log | memory.wiki/raw/hub/<slug>/log.md is an auto-generated activity log of what was added, edited, and synthesized. |
| Hub lint | memory.wiki/raw/hub/<slug>/lint.md lists gaps, conflicts, and orphan docs as a checklist. |
3. Schema, the connective tissue
Underneath, the system maintains a structured graph: per-doc concept extraction, semantic embeddings (pgvector), bundle-level entity and relationship graphs, hub-wide doc-doc edges, and cross-hub citation rollups. None of this is something you maintain by hand. It's the layer the AI uses to answer your questions about your own knowledge.
| Memory.Wiki | |
|---|---|
| Embeddings | OpenAI text-embedding-3-small per doc, indexed with HNSW for sub-second semantic search across the entire hub. |
| Hub graph | memory.wiki/hub/<slug>/graph shows every doc and bundle as nodes, with semantic and bundle-membership edges, rendered server-side so it loads instantly. |
| Cross-references | Internal Memory.Wiki URLs (/d/, /b/, /hub/) detected across all public hubs. The "most-cited" surface ranks docs by how often other people's hubs link to them. |
| Confidence tags | Synthesized claims carry their provenance (extracted directly, inferred, or ambiguous) so downstream agents can decide what to trust. |
Three operations
The architecture is the static picture. The verbs are what make it usable.
Ingest
How material gets into your hub:
- Paste anything in the editor: text, code, ChatGPT, Claude, or Gemini share URLs.
- Drop a file: PDF, DOCX, PPTX, XLSX, HTML, CSV. Converted to clean markdown.
- Capture from any AI tool with the
/memory.wikiskill: works in Claude Code, Cursor, Codex CLI, and Aider. One install, thensave this to memory.wiki as <title>triggers a permanent URL from inside the tool you're already using. - Bookmarklet and Chrome extension for the web AIs that don't expose a CLI.
- API and MCP for agents writing into your hub directly.
Query
How you (or an AI on your behalf) get knowledge back out:
- Semantic search over your hub embeddings, no exact-keyword matching required.
- Suggested queries: the system pre-computes high-value questions your own hub can answer, and surfaces them as starting points.
- Hub URL as context: paste
memory.wiki/hub/<you>into Claude, ChatGPT, Cursor, or Codex and the AI fetches a clean markdown index, then follows the links to load specific docs as it needs them. The same URL works for every AI.
Lint
How the hub stays coherent over time:
- Auto-synthesis with diff/accept keeps the wiki layer aligned with new captures instead of accumulating stale duplicates.
- Hub lint pass flags gaps, conflicts, and orphans periodically.
- Proactive bundle suggestions: when a topic cluster forms, the system suggests pulling those docs into a bundle so the schema stays organized.
Hub URL = universal context format
This is the part most products miss.
A hub URL is just a markdown index. Any AI that can fetch a URL can read your hub. There's no SDK, no API key, no plugin to install on the AI's side. Cross-AI compatibility falls out for free, because the contract is the URL, not the integration.
The same paste works in Claude, ChatGPT, Cursor, Codex, Aider, Gemini, and any LLM that hasn't been built yet, as long as it can hit an HTTP endpoint and read markdown.
This also means your hub is yours. Vendor memory layers (ChatGPT memory, Claude projects, Cursor docs) all live inside their walls. Memory.Wiki lives at a URL you control, and every vendor's tool reads that URL the same way.
This cross-AI claim is independently verifiable. See MWBench for the open eval: 100% accuracy across Claude, OpenAI, and Gemini, including on content the AIs have never seen during training, with every answer audited against a literal corpus quote.
AI as collaborator
Karpathy wrote his wiki by hand. Memory.Wiki is the same shape, but the AI does the maintenance:
- Synthesis is automatic; you only review the diff.
- Bundle suggestions are proactive; the system finds clusters before you do.
- Lint runs on a schedule; you don't have to remember to clean up.
- Suggested queries are precomputed; you don't have to sit and think "what should I ask my own hub?"
You stay in the loop on what enters the wiki layer (the diff/accept UI is intentional friction). Everything else (embedding maintenance, graph computation, cross-ref tracking, lint passes) is handled.
Try it
- Just paste something at memory.wiki and get a permanent URL in three seconds.
- Browse a real hub at memory.wiki/hub/raymindai.
- Install /memory.wiki in your AI tool: memory.wiki/install.
- Cross-AI verified: MWBench results.
This page is itself a Memory.Wiki doc. Paste its URL into any AI and it loads as context, including the architecture you just read.