Por qué Claude Code olvida entre sesiones y cómo hacemos que recuerde

Claude Code olvida el contexto entre sesiones porque cada sesión empieza con una ventana de contexto vacía. Dentro de una sesión, cuando la ventana se llena, se compacta: los turnos antiguos se convierten en un resumen. Entre una sesión y la siguiente no se conserva nada, salvo lo que quedó por escrito.

La memoria entre sesiones es una rutina que hace que un agente de programación con IA consulte las decisiones pasadas antes de trabajar y guarde las nuevas después, para que una ventana de contexto nueva empiece informada. La ejecutamos como un bucle en Claude Code, impuesto por un hook de Stop (un script que Claude Code ejecuta cada vez que termina de responder). OpenCode y Kimi Code comparten las mismas reglas y el mismo almacén.

Dentro de una sesión, los turnos antiguos se compactan; entre sesiones, la ventana nueva empieza vacía y solo cruzan las notas guardadas.

Por qué Claude Code olvida y qué hace nuestro bucle de memoria

Claude Code no olvida por accidente. Cada sesión empieza vacía por diseño, así que la solución es una rutina, no un archivo más grande.

La documentación de Anthropic(se abre en una pestaña nueva), 2026: «Cada sesión de Claude Code empieza con una ventana de contexto nueva». Dos funciones integradas dan a Claude Code memoria entre sesiones:

El contexto es algo que el agente sopesa, no un paso que esté obligado a dar. Por eso añadimos un bucle por encima, con un almacén compartido al que el agente llega por MCP:

El almacén es nuestro cerebro de empresa; cómo se clasifican las notas es la capa 1 de nuestro sistema que se mejora a sí mismo.

La versión lista para copiar (el hook, la entrada de configuración y la prueba) está en Crea tu propio bucle.

Por qué lo construimos: el agente se saltaba la regla escrita

Escribimos la regla y el agente se la saltó. Una regla que depende de que el agente se acuerde de cumplirla es una sugerencia.

La regla estaba en el archivo de instrucciones: consulta antes de explorar, guarda después. Las sesiones se saltaban la consulta y volvían a leer código que una sesión anterior ya había mapeado. Las sesiones editaban archivos y terminaban sin dejar nada escrito, así que la siguiente redescubría la misma respuesta.

La memoria existía y las herramientas funcionaban. Lo que faltaba era un momento en el que saltarse la regla tuviera un coste. Una persona aprueba el trabajo que importa (nuestro modelo de gobernanza), pero nadie vigila el final de cada sesión.

Descubre cómo ConvOps da a cada agente una sola memoria que consulta antes de trabajar(se abre en una pestaña nueva) y conserva las notas que deja cada sesión.

Cómo funciona el bucle de memoria

Consultar cuesta una llamada. Guardar cuesta una llamada. Lo único caro es conseguir que las dos cosas ocurran siempre, así que ese es el trabajo que le dimos al hook.

En cada parada comprobada, si hay ediciones y nada guardado, el agente vuelve a guardar; si no, la sesión termina.

Cómo decide un hook de Stop. Lee la transcripción (el archivo donde Claude Code registra cada mensaje y cada llamada a herramienta) y termina con un código de salida, un número que le dice a Claude Code qué hacer a continuación. La salida 0 deja que la sesión termine. La salida 2 «impide que Claude se detenga y continúa la conversación» (Anthropic, hooks(se abre en una pestaña nueva), 2026), y el agente lee el mensaje del hook. Nuestro guardián de borrados usa el mismo código de salida en las llamadas a herramientas.

Qué comprueba el hook de Stop que vigila la memoria

Cada umbral de esta sección es el que ejecuta nuestro hook.

Cada regla incumplida añade un mensaje, el bloqueo termina con «This is mandatory.» («Es obligatorio.») y el hook sale con 2.

Lo que el hook no ve

Confiamos más en el hook porque sabemos exactamente dónde está ciego.

