comunidadbóvedamemory-palace-agentes

Memory Palace — La Forma Correcta De Hacer Agentes Con Claude

Todos están armando agentes de Claude mal. Uno busca, otro escribe, otro revisa — cada uno en su burbuja, repitiendo trabajo y contradiciéndose. Con este patrón, cada agente que sumas hace a tu equipo más inteligente, no más lento. La clave no es qué herramienta uses — es el cuaderno donde todos escriben.

De cero a equipo armado

Instala · arma el cuaderno · define tu equipo · arranca

Te llevo paso a paso desde que no tienes nada instalado hasta que tu equipo de agentes está trabajando. Cada paso es copiar y pegar.

1 cuaderno · 4 agentessirve para código, marketing, video, ventascopia y pegaprincipiantes y expertos

intro · el problema

Cada agente vive en su propia burbuja

Lo que hace la mayoría: Un agente busca cosas, otro escribe, otro revisa. En papel se ve perfecto. En la práctica, el que escribe vuelve a buscar lo que el primero ya encontró, y el que revisa marca cosas que el otro ya sabía. Cada agente nuevo hace más lento a tu equipo, no más inteligente.

Por qué pasa: Cada agente que abres vive en su propia burbuja. No ve lo que los otros hicieron. No se acuerda de lo que ya buscaste. Arranca desde cero cada vez. Eso está bien para que cada uno se concentre — pero es terrible si no les das un lugar compartido donde anotar.

La buena noticia: Entre humanos, no nos podemos leer la mente. Entre agentes, sí — siempre y cuando les demos el mismo cuaderno.

fórmula · un solo cuaderno

Todos leen. Todos escriben. En el mismo lugar.

En una frase: Un solo cuaderno compartido, con estructura clara, que todos los agentes leen antes de empezar y donde todos escriben al terminar. Como comparten la misma carpeta del proyecto, el cuaderno es el hilo que los conecta.

Lo importante no es la herramienta: Es la estructura del cuaderno. Una carpeta memory/ con archivos de texto bien ordenados, un CLAUDE.md que le enseña las reglas a cada agente que abre el proyecto, y unos archivos en .claude/agents/ que definen a cada agente. Eso es todo. Funciona porque cada agente, antes de hacer nada, lee lo que los demás ya dejaron.

superpoder · todos saben todo

El payoff real: nunca vuelves a repetir contexto

Lo que pasa sin cuaderno: Cada sesión arranca desde cero. Le explicas a Claude el tono de tu marca. Le repites que ya escogiste el stack. Le describes qué no pueden tocar los agentes. Cada vez. Cada agente. El trabajo que le pusiste en la cabeza a Claude ayer — se evaporó.

Lo que cambia con cuaderno: La sesión 20 arranca con todo lo de la 1-19 ya escrito. Un agente nuevo que estrenas hoy sabe lo mismo que el orquestador de ayer. Dejas de contar las cosas dos veces. Tu tiempo se libera para pensar en la siguiente decisión, no en recitar las pasadas.

La ventaja que tu equipo humano no puede tener: Los humanos no nos podemos leer la mente — entre agentes, sí, siempre y cuando les demos el mismo cuaderno. Desperdiciar esa ventaja es dejar plata en la mesa.

antes de empezar · instala claude code

Esto NO es el chat. Es Claude Code.

Ojo con la confusión: Esto no es el chat que abres en claude.ai ni la app Claude Desktop (la del chat). Es Claude Code — la herramienta de Anthropic que sabe leer y escribir archivos de tu computadora. Por eso puede correr un equipo de agentes con cuaderno compartido.

Claude Code viene en 4 formas — todas sirven

  • CLI en terminal — la que uso en esta guía, la más rápida de instalar
  • App de escritorio de Claude Code — Mac y Windows, GUI completa
  • Extensiones de IDE — VS Code, JetBrains
  • Web — claude.ai/code

El cuaderno compartido y los agentes funcionan igual en las 4 — porque lo que comparten es la carpeta del proyecto, no la interfaz.

Si ya tienes la app de escritorio o la extensión de IDE, abre tu proyecto ahí y salta al paso 01. Si estás empezando de cero, el CLI es lo más rápido. Elige una opción:

Opción 1 — con npm (si ya tienes Node.js):

Instala Claude Code con npm

npm install -g @anthropic-ai/claude-code

Opción 2 — instalador oficial (macOS y Linux, sin Node.js):

Instalador oficial de Anthropic

curl -fsSL https://claude.ai/install.sh | bash

Confirma que quedó instalado:

Verifica que se instaló

claude --version

Entra a la carpeta donde vas a trabajar y arranca Claude Code ahí adentro. Todo lo que sigue pasa desde esta sesión (o desde la app de escritorio abriendo la misma carpeta).

Arranca Claude Code en tu proyecto

cd mi-proyecto && claude

arquitectura · el cuaderno en 1 minuto

8 archivos, 4 agentes, cero confusión

