Qué es la Vista de Agente de Claude Code: cómo sus sesiones en segundo plano comparten el contexto de tu proyecto y a dónde van las ediciones de cada una (2026)

La documentación de Anthropic lo describe de esta manera: "La vista de agente, abierta con claude agents, es una pantalla para todas tus sesiones en segundo plano: lo que se está ejecutando, lo que necesita tu entrada y lo que está terminado".

Cada fila es una sesión independiente. "Cada sesión en segundo plano es una conversación completa de Claude Code que sigue ejecutándose sin una terminal conectada, por lo que puedes abrirla, responder y salir cuando quieras".

Trabajas con las filas de tres maneras:

• Dispatch (Enviar). Escribe un prompt en la parte inferior y presiona Enter. "Cada prompt que ingresas aquí inicia su propia sesión nueva".
• Peek (Vistazo). Presiona Espacio en una fila para ver su estado más reciente, su resultado o la pregunta que está esperando, y responde sin salir de la lista.
• Attach (Conectar). Presiona Enter o la flecha derecha para abrir la conversación completa, y la flecha izquierda en un prompt vacío para volver.

También puedes llevar una sesión abierta a la vista de agente con /bg o la flecha izquierda, y copiar una en una nueva sesión en segundo plano con /fork.

La vista de agente ejecuta las sesiones en tu máquina. La documentación señala los Proyectos de Claude Code para sesiones paralelas que Claude inicia y rastrea en la nube.

Una sesión enviada es una conversación nueva. No hereda lo que se ha discutido en otras filas.

Lo que sí obtiene es el contexto permanente de tu proyecto, el mismo que cualquier sesión de Claude Code iniciada en ese lugar:

• Su directorio. "Una nueva sesión se ejecuta en el directorio desde el que abriste la vista de agente". Puedes dirigirte a otro abriendo la vista de agente allí, mencionando un repositorio hijo con @<repo> o ejecutando claude --bg desde ese directorio.
• Tus archivos de instrucciones. Claude Code carga los archivos CLAUDE.md del directorio de trabajo y los directorios superiores, y las reglas en .claude/rules/ sin un campo paths, al inicio de una sesión. Las reglas con alcance de ruta se cargan cuando Claude trabaja con un archivo coincidente.
• Memoria automática (auto memory) para el repositorio. La documentación de memoria de Claude Code dice: "Todos los worktrees y subdirectorios dentro del mismo repositorio git comparten un directorio de memoria automática". Las sesiones en segundo plano en el mismo repositorio leen del mismo lugar.
• El modelo y los ajustes que establezcas en la vista de agente. /model, /effort y /fast en la vista de agente establecen con qué comenzarán las sesiones que envíes a continuación, y los flags de configuración que pases a claude agents se transmiten a las sesiones enviadas.

Vale la pena conocer una excepción al punto de la memoria. La documentación de memoria dice que el interruptor /memory desactiva la memoria automática pero no la vuelve a activar en una sesión en segundo plano. Si la memoria automática está desactivada allí, debes volver a activarla desde una sesión que inicies directamente en tu terminal.

Las sesiones en segundo plano comparten archivos, no conversaciones.

Comparten lo que hay en el disco. Los archivos CLAUDE.md, las reglas y el directorio de memoria automática son los mismos para cada sesión en un repositorio. Si una sesión guarda una nota en la memoria automática, esta se encuentra en el directorio compartido que utilizan otras sesiones en ese repositorio. Nuestra guía sobre cómo compartir el contexto entre sesiones de Claude Code cubre las otras formas de transmitir el contexto.

No comparten sus conversaciones. Cada fila es su propia conversación. Lo que le dijiste a una sesión en una respuesta, y lo que esta resolvió, se queda en esa sesión a menos que lo escriba en algún lugar.

Un fork comienza con una copia y luego sigue su propio camino. /fork copia la conversación actual en una nueva sesión en segundo plano, junto con el modelo, el modo de permiso, el nivel de esfuerzo y las concesiones de permisos que agregaste. Después de eso, "las dos conversaciones son independientes: nada de lo que haga la copia entra en la conversación original por sí solo". La documentación señala una excepción: donde la mensajería entre sesiones está habilitada, el Claude de cualquiera de las sesiones puede enviar mensajes explícitamente a la otra. Nuestra guía para hacer fork de una sesión remota desde la aplicación Claude cubre el mismo patrón en la nube.

Qué se transfiere cuando pasas una sesión a segundo plano. Mover una sesión que ya tienes abierta al segundo plano mantiene su conversación. Los comandos en segundo plano, los subagentes en segundo plano y las tareas de /loop se transfieren; un monitor en ejecución se detiene y Claude Code pregunta primero.

