claude-code Mac & Windows

Cómo convertir a Claude en tu agente con memoria

datablog claude-code
Actualizado: 2026-06-10

En el post anterior te dejé con una regla y una deuda. La regla: usa siempre la misma carpeta. La deuda: explicarte por qué esa carpeta convierte a Claude en un agente con memoria. Este post paga la deuda —y te muestra cómo lo tengo montado yo.

1. Claude ya es un agente, no un chat

Conviene recordar dónde quedamos. En el chat, Claude solo puede hablarte. En Claude Code, Claude trabaja: lee tus archivos, escribe, ejecuta comandos, organiza carpetas. Eso ya es un agente —alguien que hace cosas, no solo alguien que responde.

Pero todo agente tiene un límite, y el de Claude conviene mirarlo de frente antes de resolverlo.

2. El límite real: la memoria muere al cerrar la sesión

Aquí está la verdad incómoda: cada vez que abres una sesión nueva, Claude empieza prácticamente en blanco. No recuerda la conversación de ayer, ni en qué proyecto andabas, ni qué decidiste la semana pasada. Cierras la ventana y, para efectos prácticos, ese Claude deja de existir.

Digo prácticamente y no totalmente en blanco por honestidad: Claude Code guarda por su cuenta una pequeña auto-memoria —la veremos en detalle más adelante— donde anota algunas cosas que cree que vale la pena conservar. Pero ojo con apoyarte en ella: es parcial e impredecible. De una conversación de mil palabras puede que solo quede guardado un párrafo de tres líneas, y tú rara vez sabes con certeza qué se guardó y qué se perdió. Ayuda, pero no puedes construir tu trabajo sobre algo que no controlas.

Y hay un detalle que vuelve este olvido aún más llamativo: solo ocurre entre sesiones. Dentro de una misma conversación, Claude parece tener una memoria excelente —le explicas algo al inicio y lo sigue usando horas después—. El problema aparece justo en el corte, al cerrar la ventana. Por eso la conclusión cae por su propio peso: la memoria entre sesiones no es algo que Claude tenga de fábrica, es algo que tú construyes —de forma deliberada, no dejándola al azar de lo que se guarde solo.

Sí, puedes decirle "recuerda esto" en medio de una conversación, y con el tiempo Claude se va acomodando a tu forma de trabajar. Pero ese camino es frágil: el control lo tiene él, no tú. Si quieres control de verdad sobre tu agente, necesitas dos cosas:

  1. Mapear una carpeta única para todas tus sesiones (la regla del post anterior).
  2. Conocer los archivos que definen cómo se comporta Claude.

3. La solución no es magia, es orden: la carpeta .claude

Toda la "memoria" de tu agente empieza en una carpeta con un nombre fácil de pasar por alto: .claude. Ese punto al inicio la convierte en una carpeta oculta —no la ves a simple vista a menos que la hagas visible a propósito— pero ahí dentro viven las instrucciones que definen a tu agente.

Y aquí viene lo importante: esa carpeta .claude no existe en un solo lugar, existe en dos, y entender la diferencia entre ambos es la clave de todo.

4. Los dos CLAUDE.md: un mismo nombre, dos trabajos distintos

Dentro de esas carpetas .claude hay un archivo que se llama exactamente igual en los dos sitios: CLAUDE.md. Es un simple archivo de texto donde escribes, en español normal, las instrucciones que Claude lee al empezar cada sesión.

Que tengan el mismo nombre confunde al principio. La diferencia no está en el nombre —está en dónde vive cada uno y en qué responsabilidad tiene.

4.1 El CLAUDE.md de usuario: quién es tu agente

Vive aquí:

~/.claude/CLAUDE.md

Esa .claude es la de tu usuario del ordenador, no la de ningún proyecto. Por eso este archivo es especial: aplica siempre, en cualquier carpeta que abras. Es la definición transversal de tu agente.

Aquí defines quién es Claude para ti. En mi caso, este archivo arranca diciendo:

Eres mi agente de inteligencia artificial que me ayuda en mi día a día con mi aprendizaje. Tu objetivo es ser mi compañero de estudio: alguien que interactúa, debate, ejemplifica y documenta conmigo.

No hay rutas técnicas ni reglas de proyecto —hay identidad y misión. Es lo que hace que Claude sea mi Claude y no un asistente genérico, sin importar en qué carpeta lo abra.

4.2 El CLAUDE.md de proyecto: cómo se trabaja en esta carpeta

Vive aquí (suponiendo que tu carpeta de agente se llame agente-claude):

agente-claude/.claude/CLAUDE.md

Este archivo está dentro de tu carpeta de agente, y por eso solo aplica cuando abres Claude ahí dentro. Aquí no defines quién es Claude —eso ya lo hiciste arriba— sino cómo se trabaja en este proyecto concreto: qué archivos consultar, cómo nombrar las cosas, qué hacer al empezar y al cerrar una sesión.

Es el manual de operaciones de esa carpeta específica.

4.3 La regla de oro: definiciones claras e independientes

La forma más simple de no confundirlos:

  • El de usuario responde "¿quién es mi agente?" → identidad, misión, comportamiento general. Te sigue a todas partes.
  • El de proyecto responde "¿cómo se trabaja en esta carpeta?" → rutas, reglas y protocolos de esa carpeta concreta. Vive pegado a la carpeta.

Cada uno con su responsabilidad, sin pisarse. Uno viaja contigo; el otro se queda en casa.

4.4 Cuándo conviene duplicar a propósito

Hay una excepción que parece un error y en realidad es una decisión de diseño. En mi setup, el protocolo de inicio (las primeras cosas que Claude lee al arrancar) lo tengo escrito en los dos archivos a la vez.

