Memoria en agentes de IA: qué recuerdan entre sesiones y qué no

La memoria de un agente de IA son las notas que sobreviven a una sesión: instrucciones escritas, notas automáticas y bases externas. Cómo funciona cada una.

info Definición Rápida

Memoria en un agente de IA es la información que sobrevive a una sesión y que el agente vuelve a leer al empezar otra. Como el modelo no conserva nada entre conversaciones, la memoria vive fuera de él: en archivos, en una base de datos o en un historial que se vuelve a cargar en la ventana de contexto.

¿Por qué un agente no recuerda por sí mismo?

Un modelo de lenguaje no aprende mientras conversas con él. Lo que sabe en una sesión es lo que tiene en su ventana de contexto: instrucciones, historial, resultados de herramientas. Cuando la sesión termina, esa ventana desaparece. La siguiente sesión empieza en blanco.

Por eso la memoria es un problema de diseño, no de magia. Forma parte de lo que se llama context engineering. Alguien tiene que decidir qué se guarda, dónde, quién lo escribe y cómo se vuelve a cargar. Si nadie lo decide, el agente vuelve a preguntar lo mismo, repite errores que ya corregiste y olvida las convenciones del proyecto.

¿Qué tipos de memoria existen?

En la práctica aparecen tres formas, con responsables distintos:

Tipo	Quién lo escribe	Qué contiene	Ejemplo
Instrucciones permanentes	Una persona	Reglas y convenciones	Un archivo CLAUDE.md con los comandos del proyecto
Memoria automática	El agente	Aprendizajes de correcciones	“En este repo, los tests van con pnpm test”
Memoria externa	Herramientas o procesos	Datos consultables	Una base de datos de decisiones o un índice vectorial

Las dos primeras son archivos que la herramienta carga al empezar. La tercera suele consultarse solo cuando hace falta, para no llenar la ventana de contexto. Anthropic ofrece para esto la herramienta de memoria de su API: Claude pide crear, leer, editar o borrar archivos dentro de un directorio /memories y tu aplicación los ejecuta en un almacenamiento que controlas tú. Así el agente lee solo lo que necesita en cada tarea, en lugar de cargarlo todo desde el inicio.

¿Cómo funciona la memoria automática?

Claude Code tiene dos mecanismos. El primero es CLAUDE.md, instrucciones que escribe una persona. El segundo es la memoria automática: notas que Claude escribe por sí mismo a partir de tus correcciones y preferencias. Según su documentación, las dos “are loaded at the start of every conversation” y Claude “treats them as context, not enforced configuration”.

La memoria automática es por repositorio y se comparte entre worktrees. Vive en tu máquina, en una carpeta con un índice MEMORY.md y un archivo por tema, y no se comparte con otras máquinas. Al empezar una sesión solo se cargan las primeras 200 líneas o 25 KB del índice, lo que ocurra primero; lo que pase de ese límite no se lee. Puedes ver, editar o borrar esas notas con el comando /memory: son archivos markdown normales.

Los subagentes tienen su propio caso. No heredan la memoria automática de la conversación principal, pero se les puede dar una memoria persistente propia con el campo memory de su configuración.

¿Por qué le importa a un diseñador?

Porque la memoria define qué tan rápido aprende un equipo con un agente. Un diseñador que trabaja con agentes puede dejar por escrito decisiones que antes vivían en la cabeza de alguien:

Qué componentes del sistema de diseño se deben usar y cuáles están obsoletos.
Qué significa “listo” para un cambio de interfaz.
Qué textos o tonos se deben respetar en el microcopy.
Qué pantallas o carpetas no se tocan sin revisión.

Esa información es la que evita que el agente invente colores o duplique botones en cada sesión.

¿Cómo se diseña una memoria que sirva?

Algunas reglas prácticas:

Separa hechos de notas. Lo que siempre es cierto (comandos, convenciones) va en instrucciones. Lo que se aprende con el tiempo va en memoria automática o en un registro revisable.
Sé breve. Cuanto más corto y concreto es el texto, más probable que se cumpla. Un archivo que crece sin control termina siendo ruido.
Pon lo crítico arriba. Si el agente solo alcanza a leer las primeras líneas, lo que importa debe estar ahí.
Revisa la memoria. Una nota automática puede estar equivocada. Léela como si fuera código de otra persona.
Usa controles técnicos para lo innegociable. Un hook que bloquee el borrado de carpetas protegidas funciona mejor que una frase en la memoria.

Ejemplo

Ejemplo ilustrativo: un equipo de producto usa un agente para mantener su sistema de componentes. En la primera semana, el agente crea un botón nuevo cada vez que lo necesita. El equipo escribe en el archivo de instrucciones que el componente Button del sistema es el único permitido, y añade una regla: “si necesitas un variante nuevo, propónlo en un issue antes de crearlo”. En la siguiente semana, el agente deja de duplicar botones. Cuando comete un error nuevo, el equipo lo corrige en el mismo archivo, no en el chat, para que la siguiente sesión lo tenga.

¿Qué pasa cuando la memoria crece?

Con el tiempo, la memoria se llena de notas que se contradicen: una dice que usas un color y otra que lo quitaste. Un agente que lee ambas puede elegir la equivocada, o ninguna. Conviene tratar la memoria como un changelog: cada cierto tiempo, eliminar lo obsoleto y fusionar lo repetido. Una práctica simple es fechar cada nota y anotar qué decisión la respalda. Si una nota no tiene respaldo, se borra. Lo mismo vale para la memoria que escribe el agente: un aprendizaje correcto en un repositorio puede ser falso en otro, así que conviene revisar en qué proyecto quedó guardado.

Qué puedes hacer mañana

Abre el archivo de instrucciones o la memoria de un proyecto que uses a diario. Busca tres cosas: una nota que ya no sea cierta, una regla repetida en dos lugares y un dato sensible, como una clave, un correo o un identificador. Borra o mueve la primera, fusiona la segunda y saca la tercera del archivo. Después pide al agente que explique qué recuerda del proyecto y compara su respuesta con lo que tú sabes.

Errores comunes

Creer que el agente “ya sabe” lo que hiciste en otra sesión sin que esté guardado en algún lugar.
Guardar claves, tokens o datos de clientes en un archivo de memoria versionado.
Dejar que la memoria crezca con notas viejas que contradicen las nuevas.
Confiar en que una instrucción en memoria impide una acción. Es contexto, no una prohibición técnica.
No revisar lo que el agente escribió solo. Una nota automática equivocada se repite en cada sesión.

Fuentes

Preguntas frecuentes

¿Un agente de IA recuerda lo que hicimos ayer?

Por defecto, no. Cada sesión empieza con una ventana de contexto nueva. Solo recuerda lo que esté guardado en un archivo, una base de datos o un historial que la herramienta vuelva a cargar.

¿Cuál es la diferencia entre CLAUDE.md y la memoria automática?

CLAUDE.md lo escribe una persona con reglas e instrucciones. La memoria automática la escribe el propio agente a partir de correcciones y preferencias. Ambas se cargan al inicio de cada sesión como contexto.

¿La memoria de un agente siempre se cumple?

No. Se carga como contexto y el modelo puede ignorarla. Si algo debe impedirse siempre, hace falta un control técnico, como un hook que bloquee la acción.

¿Qué información no conviene guardar en la memoria de un agente?

Secretos, claves, datos personales de usuarios y listas de tareas que cambian cada semana. La memoria se lee en cada sesión, así que cualquier dato sensible queda expuesto a todo lo que el agente haga.