Esta es la parte que evita que las sesiones paralelas colisionen. La documentación explica: "Antes de editar archivos, Claude mueve la sesión a un git worktree aislado bajo .claude/worktrees/, de modo que las sesiones paralelas puedan leer el mismo checkout pero cada una escriba en el suyo".

Así que una sesión enviada comienza leyendo tu directorio de trabajo y luego se mueve a su propio worktree antes de cambiar nada. Los subagentes que genera heredan su directorio de trabajo, por lo que sus ediciones también aterrizan en ese worktree.

Qué contiene un worktree nuevo

La documentación de worktree de Claude Code describe los valores predeterminados para los worktrees que crea: "crea una rama a partir de la rama predeterminada de tu repositorio y solo descarga los archivos rastreados". Agrega: "Un worktree es un checkout nuevo, así que inicializa tu entorno de desarrollo allí".

Para el contexto, eso importa de dos maneras:

• Los cambios no confirmados (uncommitted) en los archivos de instrucciones no están allí. Si editaste CLAUDE.md o una regla y no la has confirmado, un worktree extraído de la rama predeterminada tiene la versión confirmada.
• Los archivos ignorados por git (gitignored) tampoco están allí. Eso incluye archivos locales como .env. La documentación de worktree describe un archivo .worktreeinclude para llevar archivos ignorados por git a los nuevos worktrees.

Puedes cambiar el punto de partida con el ajuste worktree.baseRef. Su valor predeterminado, "fresh", crea la rama desde la rama predeterminada del remoto; "head" crea la rama desde tu HEAD local actual. Nuestra guía sobre si los worktrees de Claude Code comparten memoria cubre en detalle lo que carga una sesión de worktree.

Cuándo Claude omite el worktree

La documentación enumera casos en los que una sesión edita en el lugar, incluyendo una sesión que moviste al segundo plano desde tu terminal abierta, una sesión que ya está dentro de un worktree vinculado y un directorio que no es un repositorio git y no tiene un hook de worktree. También puedes desactivar el aislamiento para un repositorio estableciendo worktree.bgIsolation en "none".

Cómo se guarda el trabajo

Cuando una sesión en segundo plano ha cambiado código en su propio worktree, Claude Code le indica a Claude que preserve el trabajo antes de terminar: confirmar (commit) y subir (push) la rama cuando hay un remoto, y abrir un pull request borrador cuando la tarea lo requiera. Esas instrucciones descartan subir a main o master, hacer force-push y fusionar (merge). Y "si la tarea, CLAUDE.md o la memoria dicen que tú te encargas de confirmar o subir los cambios, Claude te deja git a ti".

Cada sesión termina con un informe de lo que hizo y dónde está el trabajo.

Eliminar una sesión de la vista de agente la quita de la lista, pero "Su transcripción permanece en tu máquina a través de claude --resume". Un worktree que Claude creó para ella es otro asunto: la vista de agente lo elimina, "incluyendo los cambios no confirmados, así que confirma lo que quieras conservar primero". Claude Code rechaza la eliminación cuando un worktree tiene confirmaciones que no puede confirmar que estén guardadas en otro lugar, y te indica cómo proceder.

Puedes recuperar una sesión eliminada como una fila en segundo plano con /resume en la vista de agente, que enumera las sesiones pasadas del repositorio, incluidas las que eliminaste. Nuestra guía para encontrar y eliminar el historial de sesiones de Claude Code cubre las transcripciones en sí.

Esperar que las filas se conozcan entre sí. Cada una es su propia conversación. Comparten archivos en el disco, no lo que se dijo.

Decirle una decisión a una sesión y esperar que las demás la sigan. La decisión permanece en esa conversación a menos que se escriba en CLAUDE.md, en una regla o en la memoria.

Editar CLAUDE.md y enviarlo de inmediato. Un worktree de la rama predeterminada tiene la versión confirmada, no tu edición.

Eliminar una fila antes de confirmar. La vista de agente elimina el worktree que creó, incluidos los cambios no confirmados.

Asumir que las sesiones siguen ejecutándose cuando la computadora está apagada. La documentación enumera esto como una limitación: las sesiones son locales y se detienen si la máquina se apaga. Se preservan durante la suspensión (sleep).

Paso 1: Escribe el contexto que cada sesión necesita donde cada sesión lo lea

Las convenciones y restricciones que se aplican a todo el trabajo paralelo pertenecen al CLAUDE.md de la raíz del proyecto o a una regla sin alcance en .claude/rules/. Una decisión que de otro modo repetirías en cada fila también pertenece allí. Si prefieres que Claude la recuerde, pídele que guarde el punto en la memoria automática, que comparten todas las sesiones del repositorio.

