Agent skill

Engram

by LeoYeAI in LeoYeAI/openclaw-master-skills

Sistema de memoria persistente para agentes IA. An agent skill from LeoYeAI/openclaw-master-skills.

Install Engram

skills CLI

$ npx skills add LeoYeAI/openclaw-master-skills --skill engram -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI

$ gh skill install LeoYeAI/openclaw-master-skills engram --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy

$ git clone --depth 1 https://github.com/LeoYeAI/openclaw-master-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/engramclaw .claude/skills/engram && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Paste into Claude Code

Install the "engram" agent skill from https://github.com/LeoYeAI/openclaw-master-skills/tree/main/skills/engramclaw into .claude/skills/engram/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "engram", then confirm the skill loads.

Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

$skill-installer

$skill-installer install https://github.com/LeoYeAI/openclaw-master-skills/tree/main/skills/engramclaw

Type this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.

skills CLI

$ npx skills add LeoYeAI/openclaw-master-skills --skill engram -a codex

Project install goes to .agents/skills/; add -g for ~/.codex/skills/.

GitHub CLI

$ gh skill install LeoYeAI/openclaw-master-skills engram --agent codex

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/LeoYeAI/openclaw-master-skills.git skills-src && mkdir -p .agents/skills && cp -r skills-src/skills/engramclaw .agents/skills/engram && rm -rf skills-src

Use ~/.agents/skills/ instead of .agents/skills for a personal install.

Codex skills documentation · loads skills from .agents/skills/

Paste into Codex

Install the "engram" agent skill from https://github.com/LeoYeAI/openclaw-master-skills/tree/main/skills/engramclaw into .agents/skills/engram/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "engram", then confirm the skill loads.

Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

skills CLI

$ npx skills add LeoYeAI/openclaw-master-skills --skill engram -a cursor

Project install goes to .agents/skills/; add -g for ~/.cursor/skills/.

GitHub CLI

$ gh skill install LeoYeAI/openclaw-master-skills engram --agent cursor

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/LeoYeAI/openclaw-master-skills.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/skills/engramclaw .cursor/skills/engram && rm -rf skills-src

Use ~/.cursor/skills/ instead of .cursor/skills for a personal install.

Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/

Paste into Cursor

Install the "engram" agent skill from https://github.com/LeoYeAI/openclaw-master-skills/tree/main/skills/engramclaw into .cursor/skills/engram/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "engram", then confirm the skill loads.

Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

gemini skills install

$ gemini skills install https://github.com/LeoYeAI/openclaw-master-skills.git --path skills/engramclaw

--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.

skills CLI

$ npx skills add LeoYeAI/openclaw-master-skills --skill engram -a gemini-cli

Project install goes to .agents/skills/; add -g for ~/.gemini/skills/.

GitHub CLI

$ gh skill install LeoYeAI/openclaw-master-skills engram --agent gemini-cli

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/LeoYeAI/openclaw-master-skills.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/skills/engramclaw .gemini/skills/engram && rm -rf skills-src

Use ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.

Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/

Paste into Gemini CLI

Install the "engram" agent skill from https://github.com/LeoYeAI/openclaw-master-skills/tree/main/skills/engramclaw into .gemini/skills/engram/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "engram", then confirm the skill loads.

Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

GitHub CLI

$ gh skill install LeoYeAI/openclaw-master-skills engram

Installs for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).

skills CLI

$ npx skills add LeoYeAI/openclaw-master-skills --skill engram -a github-copilot

Project install goes to .agents/skills/; add -g for ~/.copilot/skills/.

Manual copy

$ git clone --depth 1 https://github.com/LeoYeAI/openclaw-master-skills.git skills-src && mkdir -p .github/skills && cp -r skills-src/skills/engramclaw .github/skills/engram && rm -rf skills-src

Use ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.

GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/

Paste into GitHub Copilot

Install the "engram" agent skill from https://github.com/LeoYeAI/openclaw-master-skills/tree/main/skills/engramclaw into .github/skills/engram/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "engram", then confirm the skill loads.

GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

skills CLI

$ npx skills add LeoYeAI/openclaw-master-skills --skill engram -a opencode

OpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.

GitHub CLI

$ gh skill install LeoYeAI/openclaw-master-skills engram --agent opencode

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/LeoYeAI/openclaw-master-skills.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/skills/engramclaw .opencode/skills/engram && rm -rf skills-src

Use ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.

OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/

Paste into OpenCode

Install the "engram" agent skill from https://github.com/LeoYeAI/openclaw-master-skills/tree/main/skills/engramclaw into .opencode/skills/engram/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "engram", then confirm the skill loads.

OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

Facts

Skill name: engram
GitHub stars: 2.2k
Token cost: ~6.7k tokens
SKILL.md length: 1,246 words
Files: 4 (incl. references)
Skills in repo: 1,235
Repo updated: Jul 20, 2026
First seen: Oct 9, 2026
Licence: MIT

At a glance

Sistema de memoria persistente para agentes IA. An agent skill from LeoYeAI/openclaw-master-skills.