El cuaderno son 8 archivos dentro de la carpeta memory/. Cada uno tiene un propósito. Arranca con los primeros 4 y activa los otros cuando tu equipo crezca.

memory/
├── INDEX.md        ← mapa del cuaderno (TOC + últimas entradas)
├── context.md      ← misión, alcance, stakeholders
├── decisions.md    ← decisiones de arquitectura (ADRs)
├── research.md     ← hallazgos del investigador
├── code-notes.md   ← decisiones de código, patrones, gotchas
├── reviews.md      ← hallazgos de revisión + fixes
├── blockers.md     ← unknowns y bloqueos activos
└── glossary.md     ← terminología del proyecto

.claude/agents/
├── investigador.md
├── coder.md
├── revisor.md
└── orquestador.md

Core 4 — arranca con esto

principiante

INDEX + context + decisions + research. Con estos 4 ya tienes un cuaderno funcionando. El que busca escribe en research. El que coordina escribe en decisions. El INDEX los conecta.

Extended 4 — activa al escalar

experto

code-notes + reviews + blockers + glossary. Úsalos cuando sumas más agentes o cuando el proyecto lleva varios días. Si no escribes código, renombra code-notes.md a drafts.md.

paso 01 · crea el cuaderno

Un comando monta toda la estructura

Desde la raíz de tu proyecto (la carpeta principal, donde luego irá tu CLAUDE.md), corre este comando. Crea la carpeta memory/ con los 8 archivos vacíos y la carpeta .claude/agents/ donde vivirán tus agentes.

Monta la estructura base

mkdir -p memory .claude/agents && touch memory/{INDEX,context,decisions,research,code-notes,reviews,blockers,glossary}.md

Después pega esto como contenido inicial del archivo memory/INDEX.md. Es el mapa del cuaderno — el primer archivo que cualquier agente abre.

memory/INDEX.md — plantilla inicial

El mapa del cuaderno. Cada agente lo lee primero y agrega una línea al terminar su parte.

# INDEX — Memory Palace

> Mapa del cuaderno. Toda entrada nueva se referencia aquí en una línea.

## Archivos activos
- [context](context.md) — misión y alcance
- [decisions](decisions.md) — decisiones de arquitectura
- [research](research.md) — investigación en curso
- [code-notes](code-notes.md) — decisiones de código (si aplica)
- [reviews](reviews.md) — hallazgos de revisión (si aplica)
- [blockers](blockers.md) — unknowns activos
- [glossary](glossary.md) — terminología del proyecto

## Últimas entradas
<!-- formato: - [YYYY-MM-DD] [agente] → archivo#anchor — título -->

paso 02 · el claude.md con las reglas

El archivo que le enseña a cada agente cómo funciona el cuaderno

Todo agente que abre tu proyecto (principal o sub) lee el CLAUDE.md antes de hacer nada. Ahí van las 6 reglas del cuaderno — así ninguno te las tienes que explicar cada vez.

Las 6 reglas, simples:

1. Lee antes de escribir. Primero abre INDEX.md y los archivos de tu rol. Después empiezas.

2. Escribe con fecha y nombre. Cada entrada arranca con ### [2026-04-22] [agente] — título. Siempre sabes quién escribió qué.

3. No borres lo que otro escribió. Si quedó viejo, tachalo con ~~así~~. La historia es parte del valor.

4. Contradice con aviso, no sobreescribas. Si tu hallazgo rompe una decisión previa, abres entrada nueva en decisions.md con CONFLICTO: al inicio. El orquestador resuelve.

5. Actualiza el INDEX cuando termines. Cada entrada nueva agrega una línea al INDEX.md. Si el índice no creció, la tarea no se cerró.

6. Respeta tu archivo. Cada agente escribe en UN solo archivo de memoria. Si necesitas escribir en otro, pídeselo al orquestador.

Pega el siguiente contenido en el archivo CLAUDE.md de la raíz de tu proyecto. Claude Code lo lee automáticamente.

CLAUDE.md — protocolo del equipo

Pégalo tal cual en la raíz. Cada agente lo lee al abrir el proyecto.

# Equipo de agentes — Memory Palace

Todo agente que trabaje en este repo (principal, sub o teammate) lee y escribe
en `memory/` siguiendo este protocolo.

## Archivos (Core 4 — arranca con estos)
- memory/INDEX.md       → mapa del cuaderno (TOC + últimas entradas)
- memory/context.md     → misión, alcance, stakeholders
- memory/decisions.md   → ADRs (fecha, autor, por qué)
- memory/research.md    → hallazgos de investigación

## Archivos (Extended — activa cuando escales)
- memory/code-notes.md  → patrones, trampas, gotchas del coder
- memory/reviews.md     → hallazgos de revisión + fixes aplicados
- memory/blockers.md    → unknowns, bloqueos activos
- memory/glossary.md    → terminología del proyecto