¿Por qué duplicarlo? Por un seguro: si algún día abro Claude por error en una carpeta que no es la de siempre, quiero que siga siendo el mismo agente —que no pierda su esencia ni sus reglas básicas. Como el archivo de usuario aplica en todas partes y apunta a mi carpeta por su ruta completa, el contexto se carga igual aunque me equivoque de carpeta.

El único costo es que, si cambio ese protocolo, lo tengo que actualizar en los dos sitios. A cambio, garantizo que mi agente nunca pierde la identidad. La lección general: la pregunta no es solo "dónde va esto", sino "dónde quiero que aplique". Si quieres que algo te acompañe a toda carpeta, va en el de usuario —aunque eso implique duplicar.

5. La tercera capa: el cuaderno que gestiona Claude

Hasta aquí hablamos de los dos archivos que tú redactas. Pero hay una tercera capa que conviene conocer: un cuaderno que vive del lado de Claude.

Claude Code guarda, en una carpeta aparte de tu ordenador, una auto-memoria: un sitio donde se anota lo que conviene recordar entre sesiones —una preferencia tuya, una corrección que le hiciste, un dato del proyecto— y que se vuelve a cargar al inicio de cada sesión. La mayor parte la escribe Claude por iniciativa propia, pero no es terreno cerrado para ti: si le dices "recuerda que…" o "guarda esto en tu memory", lo anota ahí; e incluso puedes abrir y editar esos archivos tú mismo con el comando /memory.

La diferencia real con los CLAUDE.md no es quién puede escribir —en los tres puede haber mano tuya—, sino de quién es el archivo y para qué sirve:

Capa De quién es Dónde vive
CLAUDE.md de usuario Tuyo Carpeta oculta de tu usuario
CLAUDE.md de proyecto Tuyo Dentro de tu carpeta de agente
Auto-memoria De Claude (puedes pedirle que guarde, o editarla con /memory) Fuera de tu carpeta, en el ordenador

Los dos CLAUDE.md son tu fuente de instrucciones: los redactas tú, viven en tu carpeta y viajan con ella si la respaldas en la nube o en un repositorio. La auto-memoria es el cuaderno de apuntes de Claude: él lo gestiona, vive fuera de tu carpeta y no viaja con tu repo. Puedes consultarlo y editarlo cuando quieras, pero no es donde pones tus reglas deliberadas —esas van en los CLAUDE.md, que controlas tú.

Yo prefiero apoyarme sobre todo en los CLAUDE.md, porque me dan control explícito sobre cómo trabaja mi agente. La auto-memoria es un buen complemento —deja que Claude recuerde detalles que yo no alcanzo a escribir— pero las reglas que de verdad importan las defino yo, a mano, en los archivos que controlo.

6. Protocolos: que el agente trabaje a tu manera

Aquí está la parte que convierte una carpeta ordenada en un agente que de verdad trabaja como tú quieres. Dentro del CLAUDE.md de proyecto puedes escribir protocolos: instrucciones estándar que Claude sigue de forma consistente, sin que tengas que recordárselas cada vez.

Dos ejemplos de los que yo uso a diario:

  • Protocolo de inicio: al abrir cualquier sesión, antes de responderme, Claude lee ciertos archivos de mi carpeta para recuperar el contexto —mis preferencias, el mapa de carpetas, en qué proyecto estoy. Así nunca arranca "frío".
  • Protocolo de cierre: cuando le digo que terminamos por hoy, Claude guarda un resumen estructurado de la sesión —qué tratamos, qué aprendí, qué quedó pendiente— en un archivo con un formato fijo. Eso convierte cada conversación en memoria consultable a futuro.

Fíjate en lo que logra el protocolo de cierre: ya no es solo "Claude lee mis instrucciones", es "Claude escribe memoria por mí, a mi manera, cada vez que cerramos". Ahí la carpeta deja de ser un almacén y se vuelve una memoria viva.

No vamos a entrar al detalle de cómo se escribe cada protocolo —eso merece su propio post—. Por ahora quédate con la idea: los protocolos son las reglas estándar que escribes una vez para que tu agente se comporte igual siempre.

⚠️ Para no crear una expectativa equivocada: esto no es un "agente autónomo" al estilo de Google Antigravity, donde le das un objetivo y el agente decide y ejecuta cada paso solo mientras tú supervisas. Lo que armamos aquí es lo contrario, y a propósito: un agente que trabaja bajo tu dirección, con la memoria y los protocolos al servicio de la consistencia, no de la autonomía total. (Claude Code puede operar de forma más autónoma con subagentes y permisos amplios, pero ese es otro camino, no el de esta serie.)

7. Así se ve funcionando

Todo esto no es teoría. Yo tengo una carpeta de agente —la llamo infinity-memory— que abro en cada sesión. Dentro vive el CLAUDE.md de proyecto con mis protocolos; en mi usuario vive el CLAUDE.md que define quién es mi agente; y por debajo, Claude alimenta su auto-memoria. Las tres capas trabajando juntas hacen que, cada vez que abro Claude, no empiece de cero: sabe quién es, sabe cómo trabajo y recuerda dónde lo dejamos.

Eso es, en concreto, convertir a Claude en un agente con memoria: no un truco, sino orden —archivos claros, cada uno con su trabajo, y protocolos que hacen el resto.

8. Lo que viene

Ya tienes el mapa completo: por qué Claude olvida, los dos CLAUDE.md y para qué sirve cada uno, la auto-memoria y el papel de los protocolos.

En el próximo post abrimos el capó: vamos a escribir protocolos en detalle —empezando por el de cierre y su template de sesión— para que veas exactamente cómo se le enseña a un agente a guardar memoria a tu manera.

9. Recursos