Engram: Cómo darle memoria a tus agentes de IA (Claude Code, OpenCode)

TL;DR: Engram es un sistema de memoria persistente basado en MCP que guarda resúmenes automáticos de tus hallazgos, decisiones y configuraciones. Funciona de manera agnóstica entre diferentes agentes.

Tengo que admitir que había sido renuente a caer rendido ante los encantos del desarrollo agéntico. Prefería realizar el desarrollo a la antigua, con un buen IDE y, a lo mucho, GitHub Copilot sugiriéndome cambios. Pero finalmente cedí y me puse a experimentar con las opciones más populares: Claude Code y OpenCode. Personalmente, prefiero OpenCode (quizás en otro artículo profundice en mis razones).

Por ahora, quiero centrarme en una problemática que pronto me vi encontrando con gran frecuencia: la falta de memoria persistente de los agentes de IA.

La situación es esta: cuando empiezas a tomarte en serio el desarrollo agéntico, inicias una sesión de trabajo, haces descubrimientos clave y tomas múltiples decisiones de arquitectura. Terminas tu jornada y, cuando al día siguiente abres una nueva sesión, tu agente no recuerda absolutamente nada de lo que decidiste o descubriste.

Probablemente estés pensando que lo más práctico es simplemente continuar la sesión anterior. Sin embargo, ese enfoque ignora un detalle técnico crucial: estarías arrastrando un contexto ya gastado e inflado, lleno de información irrelevante para tus nuevas tareas. El enfoque más óptimo es persistir en memoria únicamente aquellos fragmentos de información que te sean útiles, para poder consultarlos desde sesiones limpias.

Aquí es donde entra la herramienta que te quiero presentar hoy: Engram. 🛠️

¿Qué es Engram?

Engram es un sistema de memoria persistente diseñado específicamente para agentes de código por IA. Dentro de las características que más destacan en comparación con otras alternativas, encuentro las siguientes:

• Agnóstico al agente: No está ligado a un solo agente específico. Al funcionar como servidor MCP (Model Context Protocol), puedes utilizar Engram en cualquier herramienta compatible: Claude Code, OpenCode, Gemini CLI, Codex, VS Code (Copilot), Antigravity o Cursor.
• Memoria optimizada: No guarda la sesión de trabajo completa; en su lugar, va generando y almacenando resúmenes estructurados a medida que avanzas en tu desarrollo.
• Interoperabilidad: Al no depender de un solo cliente, puedes alternar entre herramientas y mantener el mismo “cerebro”. Digamos que un día trabajas en Claude Code y al siguiente te apetece usar OpenCode; tus agentes siempre tendrán acceso a las mismas memorias.
• Sincronización en la nube/local: Puedes sincronizar las memorias aprendidas entre múltiples computadoras. Esto viene genial cuando alternas entre tu PC de escritorio y tu laptop, o cuando necesitas compartir el contexto con otros miembros del equipo.
• Registro automático: No necesitas indicarle manualmente que recuerde información todo el tiempo. El agente irá tomando notas de forma automática cuando complete hitos importantes (aunque siempre puedes forzarlo a recordar algo específico mediante un prompt).

(Si ya tienes experiencia con alternativas como claude-mem, te recomiendo examinar su comparativa detallada en la documentación oficial).

¿Cómo funciona Engram? ⚙️

Cuando tú y el agente completan una tarea significativa, como por ejemplo:

• 🐛 Un bug fix completado.
• 🏗️ Una decisión de arquitectura tomada.
• 🔍 Un descubrimiento no obvio sobre el codebase.
• ⚙️ Un cambio de configuración o de entorno.
• 🧩 Un patrón establecido (naming, estructura, convenciones).
• 👤 Una preferencia o restricción de usuario aprendida.

El agente llamará a la herramienta de guardado del MCP de Engram para persistir una memoria utilizando el siguiente formato estándar:

title: "Verbo + qué"  (ej: "Fixed N+1 query in UserList")
type: bugfix | decision | architecture | discovery | pattern | config | preference
scope: project (default) | personal
topic_key: clave estable para temas evolutivos (ej: architecture/auth-model)
content:
  **What**: Una oración clara sobre qué se hizo.
  **Why**: Qué lo motivó (user request, bug, performance, etc.).
  **Where**: Archivos o paths afectados.
  **Learned**: Gotchas, edge cases, cosas que sorprendieron (se omite si no hay).