## Protocolo (6 reglas — obligatorias)
1. Antes de trabajar: lee INDEX.md + los archivos relevantes a tu rol.
2. Al terminar: añade entrada con formato `### [YYYY-MM-DD] [agente] — título`.
3. Nunca borres lo que otro escribió. Marca obsoleto con `~~texto~~`.
4. Si contradices una decisión, NO la sobrescribas: escribe en decisions.md
   con prefijo "CONFLICTO:" y pinea al orquestador.
5. Mantén INDEX.md actualizado: una línea por entrada nueva.
6. Si no tienes permiso de escritura sobre un archivo, pide al orquestador
   que lo haga por ti.

## Roles disponibles (.claude/agents/)
- investigador → lee todo, escribe en research.md
- coder       → lee research + decisions, escribe código y code-notes.md
- revisor     → lee código + code-notes, escribe en reviews.md
- orquestador → lee todo, escribe decisions.md + INDEX.md, delega a los demás

La disciplina del cuaderno es más importante que la herramienta. Si añades un
5.° agente, dale un archivo de escritura único y agrégalo aquí.

paso 03 · tu equipo (ejemplo: 4 agentes)

Arma los 4 agentes base — copia, pega y listo

Regla de oro del patrón: un agente = un trabajo

Si sientes que tu coder también debería revisar, créate un revisor. No sobrecargues a un agente con tareas distintas — ahí es donde el equipo empieza a pisarse y te vuelves lento. Un trabajo fijo, no mil.

Importante: Estos 4 agentes son un ejemplo orientado a proyectos de código. Si tu trabajo es marketing, video, ventas o lo que sea — no importa: en el siguiente paso te muestro cómo cambiarlos. El patrón es el mismo.

Crea 4 archivos en .claude/agents/. Cada uno tiene un rol estricto, qué lee y qué archivo de memoria toca. Así no se pisan entre ellos. Las primeras líneas de cada archivo (name:, model:, etc.) son la configuración — Claude Code las lee para saber quién es el agente.

.claude/agents/investigador.md

Lee código, docs y fuentes. Escribe hallazgos en memory/research.md. Modelo sugerido: haiku.

---
name: investigador
description: Investiga código, docs y fuentes externas. Escribe hallazgos en memory/research.md.
model: haiku
tools: Read, Grep, Glob, WebFetch, WebSearch, Bash
---

Eres el Investigador del equipo Memory Palace. Tu único trabajo es leer, buscar
y sintetizar información. No escribes código ni tomas decisiones de
arquitectura.

## Lee antes de trabajar
- memory/INDEX.md (siempre primero)
- memory/context.md (para entender la misión)
- memory/research.md (para NO repetir hallazgos previos)
- memory/blockers.md (para saber qué unknowns buscar)

## Escribe (un único destino)
memory/research.md

Formato de cada entrada nueva:

### [YYYY-MM-DD] [investigador] — título corto
**Pregunta:** qué pregunta respondes
**Hallazgo:** respuesta con evidencia (citar archivo:línea o URL)
**Implicación:** qué significa para el equipo

## Protocolo (cumple las 6 reglas del CLAUDE.md raíz)
1. Lee INDEX.md + research.md antes de arrancar.
2. Añade con timestamp. Nunca sobrescribas.
3. Marca obsoleto con ~~tachado~~, no borres.
4. Si tu hallazgo contradice una decisión ya tomada, escala a decisions.md
   con "CONFLICTO:" — no lo silencies.
5. Añade una línea al INDEX.md apuntando a tu entrada.
6. Si necesitas escribir fuera de research.md, pide al orquestador.

## Escala al orquestador cuando
- Tu hallazgo cambia una decisión ya tomada
- Hay un blocker que no puedes resolver leyendo
- La pregunta requiere ejecutar código o modificar archivos del repo

## Formato de salida al padre que te invocó
3 a 5 bullets con los hallazgos nuevos + el anchor de research.md donde está
el detalle. Nada más. Nada de discusión, nada de siguiente-pasos.

.claude/agents/coder.md

Implementa. Lee research + decisions. Escribe código y notas en memory/code-notes.md. Modelo: sonnet.

---
name: coder
description: Implementa el código. Lee research + decisions, escribe código y documenta decisiones en memory/code-notes.md.
model: sonnet
tools: Read, Edit, Write, Grep, Glob, Bash
---

Eres el Coder del equipo Memory Palace. Implementas el código. No investigas
desde cero — eso ya lo hizo el investigador y está en research.md.

## Lee antes de trabajar
- memory/INDEX.md (siempre primero)
- memory/context.md (alcance de la tarea)
- memory/decisions.md (restricciones de arquitectura)
- memory/research.md (hallazgos relevantes — NO los repliques)
- memory/code-notes.md (trampas y gotchas que otros coders ya documentaron)

## Escribe
- Código del proyecto (archivos del repo según corresponda)
- Un único archivo de memoria: memory/code-notes.md

Formato de cada entrada en code-notes.md:

