--- title: "[mdfy.cc](http://mdfy.cc) Launch Checklist" url: https://memory.wiki/P67ESz3Q updated: 2026-05-27T10:58:34.932Z hub: https://memory.wiki/hub/raymindai concept_count: 12 source: "mcp" --- # [mdfy.cc](http://mdfy.cc) Launch Checklist --- ## captured: 2026-05-25 author: founder + AI collaborator status: strategy doc, homepage source, comprehensive aggregation supersedes: v7-revised (memory.wiki/nvF3Li2x), v7 FINAL (memory.wiki/xv6A2DKS), v6 FINAL (memory.wiki/\_4iafQ8K) This doc is the single reference for what Memory.Wiki is right now and where v8 takes it. Sections 1 and 2 are the audit of today. Section 3 is the v8 forward plan in short form. Section 4 is homepage copy distilled from sections 1 and 3. Sections 5 onward expand into the full v8 plan, the strategy history that led here, the MWBench evidence stack, the brand evolution, the locked decisions, and the public docs that need to stay in sync. --- ## 1. What Memory.Wiki is today ### One-line Memory.Wiki is the URL delivery layer for your AI knowledge. You write or capture markdown, it lives at a permanent URL, and any AI can fetch the URL as context. One URL, every AI. ### The three URL primitives Same primitive, three nested scopes: - `memory.wiki/` is a **Document**. One captured artifact, one permanent URL. - `memory.wiki/b/` is a **Bundle**. A curated grouping of docs around a topic, with its own URL. - `memory.wiki/hub/` is a **Hub**. Your entire knowledge layer as a single deployable URL. Each is plain markdown when an AI fetches it (`Accept: text/markdown`). No SDK, no plugin, no MCP server required. ### The capture surfaces (live) - Web editor at `memory.wiki/` (WYSIWYG markdown, paste a ChatGPT or Claude share URL, drop a PDF) - Chrome extension (one-click capture from ChatGPT, Claude, Gemini chat interfaces) - VS Code extension (publish a `.md` file from the editor sidebar) - Mac desktop app (sidebar, folders, offline, signs and notarizes through Apple) - CLI (`memory-wiki-cli` on npm, `mw publish`, `mw capture`, claim flow) - MCP server (`memory-wiki-mcp` on npm, 28 tools for Claude / Cursor / Windsurf / Codex) - QuickLook plugin (preview `.md` files in Finder, bundled with the Mac DMG) ### The retrieval surfaces (live) - Public URL fetch with `Accept: text/markdown` returns clean markdown with frontmatter - `/raw/`, `/raw/b/`, `/raw/hub/` for explicit raw access - `/hub//llms.txt` and `/hub//llms-full.txt` agent manifests - `POST /api/hub//recall` hybrid BM25 plus vector RRF question-targeted retrieval - Hub semantic graph at `/hub//graph` - Cross-hub citation rollup ### The infrastructure under the surface - Doc, chunk, and bundle embeddings on OpenAI `text-embedding-3-small`, HNSW indexed - Hub-wide `concept_index` (per-doc concept extraction via Haiku, idempotent on save) - Bundle `graph_data` (themes, insights, key takeaways, connections, generated on demand from the canvas) - Per-doc `ai_graph` (themes, insights, key takeaways, open questions, idempotent on save) - Quote-evidence judging (any cross-AI answer can be audited against a literal corpus quote) - Backlinks table (self-wiring graph from URL references inside doc bodies) - Hub readiness ledger (internal, not surfaced to users) ### The cross-AI claim, verified The whole product rests on one claim: a single URL works across Claude, ChatGPT, and Gemini. We built MWBench to prove it. Nine rounds, public methodology at `memory.wiki/mwbench`, reproducible harness at the repo. Headline result: | | raymindai (familiar hub) | mwbench-zorblax (synthetic, unseen) | | --- | --- | --- | | Paste mode, full corpus | 100% | 100% | | Paste mode, compact (5 to 9 times cheaper) | 100% | 100% | | Browse mode, AI fetches the URL itself | 98% | 100% | | Tool-use rate | 100% | 100% | | Adversarial refusal | 100% | not run this round | The unseen-hub column is the one that matters. AIs cannot recall a hub they never saw during training, so 100% there means the URL delivery model genuinely works. Not memorisation. ### What's open and reproducible - Harness, runners, judge, query sets, and bench results at `github.com/raymindai/memory-wiki` - Pre-built query sets for hub, bundle, doc, and adversarial scopes - `eval/sweep-all-glyph-clean.mjs` for production content hygiene - `eval/populate-readiness.mjs` for snapshotting bench results into the hub_readiness table ### What's been deliberately removed - The legacy `mdfy` brand. Wordmark, doc bodies, env vars all moved to memory.wiki branding. Old env vars stay as deprecated aliases. - Middle-dot, em-dash, arrow, check mark glyphs from UI surfaces and LLM-generated content. Replaced by comma, slash, parentheses, sentence break. - Per-hub AI readiness badge from the public hub viewer. The wedge is proven at the system level on `/mwbench`. Re-surfacing per-hub implied some hubs would be weaker than others, which is not the product reality. --- ## 2. The product surfaces a real user actually touches ### First-time visitor (signed out) Lands on `memory.wiki/`. Sees the editor immediately, no signup wall. Can paste markdown, get a Document URL in three seconds, share it. Anonymous captures get an edit token stored locally; the next sign-in claims them automatically. ### Capture from any AI tool In Claude Code, Cursor, Codex CLI, or Aider, after installing `/memory.wiki`: ``` save this to memory.wiki as "Auth provider tradeoffs" ``` Returns a permanent URL. Same shape in Chrome on ChatGPT / Claude / Gemini chat pages via the extension. ### Deploy to any AI Paste your hub URL into Claude, ChatGPT, Cursor, or Codex. The AI fetches the hub digest (concept clusters plus all-docs catalog plus per-doc gist plus H2 skeleton), follows the relevant links to load specific docs, answers from what it read. The compact digest is 5 to 9 times cheaper in input tokens than the full body dump, and hits the same accuracy on unseen content. ### Live demo hubs - `memory.wiki/hub/raymindai` is the founder's public hub. Real content, used for the familiar-hub bench numbers. - `memory.wiki/hub/mwbench-zorblax` is a synthetic hub of fictional company facts, seeded for the unseen-content test. Every fact is invented. --- ## 3. Where v8 takes Memory.Wiki (short form) v8 is the next public release. Three threads run in parallel. Section 6 has the full plan. ### Thread 1, brand and surface The legacy `mdfy` brand is gone from user-facing surfaces. v8 ships a new visual identity: - **New animated blob logomark** at `apps/web/public/brand/mwblob_morph.svg` (light) and `mwblob_morph_dark.svg` (dark). Always animated, always paired with the "memory.wiki" wordmark, never standalone. - **Lockup**: blob on the left, "memory" (orange) and ".wiki" (white or dark depending on background) stacked vertically on the right. Marketing surfaces (about hero, mwbench hero, 404, editor splash) use the animated lockup. External assets (favicon, OG image, app store icons) use a static single frame of the same lockup since vendor constraints rule out animation. - **Type system**: Noto Sans body, JetBrains Mono for code and small labels. - **Iconography**: Lucide icons everywhere, consistent stroke weight, single source of truth. - **No middle-dot, em-dash, arrow, check-mark glyph**, or emoji on any UI surface. Comma, slash, parentheses, or sentence break only. LLM-generated content (`documents.summary`, `documents.ai_graph`, `bundles.graph_data`, `concept_index.description`) follows the same rule via updated generator prompts plus an inline sweep over the production database. ### Thread 2, cross-AI as the wedge MWBench is now the public proof page at `memory.wiki/mwbench`. v8 keeps the eval public and reproducible, and treats every product decision through the lens of "does this make the cross-AI claim stronger or muddy it?" - Documentation everywhere links back to `/mwbench` so a curious developer can audit the claim in two clicks. - Hub viewer no longer displays per-hub readiness. The claim is system-level, not per-hub. - Marketing copy leads with "open cross-AI eval" or "cross-AI verification" instead of the internal codename MWBench, since the name has no recognition outside this work. ### Thread 3, capture and claim ergonomics The "magic moments minus user burden" thesis. Every interaction the user has should be the shortest path from intent to result. - **CLI auto-claim** ships in `memory-wiki-cli@1.4.2`. `mw login` automatically claims every anonymous doc the CLI created before login by walking the local `tokens.json`. The previous gap (`mw publish` before `mw login` left the doc orphaned to a CLI-specific `anonymous_id` that the browser migrate flow could not see) is closed. - **MCP env vars** moved to `MEMORY_WIKI_BASE_URL` (canonical) with `MDFY_BASE_URL` as deprecated alias. No behaviour change for existing shells. Same pattern for `MEMORY_WIKI_URL` in the CLI. - **Hub onboarding**: a future iteration auto-builds the ontology once a hub crosses N docs, so the compact mode digest is rich by default without the user needing to click "Build ontology". ### What v8 is NOT trying to do - Become an LLM provider, a chat UI, or a vector DB SaaS. Memory.Wiki publishes; it does not host inference or own the storage layer. - Build a vendor-locked integration. Every URL is meant to be readable by any AI; that contract trumps any one-vendor optimisation. - Compete with mem0, Letta, or OpenAI Memory on agent-side memory recall benchmarks. Those are backend stores for agents to recall from. Memory.Wiki is the URL delivery layer. Different problem, different lane. ### v8 ship list (priority order) 1. New brand lockup applied across web app surfaces (about, mwbench, editor, viewer, 404) 2. Static lockup PNG renders for favicon, OG image, app store icons, Apple touch icon 3. Public landing flip (the current root `/` is the editor; v8 keeps the editor but adds a marketing surface for signed-out visitors) 4. First-paste magic flow (visitor pastes a sample hub URL into Claude / ChatGPT in a guided way and sees the wedge work, before signup) 5. Auto-ontology on N-th doc save, so new hubs have a rich compact digest by default 6. External publish (Show HN, Twitter thread, LinkedIn) using the drafts at `memory.wiki/FX0zO5zK` --- ## 4. Homepage content, draft Once v8 lands, the public landing surface (currently `/` is the editor for signed-in users, blank-state editor for signed-out) needs a marketing slice for first-time visitors. This is the copy. ### Above the fold **Headline** ``` Stop re-explaining your context to every AI. ``` **Subhead** ``` Memory.Wiki publishes every doc, every bundle, and your whole hub as a single URL. Paste the URL into Claude, ChatGPT, or Gemini and the AI fetches your knowledge as context. One URL, every AI, verified. ``` **Tertiary line** ``` Capture anything. AI organizes. Use everywhere. ``` **Primary CTA** ``` Start your hub ``` **Secondary CTA** ``` See the cross-AI verification ``` (links to `/mwbench`) **Verification pill** ``` Cross-AI verified, 100% on unseen content, grounded by quote ``` (links to `/mwbench`) ### Second fold, the three primitives Three cards, equal weight: ``` Document memory.wiki/ One captured answer, paper, or transcript. One permanent URL. Bundle memory.wiki/b/ A curated grouping of docs around a topic. One URL pulls the whole collection into any AI. Hub memory.wiki/hub/ Your entire knowledge layer as a single URL. Paste it once, every AI reads it. ``` ### Third fold, capture from any AI ``` Capture from where you already are. ChatGPT, Claude, Gemini chat One-click Chrome extension or share-URL paste. Claude Code, Cursor, Codex CLI, Aider Install /memory.wiki once. Run save this to memory.wiki as "title" from inside any tool. PDF, DOCX, PPTX, XLSX Drop the file. Get clean markdown back, structured by AI. ``` ### Fourth fold, the proof ``` Cross-AI delivery, verified open. A single URL paste reaches: paste full 100% accuracy across Claude / OpenAI / Gemini paste compact 100% (5 to 9 times cheaper) browse 98% to 100% (AI fetches the URL itself) tool-use rate 100% (AIs reliably fetch URLs) Including on content the AIs have never seen during training. See the open methodology and reproducible harness. ``` CTA: `View MWBench results` (links to `/mwbench`) ### Fifth fold, why this is different Three-column comparison (Memory.Wiki vs vendor memory vs agent memory stores): ``` Vendor memory Agent memory stores Memory.Wiki (ChatGPT memory, (mem0, Letta, Claude projects) OpenAI Memory) First user AI (auto-extract) AI agent Human Interface Inside one tool SDK / MCP server Public URL Visibility Black box Black box Human-readable markdown Cross-vendor No No Yes, any AI fetches the URL Sharing No Personal / team Public URL, anyone reads Ownership Vendor Backend service You ``` ### Sixth fold, capture surfaces and ecosystem Logos and brief blurb for each: ``` Web editor Paste, drop, capture. URL in three seconds. Chrome extension One click on ChatGPT, Claude, Gemini. VS Code extension WYSIWYG preview, cloud sync. Memory.Wiki for Mac Native sidebar, folders, offline. CLI Publish from the terminal, pipe-friendly. MCP server 28 tools for Claude, Cursor, Windsurf, Codex. QuickLook plugin Preview .md files in Finder. ``` ### Footer fold, trust + start ``` Free during beta. No signup needed to try. Paste any markdown and you have a Document URL in three seconds. [Start your hub] [See the proof] ``` Foot links: ``` About / Docs / MWBench / Manifesto / GitHub ``` --- ## 5. Strategic history, how we got to v8 The current shape was not the first shape. Each prior version made one bet that was either kept, sharpened, or dropped. The full chain matters for v8 because it explains which decisions are load-bearing and which were experiments. ### v3 (early 2026), Rust engine + dotfile product The first thesis was "Markdown engine as a product." Rust-based comrak fork (`mdcore`) shipped to WASM, dotfile branding (`.mdcore`, `.mdfy`), domain `mdfy.app`. Won speed and rendering quality. Lost a coherent product story, because users do not care which engine renders their markdown. Outcome: engine and rendering speed are still our floor. The Rust-as-product framing was retired in the Rust-to-WASM sunset on 2026-05-16 when every surface moved to `markdown-it`. Single renderer, every viewer, no DOM drift. ### v4, AI publishing layer Reframed from "engine" to "the fastest way from thought to shared document." Added editor, share URLs, Chrome extension capture, VS Code extension, Mac desktop, CLI, MCP. Cross-AI badge moat ("Published with mdfy.app"). Outcome: the publishing surfaces (web, Chrome, VS Code, Mac, CLI, MCP, QuickLook) are now production. The viral-badge moat thesis survives but is now treated as one of multiple wedges rather than the primary one. ### v5, three-tier URL architecture Doc / Bundle / Hub introduced as the load-bearing primitive. Permission model, AI sidebars, concept indexing. Bundle pivoted away from a static collection toward a thinking surface (decomposition + tensions). The 3D Three.js knowledge graph was scoped, scrapped, and replaced by 2D backlinks + concept graph. Outcome: the three-tier URL primitive is now the structural commitment that all v8 work assumes. ### v6 (FINAL doc at `memory.wiki/_4iafQ8K`), Personal Knowledge Hub for the AI era Reframed for the AI era. "URL is the unit of everything. Doc, Bundle, Hub." Set a single-ship plan for end of August 2026. Twelve-week landing plan W1 through W12 lived on the `v6` branch; all twelve weeks shipped to `staging` by 2026-05-05. Only the public flip from editor-at-root to two-door landing was held. Outcome: v6 is the architectural baseline that everything in production runs on today. ### v7 (FINAL at `memory.wiki/xv6A2DKS`, `qHc1FWxq`), rename to memory.wiki The founder acquired `memory.wiki` on 2026-05-20. v7 is the staged rollout: UI text → domain swap → channel package names. v7 also sharpened positioning from "publishing layer" to "LLM-maintained personal wiki, deployable as URLs to any AI" after studying Karpathy's LLM-wiki gist and Graphify (44k stars). The shift in one line: - v6: *URLs that any AI can read.* - v7: *An LLM-maintained personal wiki, deployable as URLs to any AI.* Three "exceed" moves landed in W4 to W6: diff/accept on auto-synthesis, PDF ingestion, proactive bundle suggestion. Shared / social bundles were planned for W7 and W11 to W12 as the single biggest exceed move. ### v7-revised (`memory.wiki/nvF3Li2x`), craftsman SaaS reframe v7-revised tightened scope. Drops a bundle of items the original v7 plan carried that were not load-bearing: 1. Bundle Spec RFC → moved to post-launch v8 work 2. Distribution → existing mdfy.app user graph mining over generic HN+PH+Twitter wave 3. Brand → two-phase (Phase 1 at start of v8 work, Phase 2 at launch) rather than one big rebrand 4. Scope cuts on voice memo, embedded chat, public social hub, team workspace, deep Custom GPT integration 5. Mobile native (iOS + Android) added as Tier 1 surface 6. Best-UX 8 criteria bar introduced ("ship 0 features finished beats 5 features half-finished") The framing of the founder goal is also explicit: *sustainable craftsman SaaS, 5-year ARR $2-5M, NPS 70+, 1k-10k paid users who really love the product.* Not a polymath / explosive-growth bet. ### v8 (`memory.wiki/SKaY7VJP`), this doc supersedes v8 is the active plan and the focus of every section after this one. v8 keeps everything in v7-revised, adds three sharper layers: - The three-stage flow (Capture → Organize → Use) becomes the explicit user-facing framework. - Dual-layer storage (immutable original + replaceable AI metadata) is an architectural commitment. - Dual-response per URL (HTML for humans, markdown digest for AIs, content-negotiated by header) becomes the cross-AI delivery contract. The internal vs external thesis split is also v8-explicit: - **Internal** (founder, manifesto, founder note): *The graph is the product. Cross-AI is structurally impossible for vendors. Knowledge as URL = API for any AI.* - **External** (every user surface): *Stop re-explaining your context to every AI.* --- ## 6. The v8 plan in full This is the full v8 plan from `memory.wiki/SKaY7VJP`, mirrored here so this doc remains self-sufficient. ### 6.1 Founder goal Sustainable craftsman SaaS. 5-year ARR target $2-5M. NPS 70+. 1k to 10k paid users who genuinely love the product. Explosive-growth aspiration is dropped on purpose. Replaced by: stability, freedom, and craft. ### 6.2 The H1 lineup **Primary** ``` Stop re-explaining your context to every AI. Put your knowledge in one URL they can all read. ``` **Sub-head** ``` Yours, your team's, or your community's, one URL every AI fetches. ``` **Tertiary (the three-stage diagram)** ``` Capture anything. AI organizes. Use everywhere. ``` ### 6.3 The strategic framework ``` CAPTURE -> ORGANIZE -> USE user + AI auto + cross-AI AI auto user edit consumption ^ | |_____ Indispensability ______ | ``` North-star metric: weekly recapture rate. Target at week 12 post-launch is 30 of every 100 active users capturing 20 or more times per week. ### 6.4 URL architecture, three levels ``` L1 memory.wiki/ Document (12-char nanoid) L2 memory.wiki/b/ Bundle (curated collection) L3 memory.wiki/@ User (identity, Mastodon / Bluesky pattern) ``` Dual-response per URL: same URL, different body based on User-Agent + Accept + sec-fetch-dest. | Consumer | URL | Response | | --- | --- | --- | | Browser | `memory.wiki/@raymind` | HTML (timeline + Galaxy tab + Bundles tab) | | AI (Claude, ChatGPT, Cursor) | same URL | Markdown digest, token-budgeted, 8-16KB | | Explicit `.md` suffix | `memory.wiki/@raymind.md` | text/markdown explicit | Backward compat: `/hub/` 301-redirects to `/@`. `profiles.hub_slug` stays as the internal DB column name. ### 6.5 Dual-layer storage ``` ORIGINAL (immutable) AI LAYER (replaceable) captured by the user as-is generated by AI markdown body tags, cluster_id source URL, timestamp summary, related_ids attribution agent_id, generated_at never overwritten regeneratable any time ``` UI: every entry has a view toggle, Original vs Organized. AI metadata is a separate element layered above the body, never replacing it. Lock toggle lets the user mark "AI cannot touch this entry." ### 6.6 Auto-organize policy Three types, increasing levels of user friction. **Type 1, metadata, no approval needed** | What | When | | --- | --- | | Tags (5-10 per doc) | At capture | | Cluster assignment | At capture | | One-to-two sentence summary | At capture | | Related docs | At capture + daily recompute | | Entity extraction (names, places) | At capture | **Type 2, bundles, dual namespace** ``` memory.wiki/@raymind | +-- My Bundles (user creates explicitly) +-- AI Bundles (AI creates automatically) ``` | AI action | My Bundles | AI Bundles | | --- | --- | --- | | Create new bundle | no | yes | | Add doc to existing | confirm | yes | | Rename / re-describe | no | yes | | Delete | no | yes (if cluster dissolves) | One-tap conversion: AI Bundle becomes My Bundle (locks AI out). Reversible. **Type 3, synthesis docs, AI creates a new doc** | What | Trigger | | --- | --- | | Bundle summary doc | User click | | Weekly digest at `/@user/digest/` | Auto, Sunday | | Cross-doc synthesis | User click | | About / Current Focus draft | At signup + monthly auto | Every AI-generated doc carries an `AI-generated` badge plus the agent identity. ### 6.7 Attribution model Every entry, bundle, and doc carries a generation history: ```json { "creator_type": "user" | "ai", "agent": "memory-wiki-background" | "claude-sonnet-4.6" | "gpt-4o" | "custom-gpt" | "cursor-mcp", "triggered_by": "user-capture" | "weekly-digest" | "user-on-demand" | "auto-cluster", "generated_at": "2026-05-23T10:00:00Z", "user_edits": 0 } ``` UI: - User-written: user avatar plus dot - AI-generated: AI badge plus agent name (Claude, GPT, background) - Edited-by-you (was AI): pen icon plus "originated from AI" footnote ### 6.8 Collaboration model, three tiers **Tier A, sharing primitives, v8 launch** | Item | Change | | --- | --- | | Doc visibility | public / private / restricted (kept) | | Bundle visibility | new: public / unlisted / private / restricted | | Bundle collaborators | new: multiple edit, max 5 | | Public `@username` profile | new: user picks what to expose | | Presence indicators | avatars + live cursor (Yjs) | | Comments | per-doc thread | **Tier B, AI collaboration, v8 launch** - Shared bundle's AI auto-organize works across all contributors' captures - `@user/bundle` URL paste pulls everyone's context together for the AI - Attribution surfaces "added by @raymind" cleanly **Tier C, team workspace, deferred to v9 or later** | Item | Why later | | --- | --- | | Multi-tenant workspace | big DB schema change | | Role-based access (Admin / Editor / Viewer) | UX complexity, B2B onboarding | | Per-seat billing | Stripe branching | | SSO / SAML | Enterprise scope | | Audit log | Compliance scope | Tier C waits until post-PMF, 6 to 12 months after v8 launch. ### 6.9 Mobile strategy Native iOS + native Android are Tier 1 surfaces. Both new builds, both launching with v8. | Capability | iOS | Android | | --- | --- | --- | | Share Extension (any app → memory.wiki) | yes | yes | | Camera capture with OCR | yes | yes | | Auto screenshot processing (Korean culture pattern) | yes | yes | | Spotlight / Search integration | yes | yes | | Widgets (home + lock screen) | yes | yes | | Background sync (offline-first) | yes | yes | | Push notification | yes | yes | | Main UI: timeline + quick capture | yes | yes | Excluded from v8 mobile scope: voice memo (Korean cultural fit weak), Action Extension, Live Activities, keyboard extensions. Deferred to v8.1 / v9. ### 6.10 Best-UX, eight criteria Every feature must pass eight bars before shipping: | Criterion | Baseline | | --- | --- | | Capture latency | under 1 second from tap to completion notice | | Open latency | under 500ms from URL to LCP | | Action requirement | every action is 1 tap or 1 keystroke | | Surprise factor | 0 (AI never silently changes user data) | | Cross-surface consistency | mobile, desktop, Chrome ext, Cursor share one mental model | | Beauty | Linear / Granola / Things polish level | | Animation feel | calm, responsive, 60fps | | Type and spacing | consistent grid and typography across every screen | Features that miss any one criterion do not ship. *Finished count beats shipped count.* ### 6.11 Nine surfaces, three tiers **Tier 1, heavy work** | Surface | Work | | --- | --- | | `apps/web` | Full rebuild (three-stage flow, dual namespace, /@user, dual response, attribution, collab, branding) | | `apps/ios-native` | New build (Share Ext, camera, Widget, Spotlight, sync) | | `apps/android-native` | New build (same scope) | **Tier 2, medium** | Surface | Work | | --- | --- | | `apps/chrome-extension` | Per-AI capture optimization + Inject button + AI Bundle awareness | | `packages/mcp` | Organize ops + digest endpoints + attribution metadata | **Tier 3, light** | Surface | Work | | --- | --- | | `apps/vscode-extension` | Branding + new API + Copy-as-context command | | `apps/desktop` | Branding + new schema compat | | `apps/cli` | Command audit + branding | | `apps/quicklook` | Branding only | All nine surfaces release on v8 launch day. Sync release is a hard principle. ### 6.12 Timeline, 20 weeks ``` W1-2 Brand Phase 1 + schema migration + foundation W3 Attribution + AI bundle separation + bundle visibility schema W4-6 Web: auto-organize (real-time + background + synthesis) W7 Web: dual response (HTML + markdown) + public profile W8 Web: use surface (paste-anywhere) + comments W9-12 iOS native (Swift) — Share Ext + camera + Widget + sync W11-13 Android native (Kotlin) — parallel W13-15 Channel updates: Chrome / VSCode / Desktop / CLI / MCP / QuickLook W14 Bundle collaborators + presence (live edit polish) W16 UI polish + a11y + perf audit W17 Brand Phase 2 + landing + onboarding visuals + demo video W18 Pricing + Stripe + docs update across surfaces W19 Launch dry-run + bug bash W20 Launch wave (9 channels, simultaneous release) ``` 30 to 50 hours per week, solo founder + AI pair, full-time. Five months to launch. ### 6.13 Pricing | Tier | Price | Includes | | --- | --- | --- | | Free | $0 | 3 docs/month, public only, 1 bundle | | Pro | $15/mo | Unlimited docs, private docs, custom domain, AI auto-organize, native apps, MCP, Custom GPT | | Team | (v9+) | Per-seat, shared workspaces, role-based access | Beta users (existing mdfy graph): 50% lifetime discount code on launch day. ### 6.14 ICP **Tier 1 (80% at launch)**: AI-fluent indie hacker / solo dev / dev-rel - Uses ChatGPT + Claude + Cursor daily - Reachable on HN, Twitter, Reddit r/cursor, etc. - Founder is in this segment (dogfooded) **Tier 2 (15%)**: tech writer / researcher - Already publishes regularly - Citable URL has direct value **Tier 3 (5%)**: power knowledge worker (lawyer, consultant) - Real pain, but enterprise sales motion required, deferred **Excluded**: casual ChatGPT user, does not feel the re-explaining pain ### 6.15 GTM, wave model **Pre-launch, weeks 17 to 19** Mine the existing mdfy graph: 1. Export active mdfy.app users 2. Segment: anonymous publisher / signed-in / Chrome ext / VS Code ext / Desktop 3. Send personalized email per segment 4. Hook: "Your AI memory URL is ready" (not "upgrade to Pro") 5. Include 50% lifetime discount code Target: 50 to 100 pre-launch commits. **Launch day, week 20** Sequential wave: - Tuesday morning: existing users email - Tuesday noon: HN Show HN ("Memory.Wiki — stop re-explaining yourself to every AI") - Wednesday: Twitter thread + dev community - Thursday: ProductHunt - Friday: Manifesto post KPI target, 12 weeks post-launch: - Signups: 5,000 - Free active: 500 - Paid: 80-150 ($1.2k to $2.3k MRR) - NPS > 60 - Weekly Recapture Rate: 30% of active at 20+ captures/week **Deep partnership, week 24+** One deep integration target: **Cursor**. Direct cold-email to Cursor team, Memory.Wiki integration for Cursor rules, joint blog + PR. One deep integration beats five generic ones. ### 6.16 What v8 explicitly will not do | Item | Why | | --- | --- | | Embedded chat | Direct competition with Claude/ChatGPT, conflicts with our thesis | | Voice memo / audio input | Korean cultural fit weak, expands scope | | Public hub / social feed | Wikipedia / social product motion, not pre-PMF | | Bundle Spec RFC / open standard | Community management overhead, post-launch only | | AI conversation auto-suggest UI | Breaks on every ChatGPT UI change, maintenance burden | | Cross-AI integration depth beyond Custom GPT | One Cursor partnership is enough at launch | | Team workspace + per-seat billing | v9+ Tier C | | Visual graph as the default view | Galaxy is a fun side feature, not the main | | Founder narrative of "solo 6 months" | "Cross-AI giants can't build" is the sharper hook | | "Memory layer" category competition | Reframe as "context portability + capture layer" | ### 6.17 Risk register **Risk 1, vendor entry (40%**)Mitigation: cross-AI thesis is the narrative core. Cursor partnership sharpens differentiation. **Risk 2, 20-week schedule slip (50%**)Mitigation: reality checks at W8, W12, W16. If 50% behind, cut features rather than push the date. Tier C is already deferred. **Risk 3, mobile native app store rejection (15%**)Mitigation: TestFlight + Play Store internal track 6 weeks before launch (W14). If rejected, time is reserved. **Risk 4, paid acquisition stalls at the first 100 (35%**)Mitigation: mdfy graph mining first. Segmented email campaign from W17. "Your AI memory URL is ready" hook. **Risk 5, AI cost spiral on auto-organize (25%**)Mitigation: free tier rate limits (3 docs/month, 1 bundle). Pro $15 has cost reflected. Three-provider failover (Anthropic / OpenAI / Gemini). Background organize batches and caches. **Risk 6, solo founder burnout (40%**)Mitigation: reality checks at W6, W10, W14, W18 + a one-day-off rule. 50 hours/week cap. Trust the AI-pair efficiency. **Risk 7, Best-UX bar delays launch (30%**)Mitigation: ship-not-ship decisions called early. W16 audit: any feature that fails moves to v8.1. Only pass-features launch. ### 6.18 Internal vs external thesis **Internal** (founder, manifesto, founder note only): - The graph is the product - Cross-AI is structurally impossible for giants - AI-native memory infrastructure - Knowledge-as-URL = API for any AI **External** (every user surface): - "Stop re-explaining your context to every AI." - "Capture anything. AI organizes. Use everywhere." - "Yours, your team's, or your community's, one URL every AI reads." Internal language (graph, layer, infrastructure, memory) lives in manifesto / about / founder note ONLY. Never on a product surface. ### 6.19 Locked decisions (23) | \# | Decision | Value | | --- | --- | --- | | 1 | Framework | Capture, Organize, Use | | 2 | URL doc | `memory.wiki/` (kept) | | 3 | URL bundle | `memory.wiki/b/` (kept) | | 4 | URL user | `memory.wiki/@` (new, Mastodon / Bluesky pattern) | | 5 | Bundle namespace | My + AI split | | 6 | Dual-layer | original immutable + AI metadata | | 7 | Dual-response | same URL, content negotiation | | 8 | Attribution | per-entry, AI agent identity included | | 9 | Mobile | iOS + Android native, Tier 1 | | 10 | Voice memo | dropped | | 11 | Galaxy | visible tab, not default | | 12 | Embedded chat | dropped | | 13 | Best UX | 8 criteria | | 14 | Pricing | $15/mo Pro, free 3 docs/month | | 15 | H1 | "Stop re-explaining your context to every AI." | | 16 | Branding | Phase 1 (start) + Phase 2 (end) | | 17 | Timeline | 20 weeks | | 18 | 9 surfaces | sync release on launch day | | 19 | Surface tiers | T1 web/iOS/Android, T2 Chrome/MCP, T3 VSCode/Desktop/CLI/QuickLook | | 20 | Parallel work | T1 main 80%, T2/T3 later phases | | 21 | Auto-organize | metadata auto + bundle (My approval / AI auto) + synthesis (user-trigger or weekly) | | 22 | Docs update | per-surface, week 18 | | 23 | Collaboration | Tier A+B (sharing + presence + comments) v8, Tier C v9+ | ### 6.20 Mantras > **One URL. Every AI.** > ****Capture is the friend. Organize is the AI. Use is your right.** > ****What a human wrote is sacred. What an AI made is attributed.** > ****Cross-AI is the wedge giants can't build. Don't say it to users.** > ****One feature finished beats five features half-finished.** --- ## 7. MWBench, the evidence stack in full MWBench is the public verification of the cross-AI thesis. Public landing at `memory.wiki/mwbench`. Reproducible harness at `github.com/raymindai/memory-wiki/tree/main/eval`. ### 7.1 The two-axis design Every cell in MWBench is one (mode, content) pair. ``` Familiar (raymindai) Unseen (mwbench-zorblax) Paste full corpus cell 1 cell 2 Paste compact cell 3 cell 4 Browse cell 5 cell 6 ``` - **Familiar** is `memory.wiki/hub/raymindai`, the founder's real public hub. AIs may have seen partial content during training. - **Unseen** is `memory.wiki/hub/mwbench-zorblax`, a synthetic hub of fictional ZorblaxCorp facts. Every fact is invented. AIs cannot have seen it. - **Paste full** is "corpus dumped into the prompt." Full body. Most expensive. - **Paste compact** is "concept clusters + all-doc catalog + per-doc gist + H2 skeleton." 5 to 9 times cheaper. - **Browse** is "AI is given the URL only, must fetch it using its own browse tool." Requires the URL delivery contract to work end-to-end. The Unseen × Compact × Browse corner is the hard cell. If we hit 100% there, the cross-AI URL delivery contract is structurally sound. ### 7.2 The judge Quote-evidence judge. One LLM call. For each claim in the answer, the judge: 1. Decomposes the answer into atomic claims 2. Requires a literal corpus quote per claim 3. Returns per-claim verdict: `supported`, `paraphrase_supported`, `not_found`, or `contradicts` 4. Falls back to chunked retrieval when corpus > 800k chars Adversarial mode also handles empty-answer as implicit refusal (counted as adversarial-correct), placed before the empty-answer early return. ### 7.3 Round-by-round (highlights) | Round | Date | What we measured | Headline | Bug closed in round | | --- | --- | --- | --- | --- | | 1 | 2026-05-19 | First production, raymindai hub, paste mode | 95.0% accuracy, 93.3% consistency | Gemini 2.5 Pro maxOutputTokens too low for thinking budget | | 2 | 2026-05-20 | Bundle queries | High paste, 41% browse | Tool-use turns capped too low (4) | | 3 | 2026-05-21 | Doc queries | 100% paste, 80% browse | None | | 4 | 2026-05-22 | Hub queries | 100% paste, 90% browse | Bullet-loss in extractSkeleton | | 5 | 2026-05-22 | Bundle/doc consistency check | 100% paste both | None | | 6 | 2026-05-22 | Pre-deploy browse | 41 to 80% browse | Browse-runner last-turn salvage | | 6.5 | 2026-05-23 | Post-deploy hub | 98.3% browse | None | | 7 | 2026-05-23 | Doc with ai_graph live | 90% browse | Concept gist coverage | | 8 | 2026-05-24 | Zorblax synthetic unseen-hub baseline | Discovered extractFacts m-flag bug, 47% to 80% compact | extractFacts regex anchoring | | 9 | 2026-05-24 | Final all-cells | 100% across all cells | All compact gist surfaces unified | ### 7.4 The four product bugs MWBench found These are kept because they shaped the surface, not just the bench: 1. **extractFacts m-flag** — the regex `(?=\n##\s|\n#\s|$)/im` made `$` match per line. Only the first bullet of any Facts section was captured. Fixed with header-anchored split, no m-flag. Compact accuracy on zorblax went 47% to 80%. 2. **extractSkeleton single-line per H2** — kept the first line of each H2 section, dropped subsequent bullets. Made bullet-aware. Compact went 80% to 100%. 3. **Hub route stale copy** — hub raw route had a local clone of gist helpers, so the lib fix did not propagate. Refactored to import from `@/lib/doc-gist`. 4. **Browse-runner last-turn salvage** — OpenAI and Gemini kept calling tools past MAX_TOOL_TURNS=4 and never finalized. Bumped to 6 and made the last turn drop tools to force a final text answer. OpenAI tool_choice "none" requires tools present, so we always include tools, just flip the choice on the last turn. ### 7.5 What MWBench is NOT - Not a memory-store benchmark. Has no opinion on agent-side recall. mem0 and Letta solve that. - Not a hallucination benchmark in the LLM sense. Measures whether the URL delivery contract produces grounded answers, not whether the model generally hallucinates. - Not a vendor leaderboard. Not ranking Claude vs OpenAI vs Gemini. Confirming the URL works on all three. --- ## 8. Brand evolution ### 8.1 Identity history - **v3-v6 wordmark**: `mdfy.app`, lowercase, sans, neutral. Dotfile aesthetic. - **v7 transition**: domain acquired 2026-05-20. Wordmark moved to `memory.wiki` with two-tone color split: "memory" in orange, ".wiki" in primary ink. v7 rebrand polish killed verb-form awkwardness ("memory.wiki it" / "memory.wiki-ed it" felt wrong; switched to "publish to Memory.Wiki" everywhere). - **v8 ongoing**: animated blob logomark + lockup. Symbol is always animated, always paired with the wordmark, never standalone. ### 8.2 Animated blob Files: - `apps/web/public/brand/mwblob_morph.svg` (light theme variant) - `apps/web/public/brand/mwblob_morph_dark.svg` (dark theme variant) - Source at `assets/brand/blob/` including 11 keyframe SVGs and the After Effects project file Rule: - The blob is **always animated** on any web/native surface. SVG `` keyframes run continuously. - The blob is **always paired with the wordmark** on the right. The blob is not a standalone identity. - Static single-frame PNG renders are used only where the medium forbids animation: favicon, OG image, app store icons, Apple touch icon, vendor manifests. ### 8.3 Lockup composition ``` [ blob ] memory .wiki ``` - Blob on the left, animated - "memory" in accent (orange), regular weight, top line - ".wiki" in primary ink (white on dark, near-black on light), regular weight, bottom line - Both lines stacked, aligned to the same x-axis as the blob's right edge ### 8.4 Type system - Body: **Noto Sans** (Latin + CJK) - Code, small labels, mono badges: **JetBrains Mono** - Hero serif (v8-preview gallery only, not in production yet): **Instrument Serif** or **Fraunces** under evaluation ### 8.5 Iconography - **Lucide** icons across every surface, consistent stroke weight (1.5px), no mixed icon libraries - No emoji on UI surfaces. No emoji in LLM-generated content (covered by glyph rule) ### 8.6 Color balance (v8 Frontier Pure) The Roadmap section of `/about` is the validated balance for v8 Frontier Pure design language: - All body type, headings, list rows, descriptions stay ink (white on dark, near-black on light) - One small mono badge per card (e.g. `Phase 1 + 2`), colored only by category: lime / orange / violet - Bullet dots: micro-lime accent - Pillar tags ("/ LIVE", "/ COMING SOON", "/ VISION"): ink mono caps, not colored - Card backgrounds, borders, separators: neutral hair on bg-deep - Zero gradients, zero glows, zero backdrop blur, zero accent borders on chips When adding any colored element on a v8 Pure surface, ask: would this hit the Roadmap balance? Colored elements should be one of: a small mono phase/category badge, a bullet dot, a status dot, an icon-only mark. Body copy, headings, chip text, and button text stay ink. ### 8.7 Glyph hygiene No middle-dot (`·`), em-dash (`—`), arrow (`→`, `←`, `↑`, `↓`), check mark (`✓`, `✔`), or emoji on any UI surface or in any LLM-generated content. Comma, slash, parentheses, sentence break only. Enforced two ways: 1. Generator prompts (Haiku for doc ai_graph, concept index; Sonnet for bundle graph_data) carry the no-glyph instruction 2. `eval/sweep-all-glyph-clean.mjs` runs a one-shot scrub across the production DB: ```js function stripGlyphs(s) { return s.replace(/[—―]/g, ", ").replace(/–/g, "-").replace(/·/g, ", ") .replace(/[→➤➜]/g, "to").replace(/[←]/g, "from") .replace(/[↑↓]/g, "").replace(/[✓✔✖✘]/g, "") .replace(/[★☆✩✭✯✰]/g, "").replace(/…/g, "...") .replace(/\s+/g, " ").trim(); } ``` ### 8.8 v8-preview gallery While the new lockup is rolling out, `/v8-preview` carries 13 design variants for internal evaluation: ``` A Warm Serif I Clay B Light Paper I.2 Clay Mono C Dark Edge I.3 Clay Stack D Liquid Glass J Modern E Editorial K Frontier F Lovable G Wise H Miro ``` Frontier (K) is the front-runner. It informs the production `/about` surface (`AboutPure.tsx`) and the components in `apps/web/src/components/pure/`. --- ## 9. The product surfaces, file by file This section is the engineering map of what code actually runs and where. ### 9.1 Web app (`apps/web/`, Next.js 15, App Router, Vercel) Routes: - `/` editor (the main product surface, what signed-in users land on) - `/d/[id]` doc viewer (TipTap canEdit=false) - `/b/[id]` bundle viewer - `/hub/[slug]` hub viewer - `/embed/[id]` iframe embed - `/raw/`, `/raw/b/`, `/raw/hub/` raw markdown for AI / bot consumption - `/auth/{cli,desktop,mcp,vscode}` device auth flows - `/mwbench` public landing for the cross-AI eval - `/about` v8 Frontier Pure marketing surface (`AboutPure.tsx`) - `/v8-preview` private variant gallery (13 variants, `robots: noindex`) - `/api/docs`, `/api/import/github`, `/api/og`, `/api/user/claim-by-edit-token`, etc. Rendering pipeline (every non-edit surface): ``` Markdown -> render() in apps/web/src/lib/render.ts 1. markdown-it.render(body) 2. styleAsciiDiagrams() 3. highlightCode() 4. processKatex() 5. processImages() -> dangerouslySetInnerHTML Mermaid hydrates in useEffect. ``` TipTap Live tab uses the same markdown-it config (`thead`/`tbody` no-op + footnote plugin) so the editor and viewer DOM never diverge. ### 9.2 VS Code extension (`apps/vscode-extension/`, Marketplace, v1.4.1) Sidebar with WYSIWYG preview, cloud sync, AI tools, "Copy as context" command (in progress for v8). ### 9.3 Mac desktop app (`apps/desktop/`, v2.3.5, DMG, Developer ID signed + notarized) Sidebar + folders + offline. v2.3.5 killed QuickLook "Open" auto-launching the app and gave `.md` a Memory.Wiki icon. URL scheme moved to `memorywiki://` (was `mdfy://`). ### 9.4 Chrome extension (`apps/chrome-extension/`, Web Store, v2.2.2) Per-AI capture from ChatGPT, Claude, Gemini chat pages. v8 work: Inject button (preview the URL inline before send), AI Bundle awareness. ### 9.5 CLI (`apps/cli/`, npm `memory-wiki-cli`, v1.4.2) Commands: `mw publish`, `mw capture`, `mw login`, `mw claim`. Auto-claim runs on `mw login`: walks the local `tokens.json`, POSTs each edit_token to `/api/user/claim-by-edit-token`. Closes the orphan-CLI-doc gap. Env vars: `MEMORY_WIKI_URL` (canonical), `MDFY_URL` (deprecated alias). ### 9.6 MCP server (`packages/mcp/`, npm `memory-wiki-mcp`, v1.5.1) 28 tools for Claude Code, Cursor, Windsurf, Codex CLI: `mdfy_create`, `mdfy_read`, `mdfy_update`, `mdfy_search`, `mdfy_publish`, `mdfy_set_allowed_emails`, `mdfy_folder_create`, etc. Env vars: `MEMORY_WIKI_BASE_URL` (canonical), `MDFY_BASE_URL` (deprecated alias). `MwConfig` (was `MdfyConfig`). `CONFIG_DIR` (was `MDFY_DIR`). ### 9.7 QuickLook plugin (`apps/quicklook/`, bundled with Mac DMG) Preview `.md` files in Finder with full markdown rendering. Sandboxed entitlement preserved for PluginKit acceptance. --- ## 10. Public docs that need to stay in sync When v8 ships, these public memory.wiki documents must reflect the new framing. Today's links: - This doc: `memory.wiki/P67ESz3Q` - v8 Plan (founder canonical): `memory.wiki/SKaY7VJP` - v7 revised: `memory.wiki/nvF3Li2x` (superseded, kept for archival) - v7 FINAL: `memory.wiki/xv6A2DKS` and `memory.wiki/qHc1FWxq` (superseded) - v6 FINAL: `memory.wiki/_4iafQ8K` (superseded, kept for architectural lineage) - Strategic pivot history: `memory.wiki/4N8X52tq` - MWBench public landing copy source: also `/mwbench` route in the web app - Launch drafts (Show HN, Twitter, LinkedIn): `memory.wiki/FX0zO5zK` - Manifesto: `/manifesto` route in the web app - Karpathy LLM Wiki + Graphify strategic write-up: published from `mdfy.app/fEdn_hVU` (legacy URL still in memory) The hierarchy: this doc (P67ESz3Q) carries the audit and the v8 short-form plan. SKaY7VJP carries the full canonical v8 plan. The manifesto carries the internal thesis ("the graph is the product", "cross-AI is structurally impossible for giants"). The /mwbench page carries the evidence. The about page carries the external thesis ("stop re-explaining your context"). No public surface uses internal-thesis language. --- ## Facts - Memory.Wiki publishes Document, Bundle, and Hub primitives as URLs every AI can fetch - Cross-AI wedge verified at 100% on truly unseen content across Claude, OpenAI, Gemini - MWBench is the open methodology, public at `/mwbench`, reproducible from the repo - Legacy mdfy brand removed from user-facing surfaces; deprecated env var aliases kept - New animated blob logomark always paired with "memory.wiki" wordmark, never standalone - No middle-dot, em-dash, arrow, check mark, or emoji on UI surfaces or LLM-generated content - CLI 1.4.2 ships auto-claim of anonymous docs after login - MCP 1.5.1 ships MEMORY_WIKI_BASE_URL canonical env var - v8 ship list ordered: brand lockup, static exports, landing flip, first-paste magic, auto-ontology, external publish - Homepage copy structured into seven folds: headline, primitives, capture, proof, comparison, ecosystem, footer - v8 framework is Capture, Organize, Use, with a north-star metric of Weekly Recapture Rate - v8 URL architecture adds `memory.wiki/@` as the user-identity scope alongside Doc and Bundle - v8 commits to dual-layer storage (immutable original + replaceable AI metadata) and dual-response per URL (HTML for humans, markdown digest for AIs) - v8 timeline is 20 weeks across 9 surfaces, synced launch wave - v8 collaboration model is Tier A (sharing) + Tier B (AI collab on shared bundles) at launch, Tier C (team workspace) deferred to v9 - v8 mobile is iOS + Android native, Tier 1 scope - Best-UX bar has 8 criteria; features that fail any one are deferred - Pricing is Free (3 docs/month), Pro $15/mo, Team in v9 - Founder goal is sustainable craftsman SaaS at 5-year ARR $2-5M, NPS 70+, 1k-10k paid users - Internal thesis (graph is the product, cross-AI giants can't build) never appears on user surfaces; external thesis "stop re-explaining your context" is the only line users see --- ## Summary Memory.Wiki is a URL delivery layer for knowledge that lets users publish markdown documents, bundles, and personal hubs to permanent URLs that any AI can fetch as context across Claude, ChatGPT, and Gemini. Version 8 will rebrand from mdfy to memory.wiki, apply a new visual identity, expand cross-AI verification through the public MWBench benchmark, and streamline capture workflows to eliminate user friction. ## Themes - cross-AI URL delivery - brand consolidation and visual identity - product surface ergonomics ## Key takeaways - Memory.Wiki is a URL delivery layer where any AI can fetch markdown documents, bundles, or entire hubs via plain HTTP with no SDK or plugin required. - The three nested URL primitives are Document (memory.wiki/), Bundle (memory.wiki/b/), and Hub (memory.wiki/hub/), each with its own permanent URL and retrievable as clean markdown. - MWBench proves the cross-AI claim with 100 percent accuracy on unseen content across paste and browse modes, with tool-use rates of 100 percent, using a public reproducible harness. - v8 ships a new visual identity (animated blob logomark, Noto Sans body, Lucide icons) and removes the legacy mdfy brand entirely from user-facing surfaces. - The product explicitly does not compete with agent memory stores (mem0, Letta, OpenAI Memory), vector DB SaaS, or LLM providers, staying in the URL delivery lane. - CLI auto-claim closes the gap where anonymous documents created before login were orphaned, and MCP env vars standardize on MEMORY_WIKI_BASE_URL with MDFY_BASE_URL as deprecated alias. ## Insights - The core claim (one URL works across Claude, ChatGPT, Gemini) is verified by a reproducible public benchmark rather than marketing assertion, making the moat auditable rather than claimed. - Each major version pivoted on a single architectural bet (engine speed, publishing surfaces, three-tier URLs, AI-era positioning), and v8 treats only the three-tier URL primitive and cross-AI verification as load-bearing, deprecating the en - The removal of special glyphs from UI and LLM-generated content is a deliberate constraint on token efficiency and cross-AI compatibility, not a style choice. ## Open questions / gaps - What specific N threshold triggers auto-ontology generation once a hub reaches it, and how does the system determine whether a hub needs a richer digest by default? - The document references a Rust engine sunset on 2026-05-16 when all surfaces moved to markdown-it, but does not explain what performance tradeoffs resulted from that switch or whether rendering speed remains competitive. - Section 5 cuts off mid-sentence ('v6 is the architectural baseline that everything in production ru'), leaving the full outcome of the v6 cycle unclear. ## Concepts in this document - **memory.wiki** _(entity)_ The core product platform managing knowledge capture and AI-assisted workflows. - **Knowledge Management** _(tag)_ Overarching domain of personal and organizational information systems - **Chrome Extension** _(entity)_ Browser capture tool for one-click knowledge saving - **MCP Server** _(entity)_ Model Context Protocol server enabling AI tools to interact with Memory.Wiki - **Claude** _(entity)_ Anthropic's AI assistant, key target for cross-AI compatibility - **ChatGPT** _(entity)_ OpenAI's AI assistant, primary competitor and integration target - **Bundle** _(concept)_ Curated groups of memories that enable sharing and AI deployment; unit of collaborative knowledge. - **Capture-Organize-Use Framework** _(concept)_ Strategic framework for knowledge workflow with AI-powered organization - **Cursor** _(entity)_ Development AI tool that reads memory.wiki URLs as markdown for code context. - **AI-Optimized Context Packaging** _(concept)_ Revolutionary approach to formatting information specifically for LLM consumption rather than human reading. - **Intent-adaptive bundles** _(concept)_ Technical feature concept allowing dynamic context packaging for different use cases (coding, fundraising, research) via URL parameters. - **Dual-layer storage** _(concept)_ Architecture separating immutable user-captured original content from replaceable AI-generated metadata (tags, summaries, clusters), allowing transparency and re-generation. ## Concept relations (within this doc's concepts) - **Intent-adaptive bundles** is implementation of **AI-Optimized Context Packaging** - **memory.wiki** targets platform **Claude** - **memory.wiki** targets platform **ChatGPT** - **memory.wiki** targets platform **Cursor** - **memory.wiki** exposes through **MCP Server** - **memory.wiki** deploys docs as **Bundle** - **Chrome Extension** captures to **memory.wiki** - **memory.wiki** core strategy **AI-Optimized Context Packaging** - **AI-Optimized Context Packaging** key implementation **Intent-adaptive bundles** - **memory.wiki** must implement **AI-Optimized Context Packaging** - **Intent-adaptive bundles** enables specialized **AI-Optimized Context Packaging** - **AI-Optimized Context Packaging** enabled by **Intent-adaptive bundles** - **memory.wiki** implements **AI-Optimized Context Packaging** - **Cursor** saves decisions to **memory.wiki** - **Claude** loads context from **memory.wiki** - **memory.wiki** implements **Capture-Organize-Use Framework** - **memory.wiki** implements core strategy **AI-Optimized Context Packaging** - **AI-Optimized Context Packaging** enables through **Intent-adaptive bundles** - **Capture-Organize-Use Framework** requires **Dual-layer storage** - **AI-Optimized Context Packaging** enables via **Intent-adaptive bundles** _Hub canonical:_ https://memory.wiki/hub/raymindai _Concept digest:_ https://memory.wiki/raw/hub/raymindai?digest=1&compact=1