Creamos `memorize`, para que los agentes de IA compartan la memoria del proyecto — y necesitamos ayuda

Empezó con un problema que vivía todos los días desarrollando en solitario. Los vendors sacan modelos mejores casi a diario, pero cada vez que cambiaba para seguir desarrollando con otro modelo (por ejemplo, de Opus 4.7 a GPT 5.5), la memoria de trabajo del proyecto no se iba conmigo. Mientras cada agente iba acumulando su propio silo de memoria, yo tenía que reconstruir a mano el contexto roto una y otra vez. Las primeras funciones de memoria de los agentes eran demasiado pobres: cuando terminaba la sesión, el contexto moría; además, al estar atadas a una sola máquina, lo que hacía en el desktop no continuaba en la laptop.

Los proyectos necesitan su propia memoria. Por eso hicimos esto: una herramienta open source, local-first, que hace que el proyecto mismo tenga memoria.

Partes técnicas en las que tenemos confianza

• Memoria de dos capas inspirada en el sistema de aprendizaje complementario (CLS) del cerebro: durante el trabajo captura observaciones de forma barata sin usar LLM (hipocampo), y en los límites de la sesión hace consolidación en background (neocórtex). El olvido no ocurre por borrado, sino solo por competencia de puntajes al momento de recuperar (importancia × recencia con semivida de 14 días × relevancia para la tarea), y ningún recuerdo se elimina.

• Cero API keys: no hace falta un LLM aparte para la consolidación. Simplemente lanza el claude -p / codex exec en el que ya iniciaste sesión. El diseño hace que el agente use su propio yo para ordenar su memoria; la recursión infinita que esto podría causar (consolidación → dispara hook → consolidación → …) se corta con un guard de variables de entorno.

• Consolidación sin pérdida: el watermark solo avanza después de persistir el evento; si hay timeout del LLM o falla el parseo, el siguiente límite vuelve a intentar el mismo tramo. Incluso si el watermark se pierde, la deduplicación basada en procedencia evita consolidaciones duplicadas.

• Convergencia entre máquinas sin servidor: si sincronizas un log de eventos append-only, todas las máquinas convergen al mismo estado usando solo reglas deterministas basadas en contenido, sin sincronización de reloj. Incluso si dos máquinas consolidan el mismo tramo al mismo tiempo, todas las réplicas eligen al mismo ganador.

• No confiamos en embeddings para detectar contradicciones: la similitud coseno es ciega ante las negaciones ("haz merge" y "no hagas merge" quedan casi como el mismo vector). Por eso la similitud se usa solo para recuperar candidatos, y la decisión la toma un LLM. Los recuerdos que pierden no se borran; simplemente se cierra su periodo de validez, así que se puede restaurar que "en ese momento era cierto".

• Compartición en tiempo real entre sesiones paralelas: las sesiones que corren sobre el mismo proyecto pueden ver en qué está trabajando la otra, y si tocan el mismo archivo aparece una alerta de conflicto.

• El esquema evoluciona con medición, no con teoría: para decidir si conviene cambiar el sistema de clasificación de recuerdos, juntamos durante semanas campos de vida útil solo de observación y telemetría de comportamiento (cuándo se inyectó, cuándo se invalidó) asociados a cada recuerdo, y tomamos la decisión con datos. Toda esta discusión está abierta en Discussions del repositorio.

Por qué lo publicamos ahora

Sinceramente, quería lanzarlo más maduro. Pero al ver que OpenAI está sacando funciones de memoria como dreaming, cambié de idea: si un vendor grande empezó a excavar el mismo problema, eso significa que la dirección es correcta, y antes de que la memoria encerrada dentro de los vendors se vuelva el estándar, debería existir una alternativa neutral respecto al vendor. Por eso lo publicamos ahora.

Hasta dónde queremos llegar