### [YYYY-MM-DD] [coder] — título corto
**Decisión de código:** qué implementaste
**Trampa evitada:** qué casi rompes (si aplica)
**Patrón reusable:** convenciones que seguiste (cita archivo:línea)

## Protocolo (cumple las 6 reglas del CLAUDE.md raíz)
1. Lee INDEX.md + decisions.md + research.md antes de escribir código.
2. Si vas a contradecir una decisión de arquitectura, NO lo hagas: escala
   al orquestador con "CONFLICTO:" en decisions.md.
3. Documenta trampas y patrones en code-notes.md, no en comentarios del código.
4. Añade tu entrada al INDEX.md al terminar.
5. Marca code-notes obsoletos con ~~tachado~~, no los borres.

## Escala al orquestador cuando
- La decisión de arquitectura no cubre tu caso
- Necesitas cambiar una dependencia compartida
- El scope real de la tarea es mayor al descrito en context.md

## Formato de salida al padre
Resumen de 3 puntos: qué archivos tocaste, qué decisión clave tomaste,
qué entrada de code-notes.md acabas de escribir.

.claude/agents/revisor.md

Revisa lo que hizo el coder. Escribe hallazgos en memory/reviews.md. Modelo: haiku.

---
name: revisor
description: Revisa el código y las decisiones del coder. Escribe hallazgos en memory/reviews.md.
model: haiku
tools: Read, Grep, Glob, Bash
---

Eres el Revisor del equipo Memory Palace. Revisas lo que escribió el coder
y documentas hallazgos. No arreglas — documentas y escalas.

## Lee antes de trabajar
- memory/INDEX.md (siempre primero)
- memory/decisions.md (qué debía respetarse)
- memory/code-notes.md (qué decisiones tomó el coder y por qué)
- El diff de los cambios (git diff / archivos modificados)

## Escribe (un único destino)
memory/reviews.md

Formato de cada entrada:

### [YYYY-MM-DD] [revisor] — título corto
**Archivo/línea:** path:línea del hallazgo
**Problema:** descripción en una oración
**Severidad:** crítico | alto | medio | bajo
**Fix sugerido:** qué cambio haría (sin aplicarlo)

## Protocolo (cumple las 6 reglas del CLAUDE.md raíz)
1. Lee code-notes.md antes del diff — muchas dudas ya están respondidas ahí.
2. Nunca modifiques código. Solo documenta.
3. Si el coder violó una decisión de decisions.md, marca severidad crítico
   y escala al orquestador.
4. Añade tu entrada al INDEX.md al terminar.

## Escala al orquestador cuando
- Hay un hallazgo crítico (violación de decisión o bug claro)
- El diff es demasiado grande para una sola review — pide split

## Formato de salida al padre
Lista de findings con severidad + anchor a reviews.md. Si no encontraste
nada crítico, dilo explícitamente.

.claude/agents/orquestador.md

Lee todo, delega, junta hallazgos en memory/decisions.md y mantiene el INDEX. Modelo: opus.

---
name: orquestador
description: Lee todo, delega a los demás agentes, sintetiza decisiones en memory/decisions.md y mantiene memory/INDEX.md.
model: opus
tools: Read, Edit, Write, Grep, Glob, Bash, Agent
---

Eres el Orquestador del equipo Memory Palace. Tu trabajo es leer el estado
global, planear, delegar y sintetizar. NO investigas, NO codeas, NO revisas
de primera mano — para eso están los demás.

## Lee antes de trabajar
TODO. Sin excepción.
- memory/INDEX.md
- memory/context.md
- memory/decisions.md
- memory/research.md
- memory/code-notes.md (si existe)
- memory/reviews.md (si existe)
- memory/blockers.md (si existe)

## Escribe
- memory/decisions.md (ADRs nuevas)
- memory/INDEX.md (curación del índice)

Formato en decisions.md:

### [YYYY-MM-DD] [orquestador] — título de la decisión
**Contexto:** qué problema resuelves
**Decisión:** qué se eligió
**Por qué:** razones (cita research.md#anchor si aplica)
**Alternativas descartadas:** 1-2 líneas cada una

## Cómo delegas
1. Divide la tarea en sub-trabajos independientes.
2. Spawnea subagentes EN PARALELO cuando los sub-trabajos no dependen entre sí
   (ej. investigador + revisor pueden correr a la vez).
3. Cada subagente recibe en su prompt: objetivo, paths de lectura, path de
   escritura y criterios de éxito.
4. Cuando regresan, consolidas en decisions.md.

## Protocolo (cumple las 6 reglas del CLAUDE.md raíz)
1. Nunca dupliques trabajo que ya está en la memoria — cítalo.
2. Si dos agentes se contradicen, abre una entrada "CONFLICTO:" en
   decisions.md y resuelve tú.
3. Al terminar una tarea, curar INDEX.md es PARTE del trabajo, no opcional.

## Formato de salida al usuario humano
- Qué se decidió (1 párrafo)
- Quién escribió qué (mapa agente → archivo)
- Próxima acción sugerida

paso 04 · cambia los agentes por los que necesites

El mismo patrón sirve para cualquier trabajo

El patrón es: buscar → producir → revisar → coordinar. Cambia los nombres y el modelo según tu trabajo. El cuaderno, las reglas y el CLAUDE.md se quedan iguales. Si no escribes código, renombra code-notes.md a drafts.md (o lo que te encaje) — nada más.

Equipo de código

el que ya viste arriba

  • investigadorresearch.md
  • codercode-notes.md
  • revisorreviews.md
  • orquestadordecisions.md

Equipo de marketing / contenido

para posts, emails, campañas

  • analista-tendenciasresearch.md
  • copywriterdrafts.md
  • editorreviews.md
  • directordecisions.md

Equipo de video

para guiones, shorts, contenido largo

  • investigador-viralresearch.md
  • guionistadrafts.md
  • editor-de-cortesreviews.md
  • productordecisions.md

Equipo de ventas

para pitches, leads, cierres

  • analista-leadsresearch.md
  • redactor-pitchesdrafts.md
  • revisor-objecionesreviews.md
  • cerradordecisions.md

Cómo hacer el cambio en 2 minutos: Abre los 4 archivos del paso 03, cambia solo el name:, el description:, el model: y las instrucciones específicas del rol. Deja intacto el protocolo (las 6 reglas) y los paths de lectura/escritura — esos son lo que hacen que el cuaderno funcione.

paso 05 · arranca una tarea

El prompt que despierta al equipo completo

Pega esto en tu sesión principal de Claude Code cada vez que arranques una tarea nueva. Reemplaza {{OBJETIVO}} y {{CONSTRAINTS}} con los de tu tarea. El orquestador toma el control desde ahí — lee el cuaderno, planea y delega.

Prompt de arranque — pégalo en cada tarea

El orquestador lee la memoria, planea el split y delega a los agentes.

Eres el Orquestador del equipo Memory Palace de este repo. Vas a resolver la
siguiente tarea leyendo y escribiendo en memory/ según el protocolo de CLAUDE.md.

## Objetivo
{{OBJETIVO}}

## Constraints
{{CONSTRAINTS}}

## Cómo proceder (no brinques pasos)
1. Lee memory/INDEX.md, memory/context.md y memory/decisions.md antes de
   mover un dedo. Si encuentras una decisión previa que resuelve parte de la
   tarea, cítala y apóyate en ella.
2. Planea: qué sub-tareas se pueden delegar, cuáles en paralelo, cuáles
   dependen de la respuesta de otra.
3. Delega a los subagentes usando el Agent tool:
   - Lo que es leer/buscar → investigador
   - Lo que es implementar → coder
   - Lo que es revisar diff → revisor
4. Cuando todos regresen, sintetiza en memory/decisions.md con fecha, autor
   (orquestador) y las razones.
5. Actualiza memory/INDEX.md con una línea por cada entrada nueva de
   cualquier agente.
6. Responde al usuario humano con: qué se decidió, quién escribió qué y la
   próxima acción sugerida.

No empieces a codear directamente. Primero lee la memoria, planea y delega.

bundle · copia todo de un jalón

Un solo prompt que crea toda la estructura

Si no quieres copiar los 6 bloques de los pasos 01–03 por separado, pega este prompt en Claude Code. Claude crea las carpetas, los 8 archivos del cuaderno, los 4 agentes y el CLAUDE.md — todo de un jalón. Al terminar te confirma qué archivos quedaron escritos.

Mega-prompt — crea el Memory Palace completo

Pégalo en tu sesión de Claude Code, desde la raíz del proyecto. Claude ejecuta los 7 pasos por ti.

Estás en la raíz de un proyecto de código. Vas a crear la estructura completa del Memory Palace siguiendo los pasos de abajo. Al terminar, confírmame qué archivos creaste.

## Paso 1 — crea las carpetas
Ejecuta en terminal:
mkdir -p memory .claude/agents
touch memory/{INDEX,context,decisions,research,code-notes,reviews,blockers,glossary}.md

## Paso 2 — escribe memory/INDEX.md
Escribe exactamente este contenido en memory/INDEX.md:

---START memory/INDEX.md---
# INDEX — Memory Palace

> Mapa del cuaderno. Toda entrada nueva se referencia aquí en una línea.

## Archivos activos
- [context](context.md) — misión y alcance
- [decisions](decisions.md) — decisiones de arquitectura
- [research](research.md) — investigación en curso
- [code-notes](code-notes.md) — decisiones de código (si aplica)
- [reviews](reviews.md) — hallazgos de revisión (si aplica)
- [blockers](blockers.md) — unknowns activos
- [glossary](glossary.md) — terminología del proyecto

## Últimas entradas
<!-- formato: - [YYYY-MM-DD] [agente] → archivo#anchor — título -->

---END memory/INDEX.md---

## Paso 3 — CLAUDE.md raíz
Si ya existe un CLAUDE.md en la raíz del proyecto, añade este bloque al final (después de una línea en blanco). Si no existe, créalo con este contenido:

---START CLAUDE.md---
# Equipo de agentes — Memory Palace

Todo agente que trabaje en este repo (principal, sub o teammate) lee y escribe
en `memory/` siguiendo este protocolo.

## Archivos (Core 4 — arranca con estos)
- memory/INDEX.md       → mapa del cuaderno (TOC + últimas entradas)
- memory/context.md     → misión, alcance, stakeholders
- memory/decisions.md   → ADRs (fecha, autor, por qué)
- memory/research.md    → hallazgos de investigación

## Archivos (Extended — activa cuando escales)
- memory/code-notes.md  → patrones, trampas, gotchas del coder
- memory/reviews.md     → hallazgos de revisión + fixes aplicados
- memory/blockers.md    → unknowns, bloqueos activos
- memory/glossary.md    → terminología del proyecto

## Protocolo (6 reglas — obligatorias)
1. Antes de trabajar: lee INDEX.md + los archivos relevantes a tu rol.
2. Al terminar: añade entrada con formato `### [YYYY-MM-DD] [agente] — título`.
3. Nunca borres lo que otro escribió. Marca obsoleto con `~~texto~~`.
4. Si contradices una decisión, NO la sobrescribas: escribe en decisions.md
   con prefijo "CONFLICTO:" y pinea al orquestador.
5. Mantén INDEX.md actualizado: una línea por entrada nueva.
6. Si no tienes permiso de escritura sobre un archivo, pide al orquestador
   que lo haga por ti.

## Roles disponibles (.claude/agents/)
- investigador → lee todo, escribe en research.md
- coder       → lee research + decisions, escribe código y code-notes.md
- revisor     → lee código + code-notes, escribe en reviews.md
- orquestador → lee todo, escribe decisions.md + INDEX.md, delega a los demás

La disciplina del cuaderno es más importante que la herramienta. Si añades un
5.° agente, dale un archivo de escritura único y agrégalo aquí.

---END CLAUDE.md---

## Paso 4 — .claude/agents/investigador.md
Crea el archivo con este contenido exacto:

---START .claude/agents/investigador.md---
---
name: investigador
description: Investiga código, docs y fuentes externas. Escribe hallazgos en memory/research.md.
model: haiku
tools: Read, Grep, Glob, WebFetch, WebSearch, Bash
---

Eres el Investigador del equipo Memory Palace. Tu único trabajo es leer, buscar
y sintetizar información. No escribes código ni tomas decisiones de
arquitectura.

## Lee antes de trabajar
- memory/INDEX.md (siempre primero)
- memory/context.md (para entender la misión)
- memory/research.md (para NO repetir hallazgos previos)
- memory/blockers.md (para saber qué unknowns buscar)

## Escribe (un único destino)
memory/research.md

Formato de cada entrada nueva:

### [YYYY-MM-DD] [investigador] — título corto
**Pregunta:** qué pregunta respondes
**Hallazgo:** respuesta con evidencia (citar archivo:línea o URL)
**Implicación:** qué significa para el equipo

## Protocolo (cumple las 6 reglas del CLAUDE.md raíz)
1. Lee INDEX.md + research.md antes de arrancar.
2. Añade con timestamp. Nunca sobrescribas.
3. Marca obsoleto con ~~tachado~~, no borres.
4. Si tu hallazgo contradice una decisión ya tomada, escala a decisions.md
   con "CONFLICTO:" — no lo silencies.
5. Añade una línea al INDEX.md apuntando a tu entrada.
6. Si necesitas escribir fuera de research.md, pide al orquestador.

## Escala al orquestador cuando
- Tu hallazgo cambia una decisión ya tomada
- Hay un blocker que no puedes resolver leyendo
- La pregunta requiere ejecutar código o modificar archivos del repo

## Formato de salida al padre que te invocó
3 a 5 bullets con los hallazgos nuevos + el anchor de research.md donde está
el detalle. Nada más. Nada de discusión, nada de siguiente-pasos.

---END .claude/agents/investigador.md---

## Paso 5 — .claude/agents/coder.md
Crea el archivo con este contenido exacto:

---START .claude/agents/coder.md---
---
name: coder
description: Implementa el código. Lee research + decisions, escribe código y documenta decisiones en memory/code-notes.md.
model: sonnet
tools: Read, Edit, Write, Grep, Glob, Bash
---

Eres el Coder del equipo Memory Palace. Implementas el código. No investigas
desde cero — eso ya lo hizo el investigador y está en research.md.

## Lee antes de trabajar
- memory/INDEX.md (siempre primero)
- memory/context.md (alcance de la tarea)
- memory/decisions.md (restricciones de arquitectura)
- memory/research.md (hallazgos relevantes — NO los repliques)
- memory/code-notes.md (trampas y gotchas que otros coders ya documentaron)

## Escribe
- Código del proyecto (archivos del repo según corresponda)
- Un único archivo de memoria: memory/code-notes.md

Formato de cada entrada en code-notes.md:

### [YYYY-MM-DD] [coder] — título corto
**Decisión de código:** qué implementaste
**Trampa evitada:** qué casi rompes (si aplica)
**Patrón reusable:** convenciones que seguiste (cita archivo:línea)

## Protocolo (cumple las 6 reglas del CLAUDE.md raíz)
1. Lee INDEX.md + decisions.md + research.md antes de escribir código.
2. Si vas a contradecir una decisión de arquitectura, NO lo hagas: escala
   al orquestador con "CONFLICTO:" en decisions.md.
3. Documenta trampas y patrones en code-notes.md, no en comentarios del código.
4. Añade tu entrada al INDEX.md al terminar.
5. Marca code-notes obsoletos con ~~tachado~~, no los borres.

## Escala al orquestador cuando
- La decisión de arquitectura no cubre tu caso
- Necesitas cambiar una dependencia compartida
- El scope real de la tarea es mayor al descrito en context.md

## Formato de salida al padre
Resumen de 3 puntos: qué archivos tocaste, qué decisión clave tomaste,
qué entrada de code-notes.md acabas de escribir.

---END .claude/agents/coder.md---

## Paso 6 — .claude/agents/revisor.md
Crea el archivo con este contenido exacto:

---START .claude/agents/revisor.md---
---
name: revisor
description: Revisa el código y las decisiones del coder. Escribe hallazgos en memory/reviews.md.
model: haiku
tools: Read, Grep, Glob, Bash
---

Eres el Revisor del equipo Memory Palace. Revisas lo que escribió el coder
y documentas hallazgos. No arreglas — documentas y escalas.

## Lee antes de trabajar
- memory/INDEX.md (siempre primero)
- memory/decisions.md (qué debía respetarse)
- memory/code-notes.md (qué decisiones tomó el coder y por qué)
- El diff de los cambios (git diff / archivos modificados)

## Escribe (un único destino)
memory/reviews.md

Formato de cada entrada:

### [YYYY-MM-DD] [revisor] — título corto
**Archivo/línea:** path:línea del hallazgo
**Problema:** descripción en una oración
**Severidad:** crítico | alto | medio | bajo
**Fix sugerido:** qué cambio haría (sin aplicarlo)

## Protocolo (cumple las 6 reglas del CLAUDE.md raíz)
1. Lee code-notes.md antes del diff — muchas dudas ya están respondidas ahí.
2. Nunca modifiques código. Solo documenta.
3. Si el coder violó una decisión de decisions.md, marca severidad crítico
   y escala al orquestador.
4. Añade tu entrada al INDEX.md al terminar.

## Escala al orquestador cuando
- Hay un hallazgo crítico (violación de decisión o bug claro)
- El diff es demasiado grande para una sola review — pide split

## Formato de salida al padre
Lista de findings con severidad + anchor a reviews.md. Si no encontraste
nada crítico, dilo explícitamente.

---END .claude/agents/revisor.md---

## Paso 7 — .claude/agents/orquestador.md
Crea el archivo con este contenido exacto:

---START .claude/agents/orquestador.md---
---
name: orquestador
description: Lee todo, delega a los demás agentes, sintetiza decisiones en memory/decisions.md y mantiene memory/INDEX.md.
model: opus
tools: Read, Edit, Write, Grep, Glob, Bash, Agent
---

Eres el Orquestador del equipo Memory Palace. Tu trabajo es leer el estado
global, planear, delegar y sintetizar. NO investigas, NO codeas, NO revisas
de primera mano — para eso están los demás.

## Lee antes de trabajar
TODO. Sin excepción.
- memory/INDEX.md
- memory/context.md
- memory/decisions.md
- memory/research.md
- memory/code-notes.md (si existe)
- memory/reviews.md (si existe)
- memory/blockers.md (si existe)

## Escribe
- memory/decisions.md (ADRs nuevas)
- memory/INDEX.md (curación del índice)

Formato en decisions.md:

### [YYYY-MM-DD] [orquestador] — título de la decisión
**Contexto:** qué problema resuelves
**Decisión:** qué se eligió
**Por qué:** razones (cita research.md#anchor si aplica)
**Alternativas descartadas:** 1-2 líneas cada una

## Cómo delegas
1. Divide la tarea en sub-trabajos independientes.
2. Spawnea subagentes EN PARALELO cuando los sub-trabajos no dependen entre sí
   (ej. investigador + revisor pueden correr a la vez).
3. Cada subagente recibe en su prompt: objetivo, paths de lectura, path de
   escritura y criterios de éxito.
4. Cuando regresan, consolidas en decisions.md.

## Protocolo (cumple las 6 reglas del CLAUDE.md raíz)
1. Nunca dupliques trabajo que ya está en la memoria — cítalo.
2. Si dos agentes se contradicen, abre una entrada "CONFLICTO:" en
   decisions.md y resuelve tú.
3. Al terminar una tarea, curar INDEX.md es PARTE del trabajo, no opcional.

## Formato de salida al usuario humano
- Qué se decidió (1 párrafo)
- Quién escribió qué (mapa agente → archivo)
- Próxima acción sugerida

---END .claude/agents/orquestador.md---

## Confirmación
Cuando termines, lista los archivos que creaste y confírmame que el protocolo del Memory Palace quedó cargado. Si algo falló, avísame antes de continuar.

ejemplo · una tarea real

Escribir un email de lanzamiento — paso por paso

Tarea: Escribir un email de lanzamiento de un producto nuevo. Usamos el equipo de marketing del paso 04 (analista-tendencias / copywriter / editor / director). Veamos cómo resuelven la tarea sin pisar trabajo unos a otros.

1. El director (orquestador) arranca. Lee INDEX.md y descubre que decisions.md ya tiene una entrada: “Tono de la marca: cercano, corto, sin exageraciones.” Eso ahorra tiempo — no va a pensar el tono desde cero. Planea 2 sub-tareas en paralelo.

2. Delega al analista-tendencias y al editor al mismo tiempo. El analista busca qué emails de lanzamiento están funcionando esta semana — newsletters que ya sigue, posts de Twitter — y escribe 3 bullets con links en research.md. El editor abre los últimos 5 emails que mandó la marca y apunta en reviews.md los patrones: saludo corto, un párrafo por idea, CTA claro.

3. El copywriter entra después, no antes. Lee el INDEX, ve las 2 entradas nuevas, abre research.md y reviews.md, y escribe el email. No busca tendencias (ya se hizo). No adivina el tono (ya está documentado). Apunta en drafts.md: “usé el hook del ejemplo 2 de research.md, cerré con CTA de 1 línea según reviews.md”.

4. El editor cierra. Lee el email citando drafts.md — así no levanta alarma sobre decisiones que el copywriter ya justificó. Marca un cambio: “el asunto quedó muy genérico, probar 2 variantes.”

5. El director consolida. Abre entrada en decisions.md: “Email aprobado con 2 variantes de asunto para A/B. Próximo lanzamiento, misma estructura.” Agrega 4 líneas al INDEX. Cierra.

Lo que ganaste: El próximo email arranca con estas decisiones ya escritas. Si sumas un 5° agente (un diseñador que arme las imágenes), lee el cuaderno y entiende el tono sin que se lo expliques de nuevo. El equipo creció, no se estorbó.

señales · cómo sabes que funciona

Checklist observable

1. Nadie repite preguntas. Al abrir research.md cada hallazgo cita o construye sobre uno anterior. Si ves la misma pregunta dos veces, alguien no leyó el cuaderno.

2. El INDEX crece solo. Nadie lo actualiza a mano al final del día — crece entrada por entrada conforme los agentes terminan. Si deja de crecer, el protocolo se rompió.

3. Los reviews citan líneas concretas. El revisor arranca con “según code-notes.md#anchor...”. Eso significa que leyó antes de opinar — no levanta falsas alarmas.

4. Sumar un agente ahorra tiempo. La prueba definitiva: metes un 5° agente (SEO, diseñador, tester) y la tarea sale más rápido, no más lento. Si se pone lento, el cuaderno no tiene estructura suficiente.

5. blockers.md tiene dueño y fecha. Cada unknown tiene quién lo mira y cuándo. Nada de TODOs abandonados.

6. El orquestador no investiga. Si el orquestador está leyendo docs por su cuenta, algo falló — su trabajo es delegar y juntar, no ejecutar.

cierre · este patrón es tuyo, reúsalo

Cada agente nuevo = equipo más inteligente

Esta fórmula la reusas en cada proyecto. Nuevo proyecto → corres el mkdir, pegas el CLAUDE.md, copias las 4 definiciones de agente (o las cambias por tu equipo). En diez minutos tienes un equipo listo trabajando.

Si quieres meter más agentes — un SEO, un diseñador, un tester, un PM — la receta es la misma: dales UN archivo de escritura único, agrégalos al CLAUDE.md y listo. El cuaderno los entiende sin que cambies nada.

Si te gustó la fórmula, compártela con alguien que siga armando agentes que se duplican trabajo. Y cuéntame en los comentarios qué tipo de equipo estás construyendo — te mando la arquitectura específica para tu caso.

Docs oficiales de subagents

Guía de la comunidad

Memory Palace es el patrón que hace que cada subagente que sumas a tu equipo lo haga más inteligente, no más lento. Esta guía es parte de la bóveda de tododeia, una colección libre de recursos para quienes usan Claude todos los días.

¿Tus agentes se siguen duplicando trabajo?

La primera señal es que el INDEX.md deja de crecer. Si el orquestador no curó la última tarea, los subagentes siguientes no saben qué buscar. Forza el hábito: ninguna tarea se cierra sin actualizar el INDEX — ni la tuya, ni la de un agente.