claude-mem y sus 104.793 estrellas: una llamada al modelo por cada evento de herramienta, 400.000 caracteres de historial y un techo de 10.000 que falla en silencio

claude-mem es un plugin de memoria para agentes de programación: se engancha a los eventos del ciclo de vida de Claude Code (y de OpenCode, Codex, Pi, Grok Bot, OpenClaw, Hermes y otros), comprime lo que hizo el agente en «observaciones», las guarda en SQLite y Chroma, y al empezar la sesión siguiente inyecta un resumen de vuelta. Tiene 104.793 estrellas, 9.241 forks y 320 watchers, y la versión 15.7.0 se publicó hace unos días.

Lo interesante no es que exista. Es que la versión que se instala en octubre de 2026 configura tres cosas a la vez, y cada una lleva un número que el README no reúne en ningún sitio: quién paga la compresión, cuánto de tu sesión se vuelve a leer en cada evento y cuántos caracteres de contexto pueden llegar antes de llegar, en silencio, como nada.

Leyendo el repositorio las tres cosas se vuelven legibles. Eso es lo que hace este artículo: el repo en main, 30 de octubre de 2026, más sus propios issues, su propia suite de evaluación y la página de precios que abre el instalador.

Los números primero

380 encabezados de versión en 14 meses son unas 27 publicaciones al mes. No es una queja: es un aviso sobre fijar versiones. Solo en la primera página de la API hay al menos 100 releases, así que «fijar una versión» aquí es una decisión real y no un trámite.

Instalar ya no es solo instalar

npx claude-mem install termina ahora con un inicio de sesión. El README lo describe sin rodeos: pide identificarte en el navegador con un enlace mágico por correo —«sin tarjeta»—, y al hacerlo se aprovisiona una clave de memoria que desbloquea el observador de claude-mem con una prueba gratuita de 30 días: la memoria corre fuera de tu plan, así que obtienes «hasta un 100 % más de uso» de tu plan. Cuando la prueba termina, la memoria vuelve automáticamente a tu plan de Anthropic salvo que te suscribas.

El código del instalador explica por qué ese es el camino por defecto. El selector de proveedor es una lista de dos opciones y el comentario encima dice: «CMEM Pro preseleccionado: es la ruta recomendada y sobre la que está construido el embudo». Un segundo comentario, sobre el paso de alta, añade: «La información de facturación vive en la página de pago, no aquí».

La página a la que te lleva es explícita, y discrepa del README en una palabra que importa:

• README, paso de identificación: «enlace mágico por correo — sin tarjeta».
• cmem.ai/pro, la página a la que te envía el instalador: «Prueba de 30 días · luego 30 $/mes · cancela cuando quieras. Se requiere tarjeta. La facturación empieza a los 30 días, o antes si gastas el uso incluido. Los planes se suben de nivel automáticamente al alcanzar el límite incluido. Las tarjetas prepago no son válidas para la prueba».

Las dos frases pueden ser ciertas en secuencia —identificarte no necesita tarjeta; empezar la prueba sí—, pero solo una está en el README, y el instalador es justo lo que lleva al usuario nuevo hacia la otra. Los niveles son 30 $ (Pro), 70 $ (Heavy) y 100 $ (CMEM Max, «más excesos facturados»), con subida automática al agotar lo incluido. Para un equipo de cinco personas son 150 $/mes en Pro antes de cualquier exceso.

Dos detalles que conviene retener:

1. Las instalaciones headless son otro producto. El valor por defecto en los ajustes es CLAUDE_MEM_PROVIDER: 'claude', con este comentario: «el selector interactivo de proveedor usa ‘cmem’ (el observador alojado) por defecto, pero las instalaciones headless aterrizan aquí: no existe clave entregada en modo headless, así que el valor por defecto se queda en ‘claude’». Es decir: CI y las instalaciones por script facturan a tu propio plan desde el primer minuto, sin prueba ni identificación. Si evalúas claude-mem en un servidor de build, estás midiendo la ruta que pagas tú, no la alojada.
2. «Hasta un 100 % más de uso» es una constante, no una medición. En src/shared/pro-promo.ts: PLAN_USAGE_GAIN_PERCENT = 100, junto a PRO_TRIAL_MAX_DAYS = 30. Ese mismo archivo enumera las superficies que llevan el mensaje —banner de inicio de sesión, banner por mensaje, aviso de bienvenida de la primera sesión, «Next Steps» del instalador, cabecera del visor y aviso de vuelta al plan— y explica por qué: «Casi nadie que usa el plugin gratuito sabe que la prueba existe, así que el mensaje viaja con los mensajes que ya lee». Es ingeniería de marketing inusualmente sincera, y también la frase que hay que recordar cuando veas «gratis» cerca de este proyecto.

