La sesión termina.
Tus decisiones se quedan.

El ecosistema

Los servidores MCP hacen muy bien su trabajo.

Hay cientos. Cada uno conecta tu agente a una herramienta concreta y lo hace bien: un repositorio, un ticket, una base de datos, un navegador, un terminal. Los usamos todos los días.

Todos le dan manos a tu agente. Ninguno le da una memoria entera. Se divide en dos partes:

Un agente que escribe en el vacío no le enseña nada a nadie. Y si tu agente no puede leer tu cuaderno, lo copias a mano en cada prompt.

Las dos partes se juntan en el mismo proceso

Todo corre en tu máquina. Tu editor lanza un servidor MCP que habla en bucle local, en 127.0.0.1:7799. De ahí no sale nada. Cuando la app está abierta, es ella quien responde: tu agente lee los Vaults que tienes delante, sin copia y sin sincronización.

La conexión va en los dos sentidos. El agente lee lo que la app sabe. La app muestra lo que el agente hace. Una tarjeta de sesión se posa en tu tablero: su estado, su duración, los archivos que escribió. Puedes contestarle sin cortar lo que está haciendo.

La app es el servidor. Ciérrala, y la memoria, las tareas, la agenda y la tarjeta de sesión se quedan sin nadie con quien hablar. Te lo dicen.

Del lado del agente

Cómo trabaja un agente aquí.

Tres números, en el orden en que llegan.

Tokens estimados a partir de bytes contados, nunca tokenizados · medición del 16 de septiembre de 2026.

Los cinco costes del principio, uno por uno.

La situación	Sin memoria	Con Mnemosyne OS
Abrir una sesión nueva	El agente explora el repositorio: grep, archivos leídos enteros. La factura sube antes de la primera respuesta.	El agente carga un mapa de ≈ 50 000 tokens, y luego pide lo que le falta.
Encontrar una decisión de hace tres semanas	La recuerdas de cabeza, o se vuelve a resolver al revés.	El agente la encuentra por ≈ 1 100 tokens, con el archivo de donde sale.
Una trampa ya pagada una vez	Nadie lo escribió en otro sitio que en una conversación cerrada, así que vuelve.	Está escrito y fechado, y el agente lo lee antes de tocar la misma zona.
Una tarea dictada en plena conversación	Se queda en el log del chat.	Llega a tu lista o a tu agenda, en un archivo que te pertenece.
Dos agentes en la misma rama	Se descubren en el momento del merge.	Un control de colisión te avisa antes de que hagas commit.

Los dos números de la columna derecha son los de la escala de arriba.

Un agente lleva menos del 0,5 % de este proyecto en su ventana y alcanza cualquier hecho del resto por unos mil tokens. Incluso una ventana de un millón de tokens solo sostendría una doceava parte.

La recuperación devuelve los pasajes y nombra el archivo de donde sale cada uno. Compruebas una afirmación contra la ficha.

Un chat reenvía su historial en cada turno, así que cuanto más larga es la conversación, más cuesta la respuesta siguiente. Una pregunta hecha a la memoria cuesta lo mismo en el primer turno y en el centésimo.

Empezar

Conectar Claude Code, Cursor o Antigravity.

Dos pasos para conectar tu agente. Solo el primero pide una descarga.

Descargar Mnemosyne OS El código en GitHub

Después, añade el servidor al .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}"
  }
} } }

Apunta un Vault a la carpeta de tu proyecto. Tu agente ya puede leer lo que decidiste, y escribir lo que él decidió. Todo se queda en el disco, en archivos que puedes abrir sin nosotros.

Declarar tu IDE, y mantener el mando

Tu IDE ya escribe transcripciones en tu disco. Para que Mnemosyne OS las lea, instalas el cartucho Ariadne y le señalas la carpeta. Tú dices dónde leer, una vez.

Tres herramientas leen archivos, así que responden sin instalar nada: la lista de tus sesiones de agente, los archivos que escribieron, y el control de colisión. El resto pide la app abierta. La pregunta a la memoria es una de ellas, igual que las tarjetas de sesión en las que le escribes a un agente que trabaja.

Ariadne está en beta y se añade a mano desde su repositorio.

El fallo que conviene conocer

Un agente conectado al servidor MCP no consulta la memoria por su cuenta. Tiene las herramientas, nadie le dijo que las usara primero. Así que hace lo que siempre ha sabido hacer: grep, lee archivos enteros, y paga la exploración que acababas de evitar.

La instrucción cabe en tres líneas, en las reglas de tu proyecto (CLAUDE.md, .cursorrules, lo que uses):

Antes de buscar en el código, consulta la memoria:
mnemosyne_memory_ask sobre el Vault del proyecto.
Un grep cuesta miles de tokens, una pregunta cuesta mil.

En este repositorio la pusimos arriba del archivo de convenciones. El agente la carga con sus 50 000 tokens de apertura.

Si construyes encima de Mnemosyne OS en vez de al lado, la página de superficies de dev te orienta al paquete correcto en dos líneas.

Y si algo no funciona, o funciona mejor de lo previsto, estamos en el Discord.