• Cuenta las llamadas a herramientas por su nombre. Nunca lee qué devolvió una consulta ni si lo guardado valía algo.
• Solo memory_store cuenta como guardado. Una sesión que solo escribe notas context= y edita archivos también vuelve al trabajo.
• No ve las ediciones hechas desde la shell. Un sed o un heredoc no son una edición para el hook; solo lo son las cuatro herramientas de edición nativas.
• La transcripción puede ir con retraso. La documentación de hooks(se abre en una pestaña nueva) de Anthropic dice que se escribe de forma asíncrona, así que un guardado de último momento se cuenta en la siguiente comprobación.
• Solo funciona en Claude Code; consulta las secciones de OpenCode y Kimi Code.

Los hooks contienen las reglas que nunca deben depender de la memoria (la capa de hooks). Este obliga a hacer las llamadas, no a recordar.

Cómo recuerda Claude Code entre sesiones

El momento útil no es el guardado. Es la mañana siguiente, cuando una sesión que nunca vio el trabajo del lunes arranca con la lección del lunes.

Copperfern es una tienda online ficticia de artículos para el hogar; sus nombres, archivos y notas son inventados, y los umbrales y los mensajes son reales.

Lunes. Maya, que dirige las operaciones, abre una tarea: «Los pedidos de España salen con un céntimo de diferencia al pagar». El agente de programación ejecuta context_query("spanish vat checkout rounding") y no encuentra nada sobre el redondeo. Lee shop/checkout/tax.py, ve que el IVA se redondea una sola vez sobre el total del pedido, edita el archivo y su prueba para redondear por línea e intenta detenerse.

El hook se ejecuta: 5 llamadas a herramientas y suficientes entradas nuevas desde la última comprobación. Hubo una consulta, así que solo se activa la comprobación de ediciones:

KNOWLEDGE CHECK: Modified 2 file(s) but stored nothing. memory_store() the change/decision (supersede if updating). If you explored files, create_route()/update_route() in ConvOps. This is mandatory.

El mensaje viene a decir: has modificado 2 archivos y no has guardado nada; guarda el cambio o la decisión con memory_store() (si actualizas una nota, sustituye la anterior) y, si has explorado archivos, crea o actualiza una ruta en ConvOps. Es obligatorio.

Salida 2. El agente guarda una nota de tipo gotchas, con importancia 7 y las etiquetas shop, checkout, vat. La nota dice: «El IVA español se redondea por línea, no sobre el total del pedido; redondear el total desvía un céntimo en los pedidos con varios artículos». Registra una ruta: «El redondeo del IVA está en shop/checkout/tax.py». Vuelve a detenerse. stop_hook_active es true y la sesión termina.

La sesión del lunes corrige el redondeo, vuelve al trabajo una vez y guarda el porqué antes de terminar.

Martes. Una tarea nueva: «Añadir el IVA a la línea del envoltorio de regalo». Sesión nueva, ventana vacía: no hay nada del lunes en ella. El agente ejecuta context_query("vat gift wrap checkout") y recibe la nota del lunes y la ruta. Abre directamente shop/checkout/tax.py y redondea el IVA del envoltorio de regalo en su propia línea.

Resulta que el envío también es una línea aparte. El agente guarda la nota refinada, «El IVA español se redondea por línea; el envoltorio de regalo y el envío cuentan cada uno como una línea propia», y después olvida el registro del lunes con memory_forget, un borrado lógico reversible. En la parada, la consulta llegó antes que el guardado y la edición tiene su guardado: salida 0. Solo la nota refinada responde a la siguiente consulta.

La sesión del martes nunca vio el lunes y, aun así, su primera consulta devuelve la lección del lunes; guarda la nota refinada y olvida la antigua.

Lo que deja el bucle

Una memoria vale exactamente lo que la siguiente sesión puede usar sin preguntar: un hecho, su motivo, un tipo y una importancia honesta.

Un registro de memoria, tal como lo guarda el agente:

content:    Spanish VAT rounds per line, not per order total; rounding the
            total is off by a cent on multi-item orders.
category:   gotchas
importance: 7
tags:       shop, checkout, vat
task_id:    cf-131

