> ## Documentation Index
> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Orquestar equipos de sesiones de Claude Code
> Coordine múltiples instancias de Claude Code trabajando juntas como un equipo, con tareas compartidas, mensajería entre agentes y gestión centralizada.
Los equipos de agentes son experimentales y están deshabilitados por defecto. Habilítelos agregando `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS` a su [settings.json](/es/settings) o entorno. Sin esa variable, ningún equipo se configura al inicio de la sesión, no se escriben directorios de equipo, y Claude no genera ni propone compañeros de equipo. Los equipos de agentes tienen [limitaciones conocidas](#limitations) alrededor de la reanudación de sesiones, coordinación de tareas y comportamiento de apagado.
Los equipos de agentes le permiten coordinar múltiples instancias de Claude Code trabajando juntas. Una sesión actúa como el líder del equipo, coordinando el trabajo, asignando tareas y sintetizando resultados. Los compañeros de equipo trabajan de forma independiente, cada uno en su propia ventana de contexto, y se comunican directamente entre sí.
A diferencia de los [subagents](/es/sub-agents), que se ejecutan dentro de una única sesión y solo pueden reportar al agente principal, también puede interactuar directamente con compañeros de equipo individuales sin pasar por el líder.
Esta página describe equipos de agentes a partir de v2.1.178. Con `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS` configurado, generar un compañero de equipo ya no necesita un paso de configuración, y la limpieza ocurre automáticamente cuando la sesión sale. Antes de v2.1.178, usted le pedía a Claude que creara y nombrara un equipo primero, y Claude usaba las herramientas `TeamCreate` y `TeamDelete` para configurarlo y eliminarlo. Ambas herramientas ya no existen. La entrada `team_name` en la herramienta Agent se acepta pero se ignora, y el campo `team_name` en `TaskCreated`, `TaskCompleted`, y `TeammateIdle` [cargas útiles de hooks](/es/hooks#taskcreated) lleva el nombre derivado de la sesión y está deprecado.
Cuándo usar equipos de agentes
Los equipos de agentes son más efectivos para tareas donde la exploración paralela agrega valor real. Vea [ejemplos de casos de uso](#use-case-examples) para escenarios completos. Los casos de uso más sólidos son:
* **Investigación y revisión**: múltiples compañeros de equipo pueden investigar diferentes aspectos de un problema simultáneamente, luego compartir y desafiar los hallazgos de los demás
* **Nuevos módulos o características**: los compañeros de equipo pueden poseer cada uno una pieza separada sin pisarse mutuamente
* **Depuración con hipótesis competidoras**: los compañeros de equipo prueban diferentes teorías en paralelo y convergen en la respuesta más rápidamente
* **Coordinación entre capas**: cambios que abarcan frontend, backend y pruebas, cada uno propiedad de un compañero de equipo diferente
Los equipos de agentes agregan sobrecarga de coordinación y usan significativamente más tokens que una única sesión. Funcionan mejor cuando los compañeros de equipo pueden operar de forma independiente. Para tareas secuenciales, ediciones del mismo archivo o trabajo con muchas dependencias, una única sesión o [subagents](/es/sub-agents) son más efectivos.
Comparar con subagents
Tanto los equipos de agentes como los [subagents](/es/sub-agents) le permiten paralelizar el trabajo, pero operan de manera diferente. Elija según si sus trabajadores necesitan comunicarse entre sí:
| | Subagents | Equipos de agentes |
| :------------------ | :-------------------------------------------------------------- | :--------------------------------------------------------------- |
| **Contexto** | Ventana de contexto propia; los resultados regresan al llamador | Ventana de contexto propia; completamente independiente |
| **Comunicación** | Reportan resultados solo al agente principal | Los compañeros de equipo se envían mensajes directamente |
| **Coordinación** | El agente principal gestiona todo el trabajo | Lista de tareas compartida con auto-coordinación |
| **Mejor para** | Tareas enfocadas donde solo importa el resultado | Trabajo complejo que requiere discusión y colaboración |
| **Costo de tokens** | Menor: resultados resumidos de vuelta al contexto principal | Mayor: cada compañero de equipo es una instancia Claude separada |
Use subagents cuando necesite trabajadores rápidos y enfocados que reporten. Use equipos de agentes cuando los compañeros de equipo necesiten compartir hallazgos, desafiarse mutuamente y coordinarse por su cuenta.
Habilitar equipos de agentes
Los equipos de agentes están deshabilitados por defecto. Habilítelos configurando la variable de entorno `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS` a `1`, ya sea en su entorno de shell o a través de [settings.json](/es/settings):
```json settings.json theme={null}
{
"env": {
"CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
}
}
```
Inicie su primer equipo de agentes
Después de habilitar los equipos de agentes, describa la tarea y los compañeros de equipo que desea en lenguaje natural. Claude los genera y coordina el trabajo según su indicación.
Este ejemplo funciona bien porque los tres roles son independientes y pueden explorar el problema sin esperar el uno al otro:
```text theme={null}
Estoy diseñando una herramienta CLI que ayuda a los desarrolladores a rastrear
comentarios TODO en su base de código. Genere tres compañeros de equipo para explorar
esto desde diferentes ángulos: uno en UX, uno en arquitectura técnica, uno jugando
al abogado del diablo.
```
A partir de ahí, Claude completa una [lista de tareas compartida](/es/interactive-mode#task-list), genera compañeros de equipo para cada perspectiva, los hace explorar el problema, y sintetiza hallazgos cuando termina.
El panel del agente del líder enumera los compañeros de equipo debajo de la entrada del indicador. Desde el panel:
* **Flechas arriba y abajo**: seleccionar un compañero de equipo
* **Intro**: abrir la transcripción del compañero de equipo seleccionado y enviarle un mensaje directamente
* **Escape**: interrumpir el turno actual del compañero de equipo seleccionado
{/* min-version: 2.1.181 */}A partir de v2.1.181, la fila de un compañero de equipo inactivo se oculta después de 30 segundos y reaparece en su siguiente turno. El compañero de equipo sigue ejecutándose y es direccionable mientras está oculto.
Si desea que cada compañero de equipo esté en su propio panel dividido, vea [Elegir un modo de visualización](#choose-a-display-mode).
Controle su equipo de agentes
Dígale al líder lo que desea en lenguaje natural. Maneja la coordinación del equipo, asignación de tareas y delegación según sus instrucciones.
Elegir un modo de visualización
Los equipos de agentes admiten dos modos de visualización:
* **En proceso**: todos los compañeros de equipo se ejecutan dentro de su terminal principal. Use las teclas de flecha arriba y abajo en el panel del agente para seleccionar un compañero de equipo, luego presione Intro para verlo y escriba para enviarle un mensaje directamente. Funciona en cualquier terminal, sin configuración adicional requerida.
* **Paneles divididos**: cada compañero de equipo obtiene su propio panel. Puede ver la salida de todos a la vez y hacer clic en un panel para interactuar directamente. Requiere tmux o iTerm2.
`tmux` tiene limitaciones conocidas en ciertos sistemas operativos y tradicionalmente funciona mejor en macOS. Usar `tmux -CC` en iTerm2 es el punto de entrada sugerido en `tmux`.
El valor predeterminado es `"in-process"`. Antes de v2.1.179, el valor predeterminado era `"auto"`, por lo que las sesiones actualizadas que anteriormente abrían paneles divididos ahora permanecen en una terminal a menos que establezca el modo explícitamente. Configure `"auto"` para habilitar paneles divididos cuando ya esté ejecutándose dentro de una sesión tmux o su terminal sea iTerm2, retrocediendo a en proceso de lo contrario. La configuración `"tmux"` habilita el modo de panel dividido y detecta automáticamente si usar tmux o iTerm2 según su terminal.
{/* min-version: 2.1.186 */}A partir de v2.1.186, configure `"iterm2"` para usar explícitamente paneles divididos nativos de iTerm2. Este modo requiere la [CLI `it2`](https://github.com/mkusaka/it2) y muestra un error con el comando de instalación si falta `it2`. El indicador de configuración que ofrece instalar `it2` o cambiar a tmux aparece bajo `"auto"` o `"tmux"` cuando su terminal es iTerm2 y tmux está disponible como alternativa.
Para anular el valor predeterminado, configure [`teammateMode`](/es/settings#available-settings) en `~/.claude/settings.json`:
```json theme={null}
{
"teammateMode": "auto"
}
```
Para establecer el modo para una única sesión, páselo como una bandera:
```bash theme={null}
claude --teammate-mode auto
```
El modo de panel dividido requiere [tmux](https://github.com/tmux/tmux/wiki) o iTerm2 con la [CLI `it2`](https://github.com/mkusaka/it2). Para instalar manualmente:
* **tmux**: instale a través del gestor de paquetes de su sistema. Vea la [wiki de tmux](https://github.com/tmux/tmux/wiki/Installing) para instrucciones específicas de la plataforma.
* **iTerm2**: instale la [CLI `it2`](https://github.com/mkusaka/it2), luego habilite la API de Python en **iTerm2 → Settings → General → Magic → Enable Python API**.
Especificar compañeros de equipo y modelos
Claude decide el número de compañeros de equipo a generar según su tarea, o puede especificar exactamente lo que desea:
```text theme={null}
Spawn 4 teammates to refactor these modules in parallel. Use Sonnet for
each teammate.
```
Los compañeros de equipo no heredan la selección `/model` del líder de forma predeterminada. Para cambiar el modelo utilizado cuando el indicador no especifica uno, configure **Modelo de compañero de equipo predeterminado** en `/config`. Seleccione **Predeterminado (modelo del líder)** para que los compañeros de equipo sigan el modelo actual del líder.
{/* min-version: 2.1.186 */}Los compañeros de equipo heredan el [nivel de esfuerzo](/es/model-config#adjust-effort-level) del líder. En modo de panel dividido esto se aplica desde v2.1.186; las versiones anteriores no pasaban el esfuerzo de sesión del líder a los compañeros de equipo de panel dividido.
Requerir aprobación de plan para compañeros de equipo
Para tareas complejas o riesgosas, puede requerir que los compañeros de equipo planifiquen antes de implementar. El compañero de equipo trabaja en modo de plan de solo lectura hasta que el líder apruebe su enfoque:
```text theme={null}
Spawn an architect teammate to refactor the authentication module.
Require plan approval before they make any changes.
```
Cuando un compañero de equipo termina de planificar, envía una solicitud de aprobación de plan al líder. El líder revisa el plan y lo aprueba o lo rechaza con retroalimentación. Si se rechaza, el compañero de equipo permanece en modo de plan, revisa según la retroalimentación y reenvía. Una vez aprobado, el compañero de equipo sale del modo de plan y comienza la implementación.
El líder toma decisiones de aprobación de forma autónoma. Para influir en el juicio del líder, proporcione criterios en su indicación, como "solo aprueba planes que incluyan cobertura de pruebas" o "rechaza planes que modifiquen el esquema de la base de datos".
Hable directamente con los compañeros de equipo
Cada compañero de equipo es una sesión completa e independiente de Claude Code. Puede enviar un mensaje a cualquier compañero de equipo directamente para dar instrucciones adicionales, hacer preguntas de seguimiento o redirigir su enfoque.
* **Modo en proceso**: use las teclas de flecha arriba y abajo en el panel del agente para seleccionar un compañero de equipo, luego presione Intro para ver su sesión y escriba para enviarle un mensaje. Presione `x` en un compañero de equipo seleccionado para detenerlo. Presione Ctrl+T para alternar la lista de tareas.
* **Modo de panel dividido**: haga clic en el panel de un compañero de equipo para interactuar directamente con su sesión. Cada compañero de equipo tiene una vista completa de su propio terminal.
Asignar y reclamar tareas
La lista de tareas compartida coordina el trabajo en todo el equipo. El líder crea tareas y los compañeros de equipo las trabajan. Las tareas tienen tres estados: pendiente, en progreso y completada. Las tareas también pueden depender de otras tareas: una tarea pendiente con dependencias sin resolver no puede ser reclamada hasta que esas dependencias se completen.
El líder puede asignar tareas explícitamente, o los compañeros de equipo pueden auto-reclamar:
* **El líder asigna**: dígale al líder qué tarea dar a qué compañero de equipo
* **Auto-reclamar**: después de terminar una tarea, un compañero de equipo recoge la siguiente tarea sin asignar y sin bloquear por su cuenta
El reclamo de tareas usa bloqueo de archivos para prevenir condiciones de carrera cuando múltiples compañeros de equipo intentan reclamar la misma tarea simultáneamente.
Apagar compañeros de equipo
Para terminar gracefully la sesión de un compañero de equipo, refiriéndose a él por nombre. Por ejemplo, con un compañero de equipo llamado investigador:
```text theme={null}
Ask the researcher teammate to shut down
```
El líder envía una solicitud de apagado. El compañero de equipo puede aprobar, saliendo gracefully, o rechazar con una explicación.
Los directorios compartidos del equipo se limpian automáticamente cuando finaliza la sesión, por lo que no hay un paso de limpieza separado. Vea [Arquitectura](#architecture) para saber qué directorios se eliminan y cuáles persisten para sesiones reanudadas.
Aplicar puertas de calidad con hooks
Use [hooks](/es/hooks) para aplicar reglas cuando los compañeros de equipo terminen el trabajo o las tareas se creen o completen:
* [`TeammateIdle`](/es/hooks#teammateidle): se ejecuta cuando un compañero de equipo está a punto de quedarse inactivo. Salga con código 2 para enviar retroalimentación y mantener al compañero de equipo trabajando.
* [`TaskCreated`](/es/hooks#taskcreated): se ejecuta cuando una tarea está siendo creada. Salga con código 2 para prevenir la creación y enviar retroalimentación.
* [`TaskCompleted`](/es/hooks#taskcompleted): se ejecuta cuando una tarea está siendo marcada como completada. Salga con código 2 para prevenir la finalización y enviar retroalimentación.
Cómo funcionan los equipos de agentes
Esta sección cubre la arquitectura y la mecánica detrás de los equipos de agentes. Si desea comenzar a usarlos, vea [Controle su equipo de agentes](#control-your-agent-team) arriba.
Cómo Claude inicia equipos de agentes
Un equipo de agentes se forma cuando se genera el primer compañero de equipo, con la sesión principal actuando como el líder. Hay dos formas en que se generan los compañeros de equipo:
* **Usted solicita compañeros de equipo**: dé a Claude una tarea que se beneficie del trabajo paralelo y solicite explícitamente compañeros de equipo. Claude los genera según sus instrucciones.
* **Claude propone compañeros de equipo**: si Claude determina que su tarea se beneficiaría del trabajo paralelo, puede sugerir generar compañeros de equipo. Usted confirma antes de que proceda.
En ambos casos, usted mantiene el control. Claude no generará compañeros de equipo sin su aprobación.
Arquitectura
Un equipo de agentes consiste en:
| Componente | Rol |
| :----------------------- | :----------------------------------------------------------------------------------------- |
| **Líder del equipo** | La sesión principal de Claude Code que genera compañeros de equipo y coordina el trabajo |
| **Compañeros de equipo** | Instancias separadas de Claude Code que cada una trabaja en tareas asignadas |
| **Lista de tareas** | Lista compartida de elementos de trabajo que los compañeros de equipo reclaman y completan |
| **Buzón** | Sistema de mensajería para comunicación entre agentes |
Vea [Elegir un modo de visualización](#choose-a-display-mode) para opciones de configuración de visualización. Los mensajes de los compañeros de equipo llegan al líder automáticamente.
El sistema gestiona las dependencias de tareas automáticamente. Cuando un compañero de equipo completa una tarea de la que otras tareas dependen, las tareas bloqueadas se desbloquean sin intervención manual.
Los equipos y tareas se almacenan localmente bajo un nombre derivado de la sesión. El nombre es `session-` seguido de los primeros ocho caracteres del ID de sesión:
* **Configuración del equipo**: `~/.claude/teams/{team-name}/config.json`
* **Lista de tareas**: `~/.claude/tasks/{team-name}/`
Claude Code genera ambos automáticamente al inicio de la sesión y los actualiza a medida que los compañeros de equipo se unen, se quedan inactivos o se van. El directorio de configuración del equipo se elimina cuando la sesión termina. El directorio de lista de tareas persiste localmente y nunca se carga, por lo que las sesiones reanudadas mantienen sus tareas. La retención se rige por el mismo [`cleanupPeriodDays`](/es/settings#available-settings) que ya controla para transcripciones de sesión.
La configuración del equipo contiene estado de tiempo de ejecución como IDs de sesión e IDs de panel tmux, así que no la edite manualmente ni la pre-autorice: sus cambios se sobrescriben en la siguiente actualización de estado.
Para definir roles de compañeros de equipo reutilizables, use [definiciones de subagents](#use-subagent-definitions-for-teammates) en su lugar.
La configuración del equipo contiene un array `members` con el nombre de cada compañero de equipo, ID de agente y tipo de agente. Los compañeros de equipo pueden leer este archivo para descubrir otros miembros del equipo.
No hay equivalente a nivel de proyecto de la configuración del equipo. Un archivo como `.claude/teams/teams.json` en su directorio de proyecto no se reconoce como configuración; Claude lo trata como un archivo ordinario.
Usar definiciones de subagents para compañeros de equipo
Al generar un compañero de equipo, puede hacer referencia a un tipo de [subagent](/es/sub-agents) de cualquier [alcance de subagent](/es/sub-agents#choose-the-subagent-scope): proyecto, usuario, plugin o definido por CLI. Esto le permite definir un rol una vez, como un revisor de seguridad o ejecutor de pruebas, y reutilizarlo tanto como un subagent delegado como un compañero de equipo de equipo de agentes.
Para usar una definición de subagent, mencione por nombre cuando le pida a Claude que genere el compañero de equipo:
```text theme={null}
Genera un compañero de equipo usando el tipo de agente security-reviewer para auditar el módulo de autenticación.
```
El compañero de equipo honra los campos `tools` y `model` de esa definición, y el cuerpo de la definición se añade al prompt del sistema del compañero de equipo como instrucciones adicionales en lugar de reemplazarlo. Las herramientas de coordinación de equipos como `SendMessage` y las herramientas de gestión de tareas siempre están disponibles para un compañero de equipo incluso cuando `tools` restringe otras herramientas.
Los campos `skills` y `mcpServers` en la portada de una definición de subagent no se aplican cuando esa definición se ejecuta como un compañero de equipo. Los compañeros de equipo cargan skills y MCP servers desde su configuración de proyecto y usuario, igual que una sesión regular.
Permisos
Los compañeros de equipo comienzan con la configuración de permisos del líder. Si el líder se ejecuta con `--dangerously-skip-permissions`, todos los compañeros de equipo también lo hacen. Después de generar, puede cambiar los modos de compañeros de equipo individuales, pero no puede establecer modos por compañero de equipo en el momento de la generación.
Cuando un agente envía un mensaje a otro a través de `SendMessage`, se le dice al agente receptor que provino de otra sesión de Claude, no de usted. Un compañero de equipo no puede aprobar una solicitud de permiso o proporcionar consentimiento en su nombre, y un compañero de equipo al que se le negó una acción no puede retransmitirla a otro compañero de equipo para eludir la verificación. En [modo automático](/es/permission-modes#eliminate-prompts-with-auto-mode), el clasificador trata una afirmación de aprobación retransmitida desde otro agente como entrada no confiable en lugar de confirmación de usted. Las solicitudes de permiso de compañeros de equipo se propagan al líder de la sesión, así que apruébelas allí usted mismo.
Contexto y comunicación
Cada compañero de equipo tiene su propia ventana de contexto. Cuando se genera, un compañero de equipo carga el mismo contexto de proyecto que una sesión regular: CLAUDE.md, MCP servers y skills. También recibe la indicación de generación del líder. El historial de conversación del líder no se transfiere.
**Cómo los compañeros de equipo comparten información:**
* **Entrega automática de mensajes**: cuando los compañeros de equipo envían mensajes, se entregan automáticamente a los destinatarios. El líder no necesita sondear actualizaciones.
* **Notificaciones de inactividad**: cuando un compañero de equipo termina y se detiene, notifica automáticamente al líder.
* **Lista de tareas compartida**: todos los agentes pueden ver el estado de la tarea y reclamar trabajo disponible.
* **Mensajería de compañeros de equipo**: enviar un mensaje a un compañero de equipo específico por nombre. Para llegar a todos, envíe un mensaje por destinatario.
El líder asigna a cada compañero de equipo un nombre cuando lo genera, y cualquier compañero de equipo puede enviar un mensaje a otro por ese nombre. Para obtener nombres predecibles que pueda referenciar en indicaciones posteriores, dígale al líder cómo llamar a cada compañero de equipo en su instrucción de generación.
Uso de tokens
Los equipos de agentes usan significativamente más tokens que una única sesión. Cada compañero de equipo tiene su propia ventana de contexto, y el uso de tokens escala con el número de compañeros de equipo activos. Para investigación, revisión y trabajo de nuevas características, los tokens adicionales generalmente valen la pena. Para tareas rutinarias, una única sesión es más rentable. Vea [costos de tokens de equipos de agentes](/es/costs#agent-team-token-costs) para orientación de uso.
Ejemplos de casos de uso
Estos ejemplos muestran cómo los equipos de agentes manejan tareas donde la exploración paralela agrega valor.
Ejecutar una revisión de código paralela
Un único revisor tiende a gravitar hacia un tipo de problema a la vez. Dividir criterios de revisión en dominios independientes significa que la seguridad, el rendimiento y la cobertura de pruebas reciben atención exhaustiva simultáneamente. La indicación asigna a cada compañero de equipo una lente distinta para que no se superpongan:
```text theme={null}
Crea un equipo de agentes para revisar la PR #142. Genera tres revisores:
- Uno enfocado en implicaciones de seguridad
- Uno verificando impacto de rendimiento
- Uno validando cobertura de pruebas
Que cada uno revise e informe hallazgos.
```
Cada revisor trabaja desde la misma PR pero aplica un filtro diferente. El líder sintetiza hallazgos en los tres después de que terminen.
Investigar con hipótesis competidoras
Cuando la causa raíz es poco clara, un único agente tiende a encontrar una explicación plausible y dejar de buscar. La indicación lucha contra esto haciendo que los compañeros de equipo sean explícitamente adversarios: el trabajo de cada uno no es solo investigar su propia teoría sino desafiar las de los demás.
```text theme={null}
Los usuarios reportan que la aplicación se cierra después de un mensaje en lugar de
mantenerse conectada. Genera 5 compañeros de equipo de agentes para investigar
diferentes hipótesis. Haz que se hablen entre sí para intentar refutar las teorías
de los demás, como un debate científico. Actualiza el documento de hallazgos con
cualquier consenso que emerja.
```
La estructura de debate es el mecanismo clave aquí. La investigación secuencial sufre de anclaje: una vez que se explora una teoría, la investigación posterior está sesgada hacia ella.
Con múltiples investigadores independientes intentando activamente refutar mutuamente, la teoría que sobrevive es mucho más probable que sea la causa raíz real.
Mejores prácticas
Dé a los compañeros de equipo suficiente contexto
Los compañeros de equipo cargan contexto de proyecto automáticamente, incluyendo CLAUDE.md, MCP servers y skills, pero no heredan el historial de conversación del líder. Vea [Contexto y comunicación](#context-and-communication) para detalles. Incluya detalles específicos de la tarea en la indicación de generación:
```text theme={null}
Spawn a security reviewer teammate with the prompt: "Review the authentication module
at src/auth/ for security vulnerabilities. Focus on token handling, session
management, and input validation. The app uses JWT tokens stored in
httpOnly cookies. Report any issues with severity ratings."
```
Elegir un tamaño de equipo apropiado
No hay límite duro en el número de compañeros de equipo, pero se aplican restricciones prácticas:
* **Los costos de tokens escalan linealmente**: cada compañero de equipo tiene su propia ventana de contexto y consume tokens independientemente. Vea [costos de tokens de equipos de agentes](/es/costs#agent-team-token-costs) para detalles.
* **La sobrecarga de coordinación aumenta**: más compañeros de equipo significa más comunicación, coordinación de tareas y potencial para conflictos
* **Rendimientos decrecientes**: más allá de cierto punto, compañeros de equipo adicionales no aceleran el trabajo proporcionalmente
Comience con 3-5 compañeros de equipo para la mayoría de flujos de trabajo. Esto equilibra el trabajo paralelo con coordinación manejable. Los ejemplos en esta guía usan 3-5 compañeros de equipo porque ese rango funciona bien en diferentes tipos de tareas.
Tener 5-6 [tareas](/es/agent-teams#architecture) por compañero de equipo mantiene a todos productivos sin cambio de contexto excesivo. Si tiene 15 tareas independientes, 3 compañeros de equipo es un buen punto de partida.
Escale solo cuando el trabajo genuinamente se beneficie de tener compañeros de equipo trabajando simultáneamente. Tres compañeros de equipo enfocados a menudo superan a cinco dispersos.
Dimensionar tareas apropiadamente
* **Demasiado pequeñas**: la sobrecarga de coordinación excede el beneficio
* **Demasiado grandes**: los compañeros de equipo trabajan demasiado tiempo sin check-ins, aumentando el riesgo de esfuerzo desperdiciado
* **Justo bien**: unidades auto-contenidas que producen un entregable claro, como una función, un archivo de prueba o una revisión
El líder divide el trabajo en tareas y las asigna a los compañeros de equipo automáticamente. Si no está creando suficientes tareas, pídele que divida el trabajo en piezas más pequeñas. Tener 5-6 tareas por compañero de equipo mantiene a todos productivos y permite al líder reasignar trabajo si alguien se queda atrapado.
Espere a que los compañeros de equipo terminen
A veces el líder comienza a implementar tareas por sí mismo en lugar de esperar a los compañeros de equipo. Si nota esto:
```text theme={null}
Wait for your teammates to complete their tasks before proceeding
```
Comience con investigación y revisión
Si es nuevo en equipos de agentes, comience con tareas que tengan límites claros y no requieran escribir código: revisar una PR, investigar una biblioteca o investigar un error. Estas tareas muestran el valor de la exploración paralela sin los desafíos de coordinación que vienen con la implementación paralela.
Evitar conflictos de archivos
Dos compañeros de equipo editando el mismo archivo lleva a sobrescrituras. Divida el trabajo para que cada compañero de equipo posea un conjunto diferente de archivos.
Monitorear y dirigir
Verifique el progreso de los compañeros de equipo, redirija enfoques que no estén funcionando y sintetice hallazgos a medida que lleguen. Dejar que un equipo se ejecute desatendido durante demasiado tiempo aumenta el riesgo de esfuerzo desperdiciado.
Solución de problemas
Los compañeros de equipo no aparecen
Si los compañeros de equipo no aparecen después de que le pida a Claude que cree un equipo:
* En modo en proceso, los compañeros de equipo aparecen en el panel del agente debajo de la entrada del mensaje. Use las teclas de flecha arriba y abajo para seleccionar uno, luego presione Intro para verlo.
* Una fila de compañero de equipo que desapareció después de estar inactiva ha sido ocultada, no detenida. Las filas inactivas se ocultan después de 30 segundos y reaparecen en el siguiente turno del compañero de equipo. Envíe un mensaje al compañero de equipo por nombre para traerlo de vuelta.
* Verifique que la tarea que le dio a Claude fue lo suficientemente compleja para justificar un equipo. Claude decide si generar compañeros de equipo según la tarea.
* Si solicitó explícitamente paneles divididos, asegúrese de que tmux esté instalado y disponible en su PATH:
```bash theme={null}
which tmux
```
* Para iTerm2, verifique que la CLI `it2` esté instalada y la API de Python esté habilitada en las preferencias de iTerm2.
Demasiados avisos de permisos
Las solicitudes de permisos de compañeros de equipo suben al líder, lo que puede crear fricción. Pre-apruebe operaciones comunes en su [configuración de permisos](/es/permissions) antes de generar compañeros de equipo para reducir interrupciones.
Los compañeros de equipo se detienen en errores
Los compañeros de equipo pueden detenerse después de encontrar errores en lugar de recuperarse. Verifique su salida seleccionando el compañero de equipo en el panel del agente y presionando Intro en modo en proceso, o haciendo clic en el panel en modo dividido, luego:
* Deles instrucciones adicionales directamente
* Genere un compañero de equipo de reemplazo para continuar el trabajo
El líder se apaga antes de que el trabajo esté hecho
El líder puede decidir que el equipo está terminado antes de que todas las tareas estén realmente completas. Si esto sucede, dígale que continúe. También puede decirle al líder que espere a que los compañeros de equipo terminen antes de proceder si comienza a hacer trabajo en lugar de delegar.
Sesiones tmux huérfanas
Si una sesión tmux persiste después de que el equipo termina, puede no haber sido completamente limpiada. Enumere sesiones y mate la creada por el equipo:
```bash theme={null}
tmux ls
tmux kill-session -t
```
Limitaciones
Los equipos de agentes son experimentales. Las limitaciones actuales a tener en cuenta:
* **Sin reanudación de sesión con compañeros de equipo en proceso**: `/resume` y `/rewind` no restauran compañeros de equipo en proceso. Después de reanudar una sesión, el líder puede intentar enviar mensajes a compañeros de equipo que ya no existen. Si esto sucede, dígale al líder que genere nuevos compañeros de equipo.
* **El estado de la tarea puede retrasarse**: los compañeros de equipo a veces no marcan las tareas como completadas, lo que bloquea tareas dependientes. Si una tarea parece atrapada, verifique si el trabajo está realmente hecho y actualice el estado de la tarea manualmente o dígale al líder que empuje al compañero de equipo.
* **El apagado puede ser lento**: los compañeros de equipo terminan su solicitud actual o llamada de herramienta antes de apagarse, lo que puede tomar tiempo.
* **Un equipo por sesión**: una sesión tiene exactamente un equipo, limitado a esa sesión. No puede crear equipos nombrados adicionales ni compartir un equipo entre sesiones.
* **Sin equipos anidados**: los compañeros de equipo no pueden generar sus propios compañeros de equipo. Solo el líder puede gestionar el equipo.
* **El líder es fijo**: la sesión principal es el líder de por vida. No puede promover un compañero de equipo a líder ni transferir liderazgo.
* **Permisos establecidos en la generación**: todos los compañeros de equipo comienzan con el modo de permiso del líder. Puede cambiar modos de compañeros de equipo individuales después de generar, pero no puede establecer modos por compañero de equipo en el momento de la generación.
* **Los paneles divididos requieren tmux o iTerm2**: el modo en proceso predeterminado funciona en cualquier terminal. El modo de panel dividido no es compatible con la terminal integrada de VS Code, Windows Terminal o Ghostty.
**`CLAUDE.md` funciona normalmente**: los compañeros de equipo leen archivos `CLAUDE.md` de su directorio de trabajo. Use esto para proporcionar orientación específica del proyecto a todos los compañeros de equipo.
Próximos pasos
Explore enfoques relacionados para trabajo paralelo y delegación:
* **Delegación ligera**: [subagents](/es/sub-agents) generan agentes auxiliares para investigación o verificación dentro de su sesión, mejor para tareas que no necesitan coordinación entre agentes
* **Sesiones paralelas manuales**: [Git worktrees](/es/worktrees) le permiten ejecutar múltiples sesiones de Claude Code usted mismo sin coordinación de equipo automatizada
* **Comparar enfoques**: vea la comparación [subagent vs agent team](/es/features-overview#compare-similar-features) para un desglose lado a lado