Desarrolladores
Construye sobre una memoria
que no es tuya.
La de tu usuario. Vive en su máquina, está cifrada, y él la gobierna — incluso contra ti. Esa es la restricción, y es lo que hace posible todo lo demás.
Tu propio código
Apúntala a tu proyecto. Toma su memoria.
Declara la carpeta de tu repo: Mnemosyne vectoriza tu código — los archivos, los docs, tus conversaciones de trabajo — y no se queda en la búsqueda. Su consolidación lo convierte en una memoria sintetizada del proyecto: su arquitectura, las decisiones que tomaste, y por qué.
No es un motor de búsqueda que te devuelve una línea. Preguntas «¿por qué elegimos esto?» y obtienes la síntesis — a través de meses de trabajo, sin la palabra clave exacta. Todo en local: tu código nunca sale de tu máquina.
La regla
Tres superficies. No son intercambiables.
Transportes distintos, manifiestos distintos, bibliotecas distintas. La regla de enrutamiento cabe en dos líneas, y es lo primero que hay que leer:
¿Dibujas píxeles dentro de Mnemosyne? → Cartucho.
¿Eres un proceso separado? → App Layer 2 — o MCP si quien llama es un agente de IA.
I
Cartucho
@mnemosyne_os/cartridge-sdk 0.1.0
Dibujas píxeles DENTRO de Mnemosyne.
Un iframe aislado que habla con el OS por postMessage. Es la única superficie distribuible en MnemoHub. Sin acceso a Node ni Electron: 86 acciones de host, 5 de ellas abiertas sin permiso.
El SDK de cartucho NO es @mnemosyne_os/sdk. Instalar el paquete equivocado es el error n.º 1.
II
App Layer 2
@mnemosyne_os/sdk 1.4.1
Tu app es un proceso separado.
WebSocket JSON-RPC en 127.0.0.1:7799, un JWT por app, una lista de orígenes permitidos. Declaras un manifiesto, el usuario concede los permisos en una ventana real del sistema, y consultas la memoria.
El OS debe estar en marcha. Las páginas web remotas se rechazan, por diseño.
III
MCP
@mnemosyne_os/mcp 1.2.0
Quien te llama es un agente de IA.
Claude Code, Claude Desktop, Cursor. Un cliente ligero en el mismo 7799, ocho herramientas: query, ask, ingest, vaults, resonancias, puentes oníricos, posición, git log. Cero líneas de código que escribir.
Misma restricción: la app Infinity debe estar abierta.
Empezar
El camino más corto, por superficie.
MCP — cero líneas de código
Infinity abierto, Node 18+, luego en el .mcp.json de tu proyecto:
{ "mcpServers": { "mnemosyne": {
"command": "npx",
"args": ["-y", "@mnemosyne_os/mcp"],
"env": { "MNEMO_DEFAULT_VAULT": "DEV" }
} } }App Layer 2
pnpm add @mnemosyne_os/sdkimport { MnemoClientBrowser } from '@mnemosyne_os/sdk';
const client = await MnemoClientBrowser.connect(); // 127.0.0.1:7799
await client.register(MANIFEST); // the user grants, or refuses
await client.ingest('Una nota para recordar', 'NOTE', 'DEV');
const chronicles = await client.query('mi búsqueda', 'DEV', 10);Cartucho
Copia apps/mnemo-cartridge-boilerplate/, reemplaza la dependencia
workspace:* por la versión de npm, y luego:
pnpm add @mnemosyne_os/cartridge-sdk
pnpm dev # vite, 127.0.0.1:5185
pnpm build # tsc && vite build -> dist/En la app: MnemoHub → Mis apps de desarrollo → vincula tu carpeta. El primer vínculo es gratis; el segundo exige una licencia Engramm activa — mejor que lo sepas aquí y no en mitad de tu integración.
El pacto
Tu app tiene exactamente un vault. Y no puede salir de él.
Un vault por app, derivado por el servidor, aislado de la búsqueda federada, invisible para el mapa neuronal y el estado de sueño. Tu app no puede ensanchar sus propios muros: abrir la permanencia es una operación que la red no alcanza — solo el usuario, en su gestor de vaults, puede hacerlo.
No es una política, es una asimetría de transporte. Puedes proponer. No puedes grabar. Si te parece severo: es exactamente lo que hace que tu usuario acepte instalar tu app.
Las tres trampas que cuestan una noche
Silencioso
vault:write es determinante, y su ausencia no dice nada. Sin
declararlo en tu manifiesto, ensureSandbox() se rechaza
sin error visible — simplemente nunca tienes vault. El boilerplate
no lo declara.
Irreversible
Renombrar tu app deja huérfano su vault. La propiedad se indexa sobre el
name del manifiesto: el siguiente ensure crea un
vault nuevo y abandona el anterior. No existe ninguna migración.
A tener en cuenta
El vault solo existe en el primer arranque, nunca en la
instalación. Y todos los cartuchos comparten un origen: no pongas ningún
secreto en localStorage.
Pronto · la economía del creador
Una economía donde el creador se queda con la mayor parte.
Cuando se abra la economía de la store, la regla será simple y pública: el desarrollador se queda con el 80 % de cada venta, el hub toma el 15 %, y el 5 % financia una DAO comunitaria que revierte al desarrollo del ecosistema. Sin parte oculta, sin condiciones que cambian.
80 % desarrollador · 15 % hub · 5 % DAO comunitaria
El resto — cómo funciona, cuándo abre — está en camino. Deja tu email y sé el primero en enterarte. Cero spam, solo el anuncio.
Open-core
El SDK es abierto. El core está sellado. Y tiene fecha.
Digámoslo en el orden correcto: los paquetes con los que construyes — SDK, MCP, SDK de cartucho — son MIT, publicados, legibles. El motor cognitivo, en cambio, es propietario y se entrega sellado. Las claves, el antipiratería y lo jurídico siguen siendo privados.
Lo que eso significa para ti, en concreto: nunca necesitas el core para escribir una app. El SDK es la frontera, y es estable.
Y la parte sellada no lo sigue siendo para siempre: su licencia pasa automáticamente a MIT el 1 de enero de 2030. Está escrito en el archivo de licencia, no en una entrada de blog.
«La licencia es una llave, no un candado.»
Editar el JSON a mano evita la cuota. Lo sabemos, se acepta, y es la postura open-core que asumimos: no luchamos contra ti.
El contrato
La memoria percibe, sitúa y revela.
El humano gobierna.
Para ti, desarrollador, se resume en una frase: tu app puede proponer, el usuario dispone. No borra nada en silencio, no mezcla nada sin un gesto humano, y no sale de su vault salvo que se la invite. Construye con eso, no contra eso.
¿Cómo construyes?
La oferta para desarrolladores
Reserva tu licencia gratuita, y programa tu primer cartucho.
¿Construyes sobre Mnemosyne OS? No queremos tu dinero, queremos tu opinión. Descarga el OS, pide tu licencia de fundador — gratuita, y te añadimos 5 $ en créditos cloud para probar de inmediato, sin siquiera conectar tu clave API.
1
Descarga el OS
Gratis, ahora mismo. Windows, macOS o Linux — el OS completo, en local.
2
Pide tu licencia gratuita
Airdrop manual — cuenta unos días. Desbloquea las funciones y cartuchos reservados, de por vida, y llega con 5 $ en créditos cloud para probar sin clave API.
3
Programa tu primer cartucho
Un comando, y ya consultas el vault bajo FGAC.
npm create @mnemosyne_os/app O en vibe-coding — pega este prompt a tu asistente:
Prompt Construye un cartucho Mnemosyne OS: [describe tu app]. Antes de programar, lee elllms.txten la raíz de github.com/yaka0007/Mnemosyne-Neural-OS, luego clona un cartucho de referencia MIT (MnemoReader) y lee susrc/. Usa@mnemosyne_os/sdkpara ingerir y consultar el vault bajo FGAC — sigue los patrones de la referencia, no adivines la API.