Paso 2: Confirma los cambios de instrucciones antes de enviar

Debido a que los worktrees comienzan desde la rama predeterminada por defecto, confirma y sube los cambios a CLAUDE.md y a las reglas antes de enviar sesiones que dependan de ellos. Si tus sesiones necesitan tu rama en progreso en su lugar, establece worktree.baseRef en "head" y agrega un .worktreeinclude para los archivos locales que el trabajo necesite.

Paso 3: Pide a cada sesión que informe lo que aprendió

Incluye en el prompt lo que la sesión debe dejar atrás: la rama, un breve resumen de lo que encontró y cualquier decisión que otras sesiones necesiten. Lee los informes cuando las filas se completen y mueve cualquier cosa que las otras sesiones deban saber a CLAUDE.md o a la memoria. Confirma antes de eliminar una fila.

Si también ejecutas trabajo programado, nuestra guía sobre si las rutinas de Claude Code transfieren algo de una ejecución a la siguiente cubre la misma pregunta para las ejecuciones que comienzan por su cuenta.

La vista de agente facilita la ejecución de muchas sesiones, y cada una aprende algo que podrías querer que las demás sepan. Dentro de un repositorio, CLAUDE.md, las reglas y la memoria automática llevan eso en tu máquina. Cuando las mismas decisiones importan en otra computadora o en otra herramienta, necesitan un hogar que no esté atado a un solo checkout.

MemoryLake es una capa de memoria para mantener ese tipo de contexto en una lista que tú mantienes, disponible para Claude Code y los otros asistentes que conectes, como Codex y ChatGPT.

Tú mismo escribes las entradas, con tus propias palabras. No se lee nada, ni se escribe ni se elimina de tus sesiones en segundo plano, sus worktrees, tus archivos CLAUDE.md, tu memoria automática o el almacenamiento de cualquier proveedor. La vista de agente sigue funcionando de la manera que Anthropic describe.

Paso 1: Crea una clave API

Inicia sesión y genera una clave desde el panel de control. La clave pertenece a tu espacio de trabajo de MemoryLake y es independiente de tu cuenta de Claude.

Paso 2: Sube tus primeras memorias

Comienza con lo que extrajiste de los informes de sesión en el Paso 3 de la solución: decisiones, restricciones y hallazgos que más de una sesión necesitaba. Un punto por entrada, con fecha y etiquetado con el repositorio.

Paso 3: Conecta tu IA y agentes

Conecta Claude Code y los otros asistentes que utilices. Cada sesión puede comenzar a partir de las mismas decisiones, dondequiera que se ejecute.

La primera diferencia es que las sesiones paralelas dejan de sorprenderte. Sabes que comparten archivos y memoria en el disco, no conversaciones.

La segunda es que sus ediciones no colisionan. Cada sesión enviada escribe en su propio worktree, comenzando desde la rama predeterminada a menos que la cambies.

La tercera es que nada útil desaparece con una fila. El trabajo se confirma, los hallazgos se anotan y la transcripción sigue allí para reanudarse. Si cambias de computadora, nuestra guía sobre Claude Code en otra máquina cubre lo que la memoria automática no transfiere.

Trata cada fila como su propia conversación. Dale lo que necesita en el prompt y en el disco.

Mantén las reglas compartidas en CLAUDE.md o reglas sin alcance. Cada sesión las lee.

Confirma los cambios de instrucciones antes de enviar. Los worktrees comienzan desde la versión confirmada por defecto.

Usa .worktreeinclude para archivos locales. Los archivos ignorados por git no están en un worktree nuevo.

Pide un informe. La rama, el resultado y lo que otras sesiones deberían saber.

Confirma antes de eliminar una fila. La vista de agente elimina el worktree que Claude creó.

Recuerda que las sesiones son locales. Se detienen si la máquina se apaga.

La vista de agente es una pantalla para muchas sesiones de Claude Code en segundo plano. Cada fila es una conversación completa e independiente que comienza en tu directorio de trabajo con el CLAUDE.md de tu proyecto, las reglas y la memoria automática compartida, y luego se mueve a su propio worktree antes de editar archivos. Las sesiones comparten lo que hay en el disco, no lo que se dijo en cada conversación, y un fork es independiente una vez realizado.

Pon el contexto que todas las sesiones necesitan en CLAUDE.md, reglas o memoria, confírmalo antes de enviar, pide a cada sesión que informe lo que aprendió y confirma antes de eliminar una fila.