Desarrolladores
Construye sobre una memoria
que no es tuya.
Pertenece a tu usuario. Vive en su máquina, cifrada en cuanto él la arma. Él la gobierna, incluso contra ti.
Tu propio código
Apúntala a tu proyecto. Toma su memoria.
Declara la carpeta de tu repo. Mnemosyne OS vectoriza tu código, tus archivos, tus docs y tus conversaciones de trabajo. Luego su consolidación construye una memoria sintetizada del proyecto: la arquitectura, las decisiones que tomaste, y por qué.
Preguntas «¿por qué elegimos esto?» y obtienes la síntesis, a través de meses de trabajo, sin la palabra clave exacta. La memoria en sí se queda en local. Con un modelo local, tu código nunca sale de tu máquina. Con uno en la nube, solo salen los pasajes que responden.
La regla
Tres superficies. Cada una sirve para un trabajo distinto.
Cada una tiene su transporte, su manifiesto y su biblioteca. La regla de enrutamiento cabe en dos líneas. Léela primero:
¿Dibujas píxeles dentro de Mnemosyne OS? → 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.6.0
Dibujas píxeles DENTRO de Mnemosyne OS.
Un iframe aislado que habla con el OS por postMessage. Es la única superficie distribuible en MnemoHub. Sin acceso a Node ni Electron. 172 acciones de host, 9 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.5.7
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 2.1.3
Quien te llama es un agente de IA.
Claude Code, Claude Desktop, Cursor. Un cliente ligero en el mismo puerto 7799, con 25 herramientas. Cubren la memoria, el backlog y la agenda, el hilo del proyecto y la voz. También te dicen lo que hacen los otros agentes de código de la máquina. Cero líneas de código que escribir.
Misma restricción, con una excepción. Las tres herramientas de observación de agentes leen transcripciones que ya están en el disco, así que responden con la app cerrada.
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",
"MNEMO_VAULTS": "DEV,PERSONAL,SOCIAL",
"CLAUDE_CODE_SESSION_ID": "${CLAUDE_CODE_SESSION_ID}"
}
} } }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.
El pacto
Tu app tiene exactamente un vault. Y no puede salir de él.
El servidor deriva un vault por app. Ese vault está aislado de la búsqueda federada e 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 puede hacerlo, en su gestor de vaults.
El límite está en el transporte, no en una política. Puedes proponer. No puedes grabar. Eso es lo que hace que tu usuario acepte instalar tu app.
Las tres trampas que cuestan una noche
Silencioso
Declara vault:write en tu manifiesto. Sin él,
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 se crea en el primer arranque, nunca en la
instalación. Todos los cartuchos comparten un origen, así que 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 %. El 5 % restante financia una DAO comunitaria que revierte al desarrollo del ecosistema. Sin parte oculta, sin condiciones que cambian.
80 % desarrollador · 15 % hub · 5 % DAO comunitaria
Publicaremos cómo funciona y cuándo abre. Deja tu email para enterarte el primero. Cero spam, solo el anuncio.
Open-core
El SDK es abierto. El core está sellado. Y tiene fecha.
Los paquetes con los que construyes, el SDK, el servidor MCP y el SDK de cartucho, son MIT, publicados y legibles. El motor cognitivo, en cambio, es propietario y se entrega sellado. Las claves, el antipiratería y lo jurídico siguen siendo privados.
Nunca necesitas el core para escribir una app. El SDK es la frontera, y es estable.
La parte sellada tiene fecha. Su licencia pasa automáticamente a MIT el 1 de enero de 2030. Esa fecha está escrita 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, y lo aceptamos. Esa es la postura open-core: 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. No sale de su vault salvo que se la invite. Construye con esa regla.
¿Cómo construyes?
La oferta para desarrolladores
Reserva tu licencia gratuita, y programa tu primer cartucho.
¿Construyes sobre Mnemosyne OS? Queremos tu opinión, no tu dinero. Descarga el OS y pide tu licencia de fundador gratuita. Te añadimos 5 $ en créditos cloud para probar de inmediato, sin 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. 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/Mnemosyne-OS/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 y no adivines la API.