Works in 4 steps: Inicio de Sesión → Durante el Trabajo - Guarda Proactivamente → Fin de Sesión - Resumen Obligatorio → …
Tasks that involve Session handoff
SKILL.md covers ⚠️ IMPORTANTE: Mecanismo de…, ⚙️ Prerrequisitos, Setup (Conectar MCPorter con… and Conceptos Core, plus 6 more sections
Calls brew, npm and npx

What it does

Engram is an agent skill from LeoYeAI/openclaw-master-skills. Sistema de memoria persistente para agentes IA. Usa memsave después de bugfixes, decisiones, descubrimientos, cambios de config. Usa memsearch cuando el usuario menciona "remember"/"recordar" o al empezar trabajo que se solapa con sesiones previas. Usa memsessionsummary antes de terminar sesiones para preservar contexto.

Its SKILL.md is about 6.7k tokens, which your agent loads only when the skill is triggered. The skill folder holds 4 other files, including reference files (for example `README.md`, `_meta.json` and `references/tools.md`).

It sits in Agent Workflows, covering Session handoff. It works with Linux and macOS. The repository describes itself as: 🧠 Curated collection of 1209+ best OpenClaw skills — weekly updated by MyClaw.ai. The licence is MIT.

When your agent uses it

Tasks that involve Session handoff

Example prompts

“remember”
“recordar”
“/engram”

Requirements

Node.js

Workflow steps

4 steps, taken from the step headings in SKILL.md.

Inicio de Sesión
Durante el Trabajo - Guarda Proactivamente
Fin de Sesión - Resumen Obligatorio
Después de Compactación de Contexto

What it can do on your machine

Read from SKILL.md and the folder at commit e5199b5. It shows what the files ask for, not the result of running them.

Tool permissions
Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.
From allowed-tools in the SKILL.md frontmatter.
Runs code
Shell commands in SKILL.md call:
- brew
- npm
- npx
From the folder's file list and the shell code blocks in SKILL.md.
Network
Links to these hosts (documentation or services it may open):
- github.com
From URLs in SKILL.md, links to its own repository left out.
Credentials
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Engram loads about 6.7k tokens when it runs, and up to ~10k if it reads all its reference files. Until then it costs about 83 tokens; SKILL.md has 1,246 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it: ~83
When it runs · the whole SKILL.md, loaded when a task matches: ~6.7k
With references · SKILL.md plus every file in references/, read only if the agent opens them: ~10k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check: notes

The automated check noted patterns worth knowing about, such as sudo or a known installer.

NoteRuns commands with sudoSKILL.md:125

3. **macOS/Linux**: `chmod +x engram && sudo mv engram /usr/local/bin/`

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from LeoYeAI/openclaw-master-skills at commit e5199b5, republished under its MIT licence (© LeoYeAI). 1,246 words, ~6,671 tokens.

Download SKILL.mdSave it as .claude/skills/engram/SKILL.md (or your agent's skills folder). This skill also uses 3 other files; get the full folder from GitHub.

name: engram
description: Sistema de memoria persistente para agentes IA. Usa mem_save después de bugfixes, decisiones, descubrimientos, cambios de config. Usa mem_search cuando el usuario menciona "remember"/"recordar" o al empezar trabajo que se solapa con sesiones previas. Usa mem_session_summary antes de terminar sesiones para preservar contexto.
homepage: https://github.com/Gentleman-Programming/engram

Engram - Memoria Persistente para Agentes IA

Engram te da memoria persistente entre sesiones. Recuerdas bugfixes, decisiones de arquitectura, patrones y descubrimientos de conversaciones previas.

⚠️ IMPORTANTE: Mecanismo de Activación

NO es automático como cron job → Requiere decisión ACTIVA del agente.

✅ Cuándo el agente LLAMA a Engram:

Momento	Herramienta	Razón
INICIO de sesión	`mem_context`	Recuperar trabajo previo
Después de trabajo significativo	`mem_save`	Guardar descubrimientos
Usuario dice "recuerda"/"recordar"	`mem_search`	Buscar en memoria
Empezando trabajo similar	`mem_search`	Verificar si ya se hizo
FIN de sesión	`mem_session_summary`	Preservar contexto
Después de compactación de contexto	`mem_context`	Recuperar estado

❌ Cuándo el agente NO llama a Engram:

Cada mensaje del usuario (ruido)
Heartbeats (gasta tokens innecesariamente)
Crons en background (no es el propósito)
Tool calls triviales (no vale la pena guardarlo)

🤖 Decisión del Agente:

El agente evalúa el contexto y decide:

¿Fue trabajo significativo? → Guardar
¿Aprendí algo importante? → Guardar
¿Cambio de configuración crítico? → Guardar
¿Fue trivial? → No guardar

NO esperes a que te pidan guardar → Decide proactivamente.

⚙️ Prerrequisitos

Este skill requiere dos binarios instalados:

Herramienta	Propósito	Repositorio
MCPorter	Cliente MCP para ejecutar herramientas	steipete/mcporter
Engram	Backend de memoria persistente	Gentleman-Programming/engram

Instalar MCPorter

macOS / Linux (Homebrew):

bash

brew tap steipete/tap
brew install steipete/tap/mcporter

Todas las plataformas (npm):

bash

# Sin instalación (para probar)
npx mcporter --version

# Instalación global
npm install -g mcporter

Windows (binario):

Descargar mcporter-<version>.exe desde GitHub Releases
Renombrar a mcporter.exe
Agregar al PATH del sistema

Verificar:

bash

mcporter --version

Instalar Engram

macOS / Linux (Homebrew):

bash

brew install gentleman-programming/tap/engram

Todas las plataformas (binario):

Descargar desde GitHub Releases
Windows: Renombrar a engram.exe y agregar al PATH
macOS/Linux: chmod +x engram && sudo mv engram /usr/local/bin/

Verificar:

bash

engram version

Setup (Conectar MCPorter con Engram)

Una vez instalados ambos binarios, registrar Engram como servidor MCP:

bash

# Registrar servidor MCP de Engram
mcporter config add engram --stdio "engram mcp"

# Verificar conexión (debe mostrar 13 herramientas)
mcporter list engram

Resultado esperado:

engram - Sistema de memoria persistente para agentes IA
  13 tools · HTTP/stdio

Conceptos Core

Memoria curada por el agente: TÚ decides qué vale la pena recordar, no captura automática
Revelación progresiva: Search → Timeline → Full observation (eficiente en tokens)
Ciclo de vida de sesión: Contexto al inicio, guardados durante trabajo, resumen al final

🌐 Integración con Ecosistema OpenClaw

Ecosistema de Memoria Completo

┌──────────────────────────────────────┐
│      MEMORY.md (Estático/Permanente) │
│  - Info del usuario (no cambia)      │
│  - Reglas de seguridad (permanentes) │
│  - Directrices (permanentes)         │
└──────────────────────────────────────┘
              ↓ complementa
┌──────────────────────────────────────┐
│   memory/YYYY-MM-DD.md (Diario/Raw)  │
│  - Notas del día                     │
│  - Proyectos trabajados              │
│  - Contexto inmediato                │
│  - Se archiva automáticamente        │
└──────────────────────────────────────┘
              ↓ complementa
┌──────────────────────────────────────┐
│      Engram (Memoria Técnica)        │
│  - Bugfixes                          │
│  - Decisiones de código              │
│  - Patrones descubiertos             │
│  - Configuraciones técnicas          │
│  - Búsqueda rápida                   │
└──────────────────────────────────────┘
              ↓ complementa
┌──────────────────────────────────────┐
│  self-improving (Comportamiento)     │
│  - Correcciones del usuario          │
│  - Preferencias aprendidas           │
│  - Patrones de comportamiento        │
│  - Sistema HOT/WARM/COLD             │
└──────────────────────────────────────┘

Cuándo Usar Cada Sistema

Tipo de Información	Dónde Guardar	Por Qué
Info permanente del usuario	MEMORY.md	No cambia, referencia rápida
Notas del día	memory/YYYY-MM-DD.md	Contexto inmediato, raw
Bugfix técnico	Engram	Búsqueda rápida, técnico
Corrección del usuario	self-improving	Comportamiento futuro
Decisión de arquitectura	Engram	Técnico, referenciable
Preferencia de comunicación	MEMORY.md + self-improving	Ambos
Proyecto activo	memory/YYYY-MM-DD.md	Contexto inmediato
Patrón de código	Engram	Reutilizable

Relación con Heartbeats

❌ NO llamar Engram desde heartbeats → Gasta tokens innecesariamente.

✅ Heartbeats son para:

Chequeos proactivos (emails, calendario, etc.)
Tareas recurrentes
Notificaciones

✅ Engram es para:

Memoria entre sesiones
Contexto técnico
Búsqueda de trabajo previo

Relación con self-improving

Pueden solaparse en tipo "learning":

self-improving: Preferencias de comportamiento del usuario
Engram: Aprendizajes técnicos de código

Regla: Si es sobre cómo el usuario quiere que te comportes → self-improving. Si es técnico → Engram.

Cuándo Usar Cada Herramienta

Disparador	Herramienta	Propósito
Empezando trabajo en un proyecto	`mem_context`	Cargar contexto de sesión previa
Después de arreglar un bug	`mem_save`	Documentar qué/por qué/dónde/aprendido
Tomando decisión de arquitectura	`mem_save`	Registrar decisión + razonamiento
Descubriendo un patrón o gotcha	`mem_save`	Capturar para referencia futura
Usuario dice "remember"/"recordar"	`mem_search`	Encontrar memorias relevantes
Empezando trabajo que se solapa	`mem_search`	Verificar si ya se hizo antes
Terminando una sesión	`mem_session_summary`	Preservar contexto de sesión
Después de compactación de contexto	`mem_context`	Recuperar estado de sesión

Referencia de Herramientas (via MCPorter)

Todas las herramientas se llaman via MCPorter:

bash

mcporter call engram.<nombre_herramienta> [parámetros]

Parámetro default: Si no especificas project, Engram intenta detectar el directorio actual del proyecto. Si no puede, usa default.

Herramientas Core

mem_save - Guardar una observación

Requerido: title, content Opcional: type, project, scope, topic_key

bash

# Ejemplo - Bugfix
mcporter call engram.mem_save \
  title="Error N+1 en lista de usuarios" \
  type="bugfix" \
  project="mi-proyecto" \
  content='**Qué**: Agregué eager loading en query UserList
**Por qué**: Degradación de rendimiento con 100+ usuarios
**Dónde**: src/services/users.ts
**Aprendido**: ORM requiere Preload() explícito para asociaciones'

# Ejemplo - Decisión de arquitectura
mcporter call engram.mem_save \
  title="Sistema de backups automatizado" \
  type="config" \
  project="mi-proyecto" \
  content='**Qué**: Cron de backups diarios configurado
**Por qué**: Evitar pérdida de datos críticos
**Dónde**: scripts/backup.sh, crontab
**Aprendido**: Verificar permisos antes de automatizar'

# Ejemplo - Patrón descubierto
mcporter call engram.mem_save \
  title="Patrón: Validar inputs en boundary" \
  type="discovery" \
  project="mi-proyecto" \
  content='**Qué**: Validar inputs en capa HTTP, no en services
**Por qué**: Evita contaminar lógica de negocio
**Dónde**: src/routes/*.ts
**Aprendido**: Early validation reduce cognitive load'

Tipos: decision, bugfix, pattern, config, discovery, learning, architecture

Formato de contenido (recomendado):

**Qué**: [descripción concisa]
**Por qué**: [razonamiento/contexto]
**Dónde**: [archivos afectados: ruta/al/archivo.ts, otro.go]
**Aprendido**: [gotchas, edge cases - opcional]

mem_search - Búsqueda de texto completo

bash

# Búsqueda básica
mcporter call engram.mem_search query="middleware auth"

# Filtrada por proyecto
mcporter call engram.mem_search query="N+1" project="mi-proyecto"

# Filtrada por tipo
mcporter call engram.mem_search query="error" type="bugfix"

# Limitar resultados
mcporter call engram.mem_search query="JWT" limit=5

Retorna resultados compactos con IDs de observación para drill-down.

mem_context - Obtener contexto de sesión reciente

bash

# Obtener contexto reciente del proyecto
mcporter call engram.mem_context project="mi-proyecto"

# Más observaciones
mcporter call engram.mem_context project="mi-proyecto" limit=30

# Scope personal
mcporter call engram.mem_context scope="personal"

Llama esto al INICIO de una sesión para recuperar lo que pasó antes.

mem_session_summary - Guardar resumen de fin de sesión

Requerido: content, project

bash

mcporter call engram.mem_session_summary \
  project="mi-proyecto" \
  content='## Objetivo
Implementar autenticación JWT y corregir bugs de rendimiento

## Instrucciones
El usuario prefiere español para explicaciones

## Descubrimientos
- ORM requiere Preload() explícito para associations
- Validación debe ir en boundary layer
- Refresh tokens deben rotarse por seguridad

## Logrado
- ✅ JWT implementado con refresh tokens
- ✅ Query N+1 corregido (100x más rápido)
- ✅ Middlewares de autenticación agregados
- 🔲 Tests de integración pendientes
- 🔲 Documentación API pendiente

## Archivos Relevantes
- src/auth/jwt.ts — Generación y validación de tokens
- src/middleware/auth.ts — Middleware de autenticación
- src/services/users.ts — Queries optimizadas
- src/routes/*.ts — Validación de inputs en boundary'

Formato de contenido requerido:

## Objetivo
[Una frase: qué se construyó/trabajó en esta sesión]

## Instrucciones
[Preferencias de usuario descubiertas - opcional]

## Descubrimientos
- [Hallazgo técnico 1]
- [Hallazgo técnico 2]

## Logrado
- ✅ [Tarea completada 1 — con detalles clave]
- ✅ [Tarea completada 2 — mencionar archivos cambiados]
- 🔲 [Identificado pero no hecho — para próxima sesión]

## Archivos Relevantes
- ruta/al/archivo.ts — [qué hace o qué cambió]
- ruta/a/otro.go — [rol en la arquitectura]

Herramientas Secundarias

mem_timeline - Contexto cronológico

bash

mcporter call engram.mem_timeline observation_id=42 before=5 after=5

Muestra qué pasó antes y después de una observación específica.

mem_get_observation - Obtener contenido completo

bash

mcporter call engram.mem_get_observation id=42

Retorna contenido sin truncar de una observación específica.

mem_update - Actualizar observación existente

bash

mcporter call engram.mem_update id=42 content="Contenido actualizado..."
mcporter call engram.mem_update id=42 title="Nuevo título"

mem_delete - Eliminar observación

bash

mcporter call engram.mem_delete id=42
mcporter call engram.mem_delete id=42 hard_delete=true

Por defecto es soft-delete (puede recuperarse).

mem_suggest_topic_key - Obtener topic key estable

bash

mcporter call engram.mem_suggest_topic_key type="architecture" title="Auth architecture"
# Retorna: architecture/auth-architecture

Úsalo para temas que evolucionan (mismo topic_key = actualiza observación existente).

mem_save_prompt - Guardar prompt del usuario

bash

mcporter call engram.mem_save_prompt content="Usuario pidió implementar OAuth" project="mi-proyecto"

mem_session_start / mem_session_end - Ciclo de vida de sesión

bash

mcporter call engram.mem_session_start id="session-123" project="mi-proyecto"
mcporter call engram.mem_session_end id="session-123" summary="Completada implementación auth"

mem_stats - Estadísticas de memoria

bash

mcporter call engram.mem_stats

🔄 Protocolo de Memoria

1. Inicio de Sesión

SIEMPRE llama mem_context al inicio de una sesión para recuperar contexto previo.

2. Durante el Trabajo - Guarda Proactivamente

Guarda memorias DESPUÉS de completar trabajo significativo. NO esperes a que te lo pidan.

Guarda cuando:

Arreglaste un bug → type: "bugfix"
Tomaste decisión de arquitectura → type: "decision" o type: "architecture"
Descubriste un patrón o gotcha → type: "discovery" o type: "pattern"
Cambiaste configuración → type: "config"
Aprendiste algo no obvio → type: "learning"

NO guardes:

Cada tool call (ruido)
Cambios triviales
Información fácil de encontrar en código

Show full SKILL.md (474 more words)Show less

3. Fin de Sesión - Resumen Obligatorio

ANTES de terminar una sesión, SIEMPRE llama mem_session_summary.
Esto NO es opcional. Si lo saltas, la próxima sesión empieza a ciegas.

4. Después de Compactación de Contexto

Si el contexto se compacta/resetea, INMEDIATAMENTE llama mem_context para recuperar estado.
Luego llama mem_session_summary con el contenido compactado antes de continuar.

📊 Métricas de Uso Saludable

Rango Ideal por Sesión

Herramienta	Frecuencia Ideal	Motivo
`mem_context`	1x (inicio sesión)	Recuperar contexto
`mem_save`	2-5x (después trabajo significativo)	Guardar descubrimientos
`mem_search`	0-3x (cuando se necesita)	Verificar trabajo previo
`mem_session_summary`	1x (fin sesión)	Preservar contexto

Alertas de Uso Excesivo

>10 mem_save por sesión → Guardando demasiado ruido
0 mem_save en 5 sesiones → Probablemente olvidando cosas importantes
>50 observaciones en 1 semana → Considerar limpieza

Proporción Saludable de Tipos

Tipo	Proporción Ideal	Motivo
`bugfix`	20-30%	Errores comunes
`discovery`	20-30%	Aprendizajes clave
`decision`	15-25%	Decisiones importantes
`pattern`	10-20%	Patrones reutilizables
`config`	10-15%	Cambios de configuración
`architecture`	5-10%	Decisiones estructurales

🚫 Anti-Patrones (Qué NO Hacer)

❌ NO Guardar Todo

bash

# MAL: Guardar trivialidades
mcporter call engram.mem_save title="Usuario dijo hola" content="Usuario dijo hola"

# BIEN: Solo trabajo significativo
mcporter call engram.mem_save \
  title="Error N+1 corregido" \
  type="bugfix" \
  content='**Qué**: Agregué eager loading...'

❌ NO Usar como Sistema de Logging

bash

# MAL: Guardar cada tool call
mcporter call engram.mem_save title="Llamé read tool" content="Leí archivo X"

# BIEN: Guardar descubrimientos
mcporter call engram.mem_save \
  title="Problema de seguridad encontrado" \
  type="discovery" \
  content='**Qué**: SQL injection en login...'

❌ NO Duplicar Información de MEMORY.md

bash

# MAL: Duplicar info del usuario
mcporter call engram.mem_save title="Info del usuario" content="CEO de empresa..."

# BIEN: MEMORY.md ya tiene eso, Engram es para cosas TÉCNICAS
# Solo guardar si es contexto técnico específico de una sesión

❌ NO Llamar desde Heartbeats

bash

# MAL: Gasta tokens innecesariamente
# En heartbeat cron:
mcporter call engram.mem_context  # ← NO

# BIEN: Solo en sesión interactiva
# Heartbeats son para chequeos proactivos, no memoria

❌ NO Guardar Información Sensible sin Redacción

bash

# MAL: API key expuesta
mcporter call engram.mem_save title="Config API" content="Key: sk-abc123..."

# BIEN: Usar tags <private>
mcporter call engram.mem_save \
  title="Config API" \
  content='API key: <private>sk-abc123</private>'
# → API key: [REDACTED]

🔧 Troubleshooting

Error: "mcporter: command not found"

Verificar instalación:

bash

# macOS / Linux
which mcporter

# Windows (PowerShell)
where.exe mcporter

Solución:

Plataforma	Comando
macOS/Linux (Homebrew)	`brew install steipete/tap/mcporter`
Todas (npm)	`npm install -g mcporter`
Windows (binario)	Descargar de GitHub Releases

Error: "engram: command not found"

Verificar instalación:

bash

# macOS / Linux
which engram

# Windows (PowerShell)
where.exe engram

Solución:

Plataforma	Comando
macOS/Linux (Homebrew)	`brew install gentleman-programming/tap/engram`
Windows (binario)	Descargar de GitHub Releases

Verificar versión:

bash

engram version

Error: "No MCP servers configured" o "server 'engram' not found"

MCPorter está instalado pero Engram no está registrado.

Solución:

bash

# Registrar Engram como servidor MCP
mcporter config add engram --stdio "engram mcp"

# Verificar
mcporter list engram

Error: "MCPorter not configured"

Verificar registro:

bash

mcporter list engram

Si falla, registrar nuevamente:

bash

mcporter config add engram --stdio "engram mcp"

# Verificar tools disponibles (deben ser 13)
mcporter list engram

Error: "No previous session memories found"

No es error → Es normal la primera vez que se usa.

Solución: Empezar a usar el sistema:

bash

mcporter call engram.mem_save title="Primera observación" content="..."
mcporter call engram.mem_session_summary project="mi-proyecto" content="..."

Memoria Muy Grande (>1000 observaciones)

bash

# Ver estadísticas
mcporter call engram.mem_stats

# Buscar observaciones viejas
mcporter call engram.mem_search query="..." limit=20

# Limpiar observaciones específicas
mcporter call engram.mem_delete id=XX hard_delete=true

# Recomendación: Mantener <500 observaciones activas

Búsqueda No Encuentra Resultados

Posibles causas:

Typo en query → Verificar ortografía
Muy específico → Usar términos más generales
No existe → Guardar la información primero
Filtro incorrecto → Verificar project, type, scope

bash

# Debug: Búsqueda amplia
mcporter call engram.mem_search query="auth" limit=10

# Debug: Ver todo el proyecto
mcporter call engram.mem_context project="mi-proyecto" limit=50

Error: "Content too long"

Solución: Usar comillas simples para contenido multilínea:

bash

# MAL (falla con newlines)
mcporter call engram.mem_save title="..." content="Línea 1
Línea 2"

# BIEN (comillas simples)
mcporter call engram.mem_save title="..." content='Línea 1
Línea 2
Línea 3'

📝 Ejemplo: Flujo Completo de Sesión Real

Escenario: Usuario pide implementar autenticación

bash

# ═══════════════════════════════════════════════════════
# 1. INICIO DE SESIÓN - Recuperar contexto previo
# ═══════════════════════════════════════════════════════
mcporter call engram.mem_context project="mi-proyecto"
# → Veo que ayer trabajamos en el módulo de usuarios
# → Veo que se identificó un problema de seguridad
# → Sé que falta implementar JWT

# ═══════════════════════════════════════════════════════
# 2. TRABAJO - Después de implementar JWT
# ═══════════════════════════════════════════════════════
mcporter call engram.mem_save \
  title="JWT implementado correctamente" \
  type="config" \
  project="mi-proyecto" \
  content='**Qué**: Autenticación JWT agregada al API
**Por qué**: Sessions no escalan en múltiples instancias
**Dónde**: src/auth/jwt.ts, src/middleware/auth.ts
**Aprendido**: Refresh tokens deben rotarse'

# ═══════════════════════════════════════════════════════
# 3. TRABAJO - Después de corregir bug de N+1
# ═══════════════════════════════════════════════════════
mcporter call engram.mem_save \
  title="Query N+1 corregido en lista de usuarios" \
  type="bugfix" \
  project="mi-proyecto" \
  content='**Qué**: Agregué eager loading en UserList
**Por qué**: Degradación de rendimiento con 100+ usuarios
**Dónde**: src/services/users.ts
**Aprendido**: ORM requiere Preload() explícito'

# ═══════════════════════════════════════════════════════
# 4. TRABAJO - Después de descubrir patrón
# ═══════════════════════════════════════════════════════
mcporter call engram.mem_save \
  title="Patrón: Validar inputs en boundary" \
  type="pattern" \
  project="mi-proyecto" \
  content='**Qué**: Validar inputs en capa HTTP, no en services
**Por qué**: Evita contaminar lógica de negocio
**Dónde**: src/routes/*.ts
**Aprendido**: Early validation reduce cognitive load'

# ═══════════════════════════════════════════════════════
# 5. FIN DE SESIÓN - Guardar resumen completo
# ═══════════════════════════════════════════════════════
mcporter call engram.mem_session_summary \
  project="mi-proyecto" \
  content='## Objetivo
Implementar autenticación JWT y corregir bugs de rendimiento

## Instrucciones
El usuario prefiere español para explicaciones

## Descubrimientos
- ORM requiere Preload() explícito para associations
- Validación debe ir en boundary layer
- Refresh tokens deben rotarse por seguridad

## Logrado
- ✅ JWT implementado con refresh tokens
- ✅ Query N+1 corregido (100x más rápido)
- ✅ Middlewares de autenticación agregados
- 🔲 Tests de integración pendientes
- 🔲 Documentación API pendiente

## Archivos Relevantes
- src/auth/jwt.ts — Generación y validación de tokens
- src/middleware/auth.ts — Middleware de autenticación
- src/services/users.ts — Queries optimizadas
- src/routes/*.ts — Validación de inputs en boundary'

Próxima sesión: mem_context recuperará automáticamente todo este contexto.

🔄 Patrón de Revelación Progresiva

Recuperación de memoria eficiente en tokens:

1. mem_search "auth middleware" → resultados compactos con IDs (~100 tokens c/u)
2. mem_timeline observation_id=42 → qué pasó antes/después
3. mem_get_observation id=42 → contenido completo sin truncar

No descargues todo. Profundiza cuando lo necesites.

🔑 Topic Keys (Temas que Evolucionan)

Para temas que evolucionan en el tiempo (decisiones de arquitectura, features de larga duración):

bash

# Obtener topic key estable
mcporter call engram.mem_suggest_topic_key type="architecture" title="Auth architecture"
# → architecture/auth-architecture

# Guardar con topic_key (hace upsert a observación existente)
mcporter call engram.mem_save \
  title="Decisión arquitectura auth" \
  type="architecture" \
  topic_key="architecture/auth-architecture" \
  project="mi-proyecto" \
  content="..."

Mismo topic_key + project + scope = actualiza observación existente en lugar de crear nueva.

Familias de Topic Keys

architecture/* — Arquitectura, diseño, ADR-like changes
bug/* — Fixes, regresiones, errores, panics
decision/* — Decisiones de proyecto
pattern/* — Patrones reutilizables
config/* — Cambios de configuración
discovery/* — Descubrimientos
learning/* — Aprendizajes

🔐 Privacidad

Envuelve contenido sensible en tags <private> - se eliminan antes de guardar:

API key: <private>sk-abc123</private>
→ API key: [REDACTED]

📁 Ubicación de Datos

Plataforma	Ruta
macOS / Linux	`~/.engram/engram.db`
Windows	`%USERPROFILE%\.engram\engram.db`

Override: Set ENGRAM_DATA_DIR environment variable para cambiar la ubicación.

📖 Referencia Rápida

bash

# Iniciar sesión
mcporter call engram.mem_context project="mi-proyecto"

# Guardar bugfix
mcporter call engram.mem_save title="..." type="bugfix" content='...'

# Buscar
mcporter call engram.mem_search query="..."

# Terminar sesión
mcporter call engram.mem_session_summary project="mi-proyecto" content='...'

# Ver estadísticas
mcporter call engram.mem_stats

📚 Referencia Completa de Herramientas

Ver references/tools.md para documentación completa de las 13 herramientas MCP.

🚀 Sinergia Proactiva

Engram puede alimentar proactividad del agente:

Patrón de Uso

Engram: Almacena patrones de comportamiento del usuario
Proactive-agent: Usa esos patrones para anticipar necesidades
Feedback loop: Nuevas observaciones mejoran proactividad

Ejemplo Concreto

bash

# Después de 3 sesiones donde el usuario pide lo mismo:
mcporter call engram.mem_save \
  title="Patrón: Usuario pide status al iniciar sesión" \
  type="pattern" \
  project="mi-proyecto" \
  content='**Qué**: Al iniciar sesión pregunta "qué hay pendiente"
**Por qué**: Quiere overview antes de empezar a trabajar
**Dónde**: Sesiones consecutivas
**Aprendido**: Preparar resumen automático al inicio'

# Proactive-agent puede usar esto:
# → Generar resumen de pendientes al inicio de sesión

Versión del skill: 1.0

Files

SKILL.md and 3 other files (references) in skills/engramclaw of LeoYeAI/openclaw-master-skills.

SKILL.md
README.md
_meta.json
references/tools.md

Open the folder on GitHubat commit e5199b5

Compare with similar skills

Engram next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Engram compared with similar skills
Skill	Stars	Used in	Tokens	Auto-check	Licence	Repo updated
Engram this skillLeoYeAI/openclaw-master-skills	2.2k	—	~6.7k	Automated safety check: Notes	MIT	2 mo ago
Cortex Mem MCPsopaco/cortex-mem	313	—	~2.8k	Automated safety check: Pass	MIT	2 mo ago
Mps Project ManagementJetBrains/MPS	1.7k	—	~2.2k	Automated safety check: Pass	Apache-2.0	today
Crossreviewcoddy-project/coddy-agent	167	—	~3.3k	Automated safety check: Pass	MIT	today
Gearcoleco Romhackingdrhelius/Gearcoleco	142	—	~3.9k	Automated safety check: Pass	GPL-3.0	2 days ago
Recalltermdock/termdock-issues	156	—	~675	Automated safety check: Notes	None	5 days ago

Similar skills

Cortex Mem MCP
sopaco/cortex-mem
Persistent memory enhancement for AI agents. An agent skill from sopaco/cortex-mem.
313 GitHub stars~2.8k tokensUpdated 2 mo ago
Agent WorkflowsAuto-check passed
Mps Project Management
JetBrains/MPS
Official
Open an MPS project in a running or freshly started MPS instance when MCP tools fail because no project is open (welcome screen), close an open project with mpsmcpcloseproject, or create a new empty…
1.7k GitHub stars~2.2k tokensUpdated today
Agent WorkflowsAuto-check passed
Crossreview
coddy-project/coddy-agent
Run when the user invokes /crossreview (or /crossreview:setup to choose the reviewers) or asks for a cross-review, a quorum review or a second opinion from other agents or models: fan a code review…
167 GitHub stars~3.3k tokensUpdated today
Agent WorkflowsAuto-check passed
Gearcoleco Romhacking
drhelius/Gearcoleco
Hack, modify, and translate ColecoVision and Super Game Module ROMs using the Gearcoleco emulator MCP server.
142 GitHub stars~3.9k tokensUpdated 2 days ago
Agent WorkflowsAuto-check passed
Recall
termdock/termdock-issues
Retrieves cross-session memories about past decisions, lessons, and patterns.
156 GitHub stars~675 tokensUpdated 5 days ago
Agent WorkflowsAuto-check: notes
AI Memory Obsidian
kipperacademy/skillpper
Portable workflows for persistent memory and Obsidian across macOS, Linux, and Windows.
144 GitHub stars~1.4k tokensUpdated 2 days ago
Agent WorkflowsAuto-check: notes

Questions about Engram

What does Engram do?

Sistema de memoria persistente para agentes IA. An agent skill from LeoYeAI/openclaw-master-skills. Engram is an agent skill from LeoYeAI/openclaw-master-skills. Sistema de memoria persistente para agentes IA.

When should I use Engram?

Engram fits situations like: tasks that involve Session handoff.

How do I install Engram in Claude Code?

Run `npx skills add LeoYeAI/openclaw-master-skills --skill engram -a claude-code`. Or copy the skill folder (skills/engramclaw in LeoYeAI/openclaw-master-skills) into .claude/skills/engram in your project. Claude Code loads it when a task matches its description.

How do I install Engram in Codex?

Run `npx skills add LeoYeAI/openclaw-master-skills --skill engram -a codex`. Or copy the skill folder (skills/engramclaw in LeoYeAI/openclaw-master-skills) into .agents/skills/engram in your project. Codex loads it when a task matches its description.

Can I use Engram in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add LeoYeAI/openclaw-master-skills --skill engram -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/engram, .gemini/skills/engram, .github/skills/engram and .opencode/skills/engram in your project.

What does Engram need to run?

Going by SKILL.md and its folder, Engram needs the command-line tools its instructions call (brew, npm and npx). Our summary lists: Node.js.

Does Engram access the network?

SKILL.md names 1 domain. As links in the text: github.com. This is read from the text; nothing was executed.

Is Engram safe to install?

Our automated static check of SKILL.md found notes only (runs commands with sudo), nothing it rates as a warning. It is not a guarantee. Review the folder before installing.

What licence does Engram use?

Engram is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Engram use?

About 6.7k tokens (SKILL.md is roughly 27k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 3.7k tokens, read only when the agent opens those files.

What are the alternatives to Engram?

Skills that share tags, products or a category with Engram: Cortex Mem MCP (sopaco/cortex-mem, 313 stars), Mps Project Management (JetBrains/MPS, 1.7k stars), Crossreview (coddy-project/coddy-agent, 167 stars) and Gearcoleco Romhacking (drhelius/Gearcoleco, 142 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Engram?

LeoYeAI (a GitHub user) maintains it in LeoYeAI/openclaw-master-skills, which has 2,160 GitHub stars. The repository holds 1,235 skills in this directory. The repository was last updated on July 20, 2026.

Source: LeoYeAI/openclaw-master-skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.

Install Engram

Facts

At a glance

What it does

When your agent uses it

Example prompts

Requirements

Workflow steps

What it can do on your machine

Tool permissions

Runs code

Network

Credentials

Context cost

Safety

SKILL.md

Engram - Memoria Persistente para Agentes IA

⚠️ IMPORTANTE: Mecanismo de Activación

✅ Cuándo el agente LLAMA a Engram:

❌ Cuándo el agente NO llama a Engram:

🤖 Decisión del Agente:

⚙️ Prerrequisitos

Instalar MCPorter

Instalar Engram

Setup (Conectar MCPorter con Engram)

Conceptos Core

🌐 Integración con Ecosistema OpenClaw

Ecosistema de Memoria Completo

Cuándo Usar Cada Sistema

Relación con Heartbeats

Relación con self-improving

Cuándo Usar Cada Herramienta

Referencia de Herramientas (via MCPorter)

Herramientas Core

mem_save - Guardar una observación

mem_search - Búsqueda de texto completo

mem_context - Obtener contexto de sesión reciente

mem_session_summary - Guardar resumen de fin de sesión

Herramientas Secundarias

mem_timeline - Contexto cronológico

mem_get_observation - Obtener contenido completo

mem_update - Actualizar observación existente

mem_delete - Eliminar observación

mem_suggest_topic_key - Obtener topic key estable

mem_save_prompt - Guardar prompt del usuario

mem_session_start / mem_session_end - Ciclo de vida de sesión

mem_stats - Estadísticas de memoria

🔄 Protocolo de Memoria

1. Inicio de Sesión

2. Durante el Trabajo - Guarda Proactivamente

3. Fin de Sesión - Resumen Obligatorio

4. Después de Compactación de Contexto

📊 Métricas de Uso Saludable

Rango Ideal por Sesión

Alertas de Uso Excesivo

Proporción Saludable de Tipos

🚫 Anti-Patrones (Qué NO Hacer)

❌ NO Guardar Todo

❌ NO Usar como Sistema de Logging

❌ NO Duplicar Información de MEMORY.md

❌ NO Llamar desde Heartbeats

❌ NO Guardar Información Sensible sin Redacción

🔧 Troubleshooting

Error: "mcporter: command not found"

Error: "engram: command not found"

Error: "No MCP servers configured" o "server 'engram' not found"

Error: "MCPorter not configured"

Error: "No previous session memories found"

Memoria Muy Grande (>1000 observaciones)

Búsqueda No Encuentra Resultados

Error: "Content too long"

📝 Ejemplo: Flujo Completo de Sesión Real

Escenario: Usuario pide implementar autenticación

🔄 Patrón de Revelación Progresiva

🔑 Topic Keys (Temas que Evolucionan)

Familias de Topic Keys

🔐 Privacidad

📁 Ubicación de Datos

📖 Referencia Rápida

📚 Referencia Completa de Herramientas