Qué se captura y qué sale de la máquina

En cada evento el plugin decide si merece una observación. La lista de exclusión es corta: CLAUDE_MEM_SKIP_TOOLS vale por defecto ListMcpResourcesTool,SlashCommand,Skill,TodoWrite,AskUserQuestion. Todo lo demás —comandos Bash y su salida, lecturas de archivos, ediciones, búsquedas— se captura, y el prompt del observador lleva dos campos variables, <parameters> y <outcome>, cada uno limitado a 16.000 caracteres por OBS_PROMPT_FIELD_MAX_CHARS.

Después esos campos van a un modelo. Cuál, depende del proveedor elegido:

La última fila no es hipotética. El modelo por defecto de OpenRouter era xiaomi/mimo-v2-flash:free; el issue #3659 se titula «xiaomi/mimo-v2-flash:free is deprecated on OpenRouter», y el código mantiene ahora un conjunto RETIRED_OPENROUTER_DEFAULT_MODELS precisamente porque una instalación nueva escribe todos los valores por defecto en settings.json en la primera carga: un modelo gratuito retirado se queda congelado en disco en cada instalación existente.

La aritmética que no está en el README

El modelo de coste no es por sesión. Es por evento, y el historial se reenvía cada vez. Tres valores por defecto lo concretan:

• CLAUDE_MEM_CLAUDE_OBSERVATION_BATCH_SIZE: '1' — «eventos en cola por prompt del observador (1-32). 1 = un evento por prompt». Una petición al modelo por cada evento capturado.
• CLAUDE_MEM_OBSERVER_MAX_CONVERSATION_CHARS: '400000' — la conversación se retira al pasar de 400.000 caracteres, unos 100.000 tokens.
• src/sdk/prompts.ts: «el prompt se añade a session.conversationHistory, que cada observación posterior de la sesión reenvía completa. Una sesión de automatización de navegador con unos cientos de capturas lo repite todo, cada vez».

Así que los tokens de entrada crecen de forma aproximadamente cuadrática con el número de eventos hasta el reinicio de 400.000 caracteres, y entonces vuelven al briefing. Usando la tabla de precios del propio repo (anthropic/claude-haiku-4.5 a 1,00 $ de entrada y 5,00 $ de salida por millón de tokens, precio de lista, 2026-09-08), 4.000 caracteres de andamiaje de prompt, 600 tokens de salida por observación y la estimación de 4 caracteres por token que usa el propio código:

Son estimaciones, no facturas: los tamaños reales varían y mi estimación de tokens es la que usa el propio código. Pero la forma es el hallazgo. Pasados unos 113 eventos la conversación se asienta en su techo de 400.000 caracteres, así que cada evento adicional relee unos 100.000 tokens de entrada —unos 0,10 $ a precio de lista de Haiku, unos 0,009 $ en el DeepSeek del observador alojado— y el tamaño de la carga deja de importar porque el historial domina el prompt.

Dos lecturas prácticas. En el plan alojado el observador es genuinamente barato, y por eso 30 $/mes con «uso incluido» puede cuadrar. En tu propio plan de Anthropic, una sesión larga que capture 600 eventos se está gastando decenas de millones de tokens de entrada en contabilidad, y esos tokens salen de la misma ventana que necesita tu trabajo real. La afirmación del 100 % es una afirmación sobre tu cuota restante; nada en el repo la mide.

El techo de 10.000 caracteres y el fallo que no avisa

La pieza de ingeniería más útil del repositorio la escribió el mantenedor como comentario en src/services/context/ContextBudget.ts:

«Claude Code entrega el stdout de un hook tal cual hasta 10.000 caracteres. Uno más y el bloque entero se escribe a disco y se sustituye por un extracto de ~2 KB, de modo que el modelo no recibe ningún contexto — y el hook sigue informando éxito, que es por lo que esto falló en silencio (#3802, #1899).»

Léelo otra vez: por encima del límite, el agente se queda sin memoria, y el hook informa éxito. No hay error en el log, ni aviso en la interfaz, nada que buscar con grep. El agente simplemente se comporta como si nunca hubiera tenido memoria y tú concluyes que la función no vale mucho.

El historial de issues muestra el techo redescubierto tres veces:

#5079 es el que hay que mirar. El recorte del presupuesto funcionaba; lo que lo rompió fue el pie de página. El mensaje de SessionStart lleva ahora el enlace al visor, la línea de la prueba, la cuenta atrás de la prueba y la línea de descubrimiento de TeamBrain, y un extracto ajustado justo al límite más esas líneas se pasaba: las líneas promocionales expulsaron la memoria. La corrección reserva 512 caracteres (TERMINAL_BANNER_RESERVE_CHARS) para ellas.

Hoy el constructor mide en vez de contar: renderiza y, mientras el bloque exceda el presupuesto, elimina el elemento más caro y vuelve a renderizar. El orden está documentado: primero las narrativas completas de observación, luego el resumen de la última sesión, luego la última respuesta de la sesión anterior, luego la mitad de las sesiones de la línea temporal y luego la mitad de las observaciones. Solo elementos completos, nunca medio elemento.

Lo que significa: en un proyecto con actividad, lo que de verdad recibes al inicio de sesión es una línea temporal, no narrativas. La «memoria» se degrada por diseño a «una lista de cosas que pasaron», y la única forma de saber cuál te tocó es mirar. Los tamaños están en el mismo archivo: un título de observación ocupa unos 150-320 caracteres, una línea de resumen de sesión unos 250-600 y el bloque de resumen de la última sesión 1-5 K él solo.

Se puede resolver con un comando, sin leer nada de lo anterior:

claude-mem hook claude-code SessionStart | wc -c

Si ese número ronda 10.000 estás en el techo y lo último recortado puede ser justo lo que querías. Si pasa de 10.000, el modelo está viendo un extracto. En ambos casos el hook termina con éxito: el código de salida no te dice nada.

El File Read Gate cambia cómo lee el código tu agente

Instalar claude-mem instala también una compuerta que está activa por defecto. Cuando Claude Code intenta leer un archivo de código de 32 KB o más que ya tiene observaciones, la compuerta deniega la lectura y devuelve la línea temporal del archivo más instrucciones hacia smart_outline, smart_unfold, get_observations o una lectura con offset/limit. Los archivos por debajo de 32 KB nunca se bloquean; Markdown, YAML, TOML y JSON tampoco.

El README de la evaluación del propio proyecto documenta las dos caras con honestidad, algo poco común:

• Con el archivo de prueba de 49 KB: «el mismo bloqueo ahorró un 35 % en Sonnet y un 32 % en Opus».
• Con el archivo de 19 KB, antes de que existiera el umbral de 32 KB: «la misma pregunta costó un 6 % menos en Sonnet con la compuerta activada, pero un 20 % más en Opus. Opus ejecutó smart_outline y luego leyó cerca del 70 % del archivo con lecturas dirigidas, así que el bloqueo no ahorró casi nada y costó cuatro turnos extra».

O sea: la compuerta gana de verdad en archivos grandes y pierde de verdad en los pequeños, y el umbral se ajustó después de medirlo. Si tu código son módulos de 10-30 KB no la verás; si son bundles vendorizados y archivos de 3.000 líneas, la verás constantemente y esos cuatro turnos extra son tuyos.

La compuerta tiene además una dependencia que conviene conocer: necesita el CLI de tree-sitter, que la instalación como plugin no incluye, así que el worker lo descarga de las releases de GitHub en segundo plano al primer arranque y solo ejecuta un binario cuyo SHA-256 coincide con el digest fijado. Sin red, sin compuerta; y según la documentación la lectura pasa entonces con la línea temporal como contexto.

Qué protege tus datos por defecto: menos de lo que imaginas

Aquí los valores por defecto merecen atención, porque todos son defendibles por separado y en conjunto son finos:

El proyecto dice la parte incómoda en voz alta. En docs/server-architecture-and-team-vision.md: «Modo privado por defecto. Las etiquetas <private> exigen disciplina del usuario. Un modo privado por defecto en equipo (opt-in para compartir) invierte el modelo de confianza y probablemente debería existir para entornos regulados». Es el mantenedor admitiendo que el modelo actual depende de que el usuario acierte cada vez — y con la redacción desactivada, la máquina no lo hace por ti.

En descargo de la telemetría: está activada por defecto, pero el depurado es lista blanca y no lista negra, la documentación enumera cada campo recogido, la grabación de sesión de PostHog se documenta como no aplicable porque el visor local no carga SDK de navegador, y los eventos de alto volumen se agregan por sesión en vez de enviarse uno a uno. Eso es mejor que la mayoría de herramientas de este tamaño.

La frontera open core está dibujada en el repo

docs/ip-boundary.md describe la estructura sin eufemismos: Apache-2.0 cubre el motor, el servidor, el CLI, los SDK, las herramientas MCP, los adaptadores, los tests y la documentación. Catorce áreas quedan reservadas: nube alojada Magic Recall, sincronización de memoria de equipo y organización, panel de administración, SSO/SAML/SCIM, RBAC empresarial, interfaz de auditoría, motor DLP y de políticas, agentes de conocimiento premium, evaluaciones gestionadas, herramientas de despliegue para clientes, observabilidad empresarial, flujos de soporte/SLA, conjuntos de datos de evaluación internos y conectores privados de cliente.

Lee esa lista como un mapa de lo que nunca podrás autoalojar, por mucho que la insignia de licencia diga Apache-2.0. Para una persona, perfecto. Para un equipo que necesita SSO y registro de auditoría, la vía open source termina exactamente donde empiezan las licencias de 30-100 $, que es un modelo de negocio legítimo y también lo que hay que tener previsto antes de montar un flujo de trabajo encima.

Cómo evaluarlo en una tarde

No te fíes de mis números ni de los del README. Estas ocho comprobaciones resuelven lo que de verdad importa, en el orden que menos cuesta:

1. Cuenta lo que llega. claude-mem hook claude-code SessionStart | wc -c en un proyecto con unas semanas de historial. El objetivo es estar bastante por debajo de 10.000.
2. Cuenta lo que cuesta. sqlite3 ~/.claude-mem/claude-mem.db "select count(*) from observations;" después de un día normal y multiplica por la forma de coste de arriba. Si usas el proveedor de Anthropic, mira el consumo de tu plan ese mismo día.
3. Comprueba el valor por defecto de la redacción. Pon un token ghp_ falso en un comando Bash con la redacción desactivada y búscalo en la tabla de observaciones. Si está, ya sabes para qué existe CLAUDE_MEM_REDACT_ENABLED.
4. Prueba <private> en el borde. Envuelve una cadena en <private>, ejecuta una sesión y búscala en la base de datos local. La documentación dice que se elimina en la capa de hook; verifica que la cadena nunca llegó a SQLite.
5. Decide sobre la compuerta. Si tu repositorio son archivos grandes, cronometra una tarea con la compuerta activada y desactivada. Si son módulos pequeños, confirma que nunca llegas al umbral de 32 KB.
6. Lee tu propio archivo de ajustes. ~/.claude-mem/settings.json se siembra con todos los valores por defecto en la primera carga, incluido un id de modelo de OpenRouter retirado si instalaste antes del cambio. Los valores persistidos ganan a los del código para siempre: por eso existe RETIRED_OPENROUTER_DEFAULT_MODELS.
7. Pregunta qué pasa el día 31. El README dice que la memoria «vuelve automáticamente a tu plan de Anthropic». Ni en el repo ni en la página de la oferta se dice cuánto tiempo se retienen los datos sincronizados en la nube tras caducar la prueba, ni cómo exportarlos. Consíguelo por escrito antes de meter contexto de equipo ahí.
8. Fija la versión. 380 publicaciones en 14 meses significan que main es un blanco móvil con un mes de 900 commits detrás. Elige una etiqueta y lee su changelog.

Preguntas frecuentes

¿claude-mem es gratis? El plugin es Apache-2.0 y la vía local no cuesta instalarlo. La compresión corre en un modelo y alguien la paga: el observador alojado durante los 30 días de prueba, luego 30 $/mes (Pro), o tu propio plan de Anthropic, clave de OpenRouter o de Gemini. Las instalaciones headless y de CI usan tu plan de Anthropic desde el primer minuto.

¿Qué guarda exactamente? SQLite (~/.claude-mem/claude-mem.db) guarda sesiones, observaciones y resúmenes; Chroma guarda los embeddings para la búsqueda híbrida; las capturas están desactivadas por defecto. Las entradas y salidas de herramientas se truncan a 16.000 caracteres por campo para el prompt del observador, pero el log local se conserva completo: la documentación es explícita en que el logger local nunca pasa por el depurador.

¿Por qué dejó de funcionar mi memoria? Tres formas conocidas, todas silenciosas: un bloque de SessionStart de más de 10.000 caracteres (se entrega un extracto de 2 KB y el hook informa éxito), una instalación con npm -g (el README: instala «solo el SDK o biblioteca, no registra los hooks ni levanta el servicio worker») o un modelo gratuito de OpenRouter retirado en origen.

¿Funciona con agentes que no sean Claude Code? El repo trae adaptadores para OpenCode, T3 Code, Antigravity, OMP, Pi, DeepSeek Harness, Cursor, Grok Bot, OpenClaw y Hermes, y el README documenta la instalación por IDE. La vía de Grok Bot es distinta: no tiene hooks de host, así que vigila los archivos de log del chat, usa CMEM Pro por defecto y ejecuta un piloto que añade líneas [awareness] en el log de memoria del propio bot.

¿Está mantenido? Sí, intensamente, y en la práctica por una persona: 2.567 de los 3.525 commits de la primera página de contribuidores son del propietario, y entre los principales aparecen un bot de PostHog (65), GitHub Copilot (61) y un agente de Cursor (17). 380 publicaciones en 14 meses. Factor bus uno y velocidad de publicación muy alta: por eso fijar versión importa aquí más que en un proyecto más lento.

¿Debería adoptarlo un equipo? Como comodidad por desarrollador, con la redacción activada y la retención configurada: sí. Como memoria compartida de equipo, no: la sincronización, el RBAC y el registro de auditoría están en la lista reservada, así que la respuesta son licencias de CMEM Pro y una conversación sobre qué sale de la máquina. Como instalación sensible donde nadie va a acordarse de escribir <private>: no, hasta que exista el modo privado por defecto.

Veredicto

claude-mem resuelve un problema real, y lo hace con más honestidad de ingeniería que la mayoría de proyectos con 100.000 estrellas: su suite de evaluación mide el coste en tokens de su propia función y publica el caso en el que pierde, el constructor de presupuesto documenta el techo que antes se comía la memoria en silencio, y el archivo de frontera de propiedad intelectual te dice dónde termina el tramo gratuito. Son artefactos de un mantenedor que espera ser auditado.

Los valores por defecto, en cambio, son un embudo de ventas y una capa de coste disfrazados de función de memoria. Una petición al observador por evento con toda la conversación reenviada, un techo de 400.000 caracteres que deja el evento marginal en unos diez céntimos con Haiku, un observador alojado preseleccionado en el instalador con las condiciones de facturación deliberadamente dejadas para la página de pago, y la redacción desactivada hasta que la pidas. Nada de eso es deshonesto: todo está escrito, en el código y en la documentación. Simplemente está escrito en cinco archivos distintos, que para la mayoría de la gente que teclea npx claude-mem install es lo mismo que no estar escrito.

Instálalo y dedica veinte minutos a las ocho comprobaciones de arriba. La herramienta merece la pena; la configuración por defecto no es con la que deberías trabajar.