Ejemplo de una memoria real:

 **Observation #242**
 ──────────────────
 **Type:** pattern
 **Title:** cache invalidations: create/update/delete
 **Session:** manual-save-personal-app
 **Created:** 2026-04-23 22:39:03
 **Project:** personal-app
 
 **Content**
 **What**: Completed the set of graphcache `updates.Mutation` entries for waitlist mutations in `src/utils/graphClient.ts`, plus added RefreshControl on WaitListDetails screen.
 
 **Registered invalidations**:
 - `createWaitList` → invalidates `Query.findAllActiveWaitLists` (pre-existing)
 - `updateWaitList` → invalidates `Query.findWaitListByUuid`
 
 **Why**: Details screen showed stale data after updates; list screen showed deleted items until network round-trip after deleteWaitList (previously no invalidation existed, analogous to the `deleteAutoBooking` pattern that already existed).
 
 **Where**:
 - `src/utils/graphClient.ts` — `offlineExchange.updates.Mutation` block
 - `src/screens/logged/bookings/WaitListDetails/index.tsx` — RefreshControl + `refetchWaitList` from `useQuery` tuple
 
 **Decision**: Chose Option B (urql `cacheExchange.updates`) over navigation callback or event listener registry. Rationale: graphcache `updates` is the canonical urql pattern.
 
 **Learned**:
 - Project uses `offlineExchange` from `@urql/exchange-graphcache` (not default `cacheExchange`), which supports `updates`.
 - Existing convention: `cache.invalidate('Query', 'fieldName')` with NO args.

Adicionalmente, Engram también guarda un volcado de memoria al cerrar una sesión de trabajo. En ese caso, la estructura captura el estado global:

## Goal
[En qué estábamos trabajando]

## Instructions
[Preferencias o restricciones descubiertas]

## Discoveries
- [Hallazgos técnicos, gotchas]

## Accomplished
- [Items completados con detalles]

## Next Steps
- [Qué queda por hacer]

## Relevant Files
- path/to/file — [qué hace o qué cambió]

¿Cuándo procede el agente a buscar en la memoria? 🕵️‍♂️

El acceso a la memoria ocurre de dos formas:

1. De forma reactiva (Explícita): Cuando le haces una pregunta directa, como: “¿Recuerdas cómo resolvimos X?”. Por ejemplo algunas preguntas que me han resultado especialmente útiles para mis Dailies son:
   • ¿En qué estuvimos trabajando ayer?
   • ¿Qué hicimos esta semana?
   • ¿Qué tenemos pendiente de implementar?
2. De forma proactiva (Implícita): El agente consultará las memorias por su cuenta si detecta que:
   • Empieza a trabajar en algo que podría haberse hecho/resuelto antes.
   • Se menciona un tema del cual el agente actual no tiene contexto en su ventana.

En estos casos, el agente busca en el historial de Engram para inyectar la información relevante en la sesión en curso.

Cómo instalarlo 💻

Si estás en macOS o Linux, puedes usar Homebrew directamente:

brew install gentleman-programming/tap/engram

En el caso de Windows, la documentación oficial recomienda instalarlo mediante Go:

go install github.com/Gentleman-Programming/engram/cmd/engram@latest
# El binario se guardará en %GOPATH%\bin\engram.exe (usualmente %USERPROFILE%\go\bin\)

Una vez instalado, debes configurarlo para tu agente de preferencia. Por ejemplo:

# Para OpenCode
engram setup opencode

# Para Claude Code
engram setup claude-code

(Esto instalará un plugin con todo lo necesario. Si usas otro agente, consulta los detalles en su repositorio de GitHub).

¡Y eso es todo! Al abrir tu agente, verás que se ha agregado la herramienta MCP de Engram. A partir de ahora, comenzará a generar memorias de tus sesiones divididas por proyecto (la carpeta donde estés ejecutando la terminal).

¿Cómo sincronizar Engram entre distintas computadoras? 🔄

Engram te permite exportar todas las memorias globales o aislar las de un proyecto en particular:

# Exportar absolutamente todas las memorias
engram sync --all

# Exportar las memorias de un proyecto específico
engram sync --project=nombre-del-proyecto

# Exportar las memorias de la carpeta de trabajo actual
engram sync

Esto generará una carpeta .engram/ con la memoria comprimida en chunks. Solo asegúrate de incluir esta carpeta en tu repositorio Git. Luego, para importar las memorias en otra máquina, simplemente clonas el repo y ejecutas:

engram sync --import

💡 Tip: Para verificar que se importaron correctamente, puedes ejecutar engram stats antes y después de importar para observar cómo aumentan tus métricas de memoria.

Para mis casos de uso, estos comandos CLI son más que suficientes. Pero si pretendes usar Engram con un equipo de trabajo grande, probablemente te interese Engram Cloud. La idea es montar un servidor de Engram self-hosted en un VPS usando Docker, lo que servirá como un cerebro centralizado para todo tu equipo.

BONUS: Interfaz Gráfica (TUI) 🎁

Engram incluye una TUI (Terminal User Interface) por si prefieres gestionar, buscar o eliminar tus memorias manualmente. Solo ejecuta:

engram tui

Verás una interfaz interactiva similar a esta:

Desde aquí podrás navegar por tus sesiones, explorar descubrimientos técnicos y configurar las integraciones de tus agentes.

Engram ha cambiado por completo mi flujo de trabajo ahora que realizo desarrollo agentico, permitiéndome optimizar mi consumo de tokens y también persistir información eficientemente. ¿Tú ya estás usando algún sistema de memoria para tus agentes? cuéntame tu opinión en los comentarios.

Y si te gusta descubrir herramientas y trucos para optimizar tu Developer Experience (como automatizar o limpiar procesos repetitivos), te invito a leer mi artículo Guía Práctica: Cómo Modificar una Dependencia de NPM con yarn patch.