El contenido recoge el hecho y su motivo. La importancia mide cuánto pierde la siguiente sesión si no ve la nota: la mayoría están entre 4 y 6, y esta es un 7 porque un total erróneo llega a los clientes. Entre dos y cinco etiquetas hacen que se pueda encontrar.

Una ruta indica dónde está algo:

title:       VAT rounding
description: VAT rounding lives in shop/checkout/tax.py
paths:       shop/checkout/tax.py, tests/test_tax.py

Una nota context= se escribe en la misma llamada que la actualización de una tarea y se guarda como una memoria vinculada a la tarea (importancia 4 por defecto; con menos de 40 caracteres no se guarda):

Rounded VAT per line, not per order; Spanish totals were a cent off on
multi-item orders.

Ningún campo sustituye un registro. El agente guarda la nota nueva y olvida la antigua. Una persona también puede sustituir una nota en la página del cerebro, que vincula el registro nuevo con el antiguo y saca el antiguo de las consultas.

Qué falla en un hook de memoria

Nuestro control falló dos veces, en direcciones opuestas: una vez dejó pasar ediciones en silencio y otra bloqueaba para siempre. Revisa las dos cosas en tu propio hook.

Dejaba pasar ediciones. La única comprobación de «no guardó nada» esperaba a que la sesión superara una longitud mínima. Una sesión corta de Copperfern edita la plantilla de la etiqueta de envío y termina limpiamente sin dejar nada escrito; la siguiente sesión repite la misma investigación. La regla que salió de ahí: las ediciones sin guardado se señalan en la siguiente comprobación, sin esa espera. El mínimo de 3 llamadas y el intervalo siguen aplicándose.

Bloqueaba para siempre. La comprobación de guardado antes de consulta comparaba el primer guardado con la primera consulta de toda la sesión. Una sesión guarda una nota antes de su primera consulta, después consulta correctamente y, aun así, vuelve al trabajo en cada parada hasta que se abandona. La regla que salió de ahí: cada comprobación mira solo lo ocurrido desde la anterior, así que un desliz temprano se señala en la comprobación que lo cubre, no en cada parada posterior.

El comentario de nuestro código explica por qué: «una marca que ningún comportamiento posterior puede satisfacer es un fastidio, no una protección». Esa regla tiene ahora una prueba que ejecuta el hook real con una transcripción sintética, un registro de sesión falso.

Antes de la corrección, un guardado temprano bloqueaba todas las paradas posteriores; ahora cada comprobación mira solo lo ocurrido desde la anterior, así que el desliz se señala en su propia ventana.

Acotamos la regla de consulta. Antes se aplicaba a cada mensaje. Ahora se aplica antes de explorar o de trabajar en algo que no se conoce ya; guardar después de cada acción sigue siendo obligatorio. Una sesión a la que se le pregunta «¿qué hora es en Madrid?» no hace ninguna consulta; una sesión a punto de leer el código del pago siempre la hace.

Crea tu propio bucle de memoria en Claude Code

Empieza por una regla que el hook pueda contar: si una sesión cambió archivos, deja escrito qué cambió y por qué antes de terminar.

Primero, conecta el almacén. Nosotros usamos ConvOps; un solo comando lo añade a Claude Code:

claude mcp add --transport http convops https://mcp.convops.app/

Después añade estas dos líneas a tu CLAUDE.md. Mantén ese archivo corto (qué recortar de un CLAUDE.md demasiado largo): el hook se encarga de imponer la regla y el archivo, del hábito.

Before exploring or working on anything you don't already know, query the memory store first. Known answers and chat skip the lookup.
After every action, store what you learned and why, with a type, an honest importance and two to five tags. To replace a note, store the new one, then forget the old one.

Esta versión reducida de nuestro hook (Claude Code 2.1.301) conserva la protección contra bucles, el mínimo de 3 llamadas, el intervalo, la comprobación de ediciones y la consulta en la primera comprobación. Guárdala como ~/.claude/hooks/memory-gate.py:

"""Stop hook: send the agent back when it edited files and stored nothing."""
import json, os, sys, tempfile

MIN_TOOL_CALLS = 3
INTERVAL = 2
EDIT_TOOLS = ("Edit", "Write", "MultiEdit", "NotebookEdit")