Con la llegada de modelos de nivel Fable 5, los agentes ya están en un punto donde pueden colaborar entre sí, pero no existe una infraestructura compartida para esa colaboración. A largo plazo, quiero construir una plataforma de utilidad pública que haga por la memoria y la colaboración de agentes lo que Git hizo por el código. Como no había dinero para empezar por un servidor, esa limitación terminó produciendo un diseño local-first que converge incluso sin servidor. Ahora mismo, la primera pieza de eso —"compartir la memoria del proyecto en local"— ya funciona por completo. De hecho, una parte importante de la discusión de diseño, la implementación y hasta el despliegue de hoy de madrugada de este proyecto se hizo junto con agentes: exactamente el tipo de colaboración que esta herramienta quiere habilitar.

Ayuda concreta que necesitamos

1. Probarlo y reportar dónde se rompe: instalación en una sola línea y luego un issue. Solo en la validación previa al lanzamiento de hoy encontramos 2 bugs en el script de instalación (comillas en PowerShell 5.1, Linux EACCES), y seguro hay más.
2. Adaptadores para otros agentes: gente que conozca la estructura de hooks de Cursor, Gemini CLI y Windsurf.
3. Participar en la discusión sobre la clasificación de recuerdos: hay Discussions abiertas para decidir con datos "qué tipos de recuerdos existen".

La instalación es de una línea (en Windows, revisa el comando de PowerShell en el README):

curl -fsSL https://raw.githubusercontent.com/shakystar/memorize/… | sh

O una sola línea en una sesión de Claude/Codex: "Set up memorize in this project. Follow
https://github.com/shakystar/memorize/…;

Repositorio: https://github.com/shakystar/memorize · README en coreano
(https://github.com/shakystar/memorize/blob/main/docs/i18n/README.ko.md) · documento de arquitectura
(https://github.com/shakystar/memorize/blob/main/docs/ARCHITECTURE.md)

AGPL, todo se guarda localmente, sin telemetría. Cualquier feedback es bienvenido.

[shakystar]

Soy quien lo hizo.

El día justo antes del lanzamiento de este proyecto fue exactamente el tipo de colaboración al que apunta esta herramienta. Tuve una discusión de diseño con agentes sobre si “las etiquetas eran adecuadas para clasificar recuerdos, cuando el cerebro no tiene etiquetas”, el consenso quedó plasmado en GitHub Discussions y en issues, se hizo merge del PR de implementación, y hasta confirmé el dogfooding en el que el agente usó a sí mismo (claude -p) como extractor para integrar registros reales de trabajo en memoria de largo plazo, antes de presionar el botón de despliegue. Todos los debates de diseño de ese proceso están publicados en las Discussions del repositorio.

Como creo que una de las preguntas más frecuentes que recibiré sobre lo que no escribí en el texto será “¿no se vuelve lento o no cuesta dinero?”, respondo de una vez: durante el trabajo, el LLM no ayuda en absoluto. La captura es un filtro por reglas, así que la latencia percibida es 0, y la única vez que corre el LLM es en una integración al final de la sesión; además, eso ocurre en un proceso de fondo separado, así que no bloquea al agente ni por 1 segundo. Incluso esa llamada sale a través de la suscripción de claude/codex que ya están usando, así que no hay cobro adicional por API. Según el dogfooding de hoy, 44 observaciones de una sesión se integraron en 1 llamada en segundo plano (unos 30 segundos), y la inyección al inicio de la sesión también es texto dentro de un presupuesto de 4,000 caracteres, así que la carga de tokens es mínima. La meta era que lo instalaras y luego te olvidaras de él.

Si comparto solo una de las cosas que detectamos en la validación en dispositivo real antes del lanzamiento: en el README, el comando de verificación aparecía como npx memorize, pero resulta que el memorize sin scope en npm es un paquete de otra persona. Reportes sobre este tipo de puntos que “solo se ven en dispositivo real” de verdad tienen mucho valor.

Petición: validé directamente en dispositivo real Windows y WSL/Linux, pero no tengo un equipo macOS. En CI, toda la suite de pruebas de macOS pasa, pero no pude ejecutar en dispositivo real el ciclo completo de instalación en una línea → hook → inyección al inicio de la sesión. Si alguien que use macOS pudiera instalarlo aunque sea una vez y decirme en un comentario o issue si funciona o se rompe, sería de gran ayuda.

También son bienvenidas las preguntas de diseño (por qué no se usan embeddings para decidir, por qué no hay borrado, cómo converge entre múltiples máquinas sin reloj): responderé todas.