hook = json.load(sys.stdin)
if hook.get("stop_hook_active"):
    sys.exit(0)  # the retry after a block is not checked
names, entries = [], 0
with open(hook["transcript_path"]) as f:
    for line in f:
        entry = json.loads(line)
        if entry.get("type") != "assistant":
            continue
        entries += 1
        for block in entry.get("message", {}).get("content", []):
            if isinstance(block, dict) and block.get("type") == "tool_use":
                names.append(block["name"])

if len(names) < MIN_TOOL_CALLS:
    sys.exit(0)
counter = os.path.join(tempfile.gettempdir(), f"memory_gate_{hook['session_id']}")
last = int(open(counter).read()) if os.path.exists(counter) else 0
if entries - last < INTERVAL:
    sys.exit(0)
open(counter, "w").write(str(entries))
edits = sum(n in EDIT_TOOLS for n in names)
stores = sum("memory_store" in n for n in names)
lookups = sum("context_query" in n or "route_query" in n for n in names)
problems = []
if edits and not stores:
    problems.append(f"Modified {edits} file(s) but stored nothing. Store the change and why.")
if last == 0 and not lookups:
    problems.append("No lookup at the first check. Query the memory store first.")
if problems:
    print("KNOWLEDGE CHECK: " + " | ".join(problems) + " This is mandatory.", file=sys.stderr)
    sys.exit(2)

Regístralo en Stop dentro de .claude/settings.json:

{
  "hooks": {
    "Stop": [
      {
        "hooks": [
          { "type": "command", "command": "python3 ~/.claude/hooks/memory-gate.py", "timeout": 15 }
        ]
      }
    ]
  }
}

Pruébalo con una transcripción sintética antes de fiarte de él. Esta tiene una consulta y dos ediciones, así que el resultado esperado es la salida 2:

printf '%s\n' \
  '{"type":"assistant","message":{"content":[{"type":"tool_use","name":"context_query"}]}}' \
  '{"type":"assistant","message":{"content":[{"type":"tool_use","name":"Edit"}]}}' \
  '{"type":"assistant","message":{"content":[{"type":"tool_use","name":"Edit"}]}}' \
  > copperfern-test.jsonl
echo '{"session_id":"test-001","transcript_path":"copperfern-test.jsonl"}' \
  | python3 ~/.claude/hooks/memory-gate.py; echo "exit $?"

Usa un session_id nuevo en cada ejecución, porque el archivo contador recuerda la última comprobación. Después añade una línea con memory_store y el resultado esperado pasa a ser la salida 0.

Memoria entre sesiones en OpenCode

Las sesiones de OpenCode 1.18.31 también empiezan vacías. Les damos el mismo texto y el mismo almacén.

Nuestros archivos AGENTS.md son enlaces simbólicos a CLAUDE.md, así que OpenCode lee las mismas reglas de consulta y guardado (un solo archivo para los dos). Nuestro opencode.json apunta su bloque mcp al mismo almacén de ConvOps, así que una nota guardada desde Claude Code aparece en una consulta de OpenCode. No ejecutamos ningún hook de memoria en OpenCode. Admite plugins con los que montar uno (plugins(se abre en una pestaña nueva)); nuestro guardián de borrados muestra cómo se estructura.

Memoria entre sesiones en Kimi Code

Kimi Code 0.31.1 recibe el mismo texto y el mismo almacén. Lee el AGENTS.md enlazado y nuestro .kimi-code/mcp.json incluye el mismo servidor de ConvOps, así que sus consultas devuelven lo que guardaron Claude Code y OpenCode. No ejecutamos ningún hook de memoria en Kimi Code. Admite entradas [[hooks]] en su configuración de usuario (hooks de Kimi Code(se abre en una pestaña nueva)), y la guía del guardián de borrados muestra una.

Crea una cuenta gratuita de ConvOps y conecta Claude Code, OpenCode o Kimi Code a una sola memoria(se abre en una pestaña nueva) y después añade la regla de consulta, la regla de guardado y el hook de Stop.