Claude Code Agent Teams: el futuro del desarrollo asistido por IA

En aplicaciones a gran escala o entornos empresariales, el contexto se agota antes de lo que crees. Una decisión de diseño importante que tomaste hace una hora probablemente ya no está en el contexto, así que tienes que volver a explicar cosas que el modelo ya había trabajado. Estás haciendo casi todo bien, pero el problema es que le pides a un solo asistente el trabajo de todo un equipo.

Claude Code Agent Teams nació para cambiar esto. La idea es que, en lugar de una única sesión haciendo todo en serie, inicies varios agentes especializados que comparten una lista de tareas, se envían mensajes directos entre sí y ejecutan el trabajo en paralelo.

En este artículo, te explico cómo funcionan los equipos de agentes, qué hace cada rol especializado y cómo coordinarlos en proyectos de software reales.

¿Nuevo en Claude Code? Domina lo básico en una tarde con nuestro curso Claude Code 101.

¿Qué son los equipos de agentes de Claude Code?

Claude Code Agent Teams son una capa de coordinación que permite que varias sesiones de Claude Code trabajen en el mismo proyecto al mismo tiempo. Una sesión asume el rol de líder del equipo y crea otras sesiones, llamadas compañeros, para encargarse de partes concretas del trabajo.

Cada compañero se ejecuta como una instancia completa e independiente de Claude Code con su propia ventana de contexto. Comparten una lista de tareas, se adjudican trabajo a medida que aparece y se envían mensajes directos cuando necesitan coordinarse.

Este enfoque va mucho más allá de abrir un par de pestañas del terminal y ejecutar Claude en cada una. Si haces eso, las ventanas de chat separadas no ven el progreso de las otras ni pueden acordar quién hace qué. Un equipo de agentes, en cambio, da a cada sesión una vista compartida del trabajo y un canal de comunicación. El líder mantiene a todos alineados.

En la práctica, esto significa que tú dejas de ser el relevo entre sesiones. El equipo se coordina solo, y tú intervienes solo para marcar dirección y revisar resultados.

Por qué existen los equipos de agentes

Una única sesión de Claude Code funciona bien hasta que el proyecto se hace demasiado grande.

Cada sesión tiene una ventana de contexto, y esa ventana tiene un límite. Mientras trabajas, la sesión se llena con contenidos de archivos, salidas de comandos, debates de diseño y tu propio ida y vuelta. Llegado un punto, la información más antigua ya no está en el contexto y el modelo empieza a olvidar decisiones que tomaste antes en la misma tarea.

Hay tres situaciones comunes en las que esto se ve claro:

• Repositorios grandes: una base de código con cientos de archivos no cabe entera en contexto. La sesión acaba leyendo los mismos archivos una y otra vez, gastando tokens para reconstruir entendimiento que ya tenía.
• Proyectos complejos: funcionalidades transversales, como añadir autenticación en backend, frontend y tests, obligan al modelo a manejar demasiadas preocupaciones a la vez. Cada una compite por espacio con todas las demás.
• Varias tareas simultáneas: pedir a una sola sesión que implemente una feature, refactorice un módulo, escriba tests y actualice la documentación en la misma conversación es buscarse problemas.

La respuesta es la misma a la que llegaron los equipos humanos hace décadas: divide el trabajo.

Si una sesión topa con sus límites en un refactor, da los cambios de backend a un compañero, los de frontend a otro y las actualizaciones de tests a un tercero. Cada compañero carga solo lo que necesita para su parte.

Lo mismo aplica a la investigación. Una tarea con tres hipótesis en competencia avanza más rápido cuando tres compañeros investigan cada una en paralelo y luego comparan notas, en lugar de que una sesión las recorra secuencialmente.

La especialización te da profundidad y el paralelismo, velocidad. Combinados, te permiten hacer trabajos que una sola sesión acabaría alucinando o tardaría demasiado en completar.

Cómo funcionan los equipos de agentes de Claude Code

Una sesión de equipo avanza por cinco etapas, con la orquestación gestionada dentro de Claude Code.

• Definir el objetivo: describe lo que quieres en lenguaje claro, como si enviaras un briefing a un ingeniero junior. El líder lo lee y decide cómo desglosarlo.
• Delegar el trabajo: el líder crea una lista de tareas compartida y lanza compañeros, cada uno con nombre, rol y prompt inicial. Puedes especificar la estructura del equipo o dejar que el líder la determine.
• Ejecutar en paralelo: cada compañero toma tareas, las marca en progreso, las completa y las marca como hechas. Las dependencias se respetan automáticamente; el bloqueo de archivos evita conflictos. Los compañeros pueden enviarse mensajes directos —sin pasar por el líder—.
• Combinar resultados: el líder recoge el trabajo acabado, resuelve conflictos y produce una única salida: un PR, un informe, un módulo refactorizado o lo que pida el objetivo.
• Revisar el resultado: revisas el resultado final como cualquier pull request: lees el diff, ejecutas el código y compruebas los tests.

Roles especializados en Agent Teams

Los roles dan forma al equipo de agentes. Sin ellos, acabas con sesiones genéricas haciendo trabajo solapado. Claude Code no trae una lista cerrada — defines los roles en tu briefing o apuntando al líder a una definición de subagente guardada en .claude/agents/.

Agente de planificación

Rompe el objetivo en tareas antes de escribir código. Explora la base de código, mapea dependencias y produce una lista de tareas autónomas que un solo compañero pueda terminar sin tener que consultar a cada paso.

En la práctica, el propio líder suele asumir este rol. También puedes ejecutar un compañero dedicado a la planificación cuando el trabajo sea lo bastante grande como para justificarlo.

Agente de desarrollo

Escribe la implementación. La mayoría de compañeros serán agentes de desarrollo, cada uno dueño de una parte distinta —backend, frontend, base de datos, funcionalidades de IA—. La clave es evitar solapamientos: dos compañeros editando el mismo archivo se pisarán cambios.

Estos agentes funcionan bien en modelos más económicos. Muchos equipos ejecutan el líder en Opus y a los compañeros en Sonnet, ya que la ejecución no requiere la misma profundidad de razonamiento que la coordinación.

Agente de testing

Escribe y ejecuta tests. Puede trabajar contra un contrato de API acordado mientras el compañero de desarrollo aún construye el endpoint —de modo que, cuando llegue el código, los tests ya estén listos.

También puedes mantener un compañero de testing activo toda la sesión, reejecutando la suite cada vez que un compañero de desarrollo marca una tarea como completa.

Agente de revisión

Lee diffs y detecta bugs, problemas de estilo, casos límite no cubiertos y cuestiones de seguridad. Dividir la revisión entre dos compañeros con enfoques distintos —uno de seguridad, otro de rendimiento— funciona especialmente bien, con el líder consolidando sus hallazgos.

Si ya has escrito una definición de subagente para tu proyecto, el compañero hereda sus herramientas y prompt del sistema automáticamente.

Agente de documentación

Redacta docstrings, actualizaciones de README y documentación más extensa como notas de arquitectura o referencias de API. Suele ser el último en ejecutarse: cuando desarrollo y testing terminan, la forma final del trabajo ya está clara.

Por qué la especialización mejora los resultados

Una sesión generalista tiene que mantener implementación, tests, docs y feedback de revisión en contexto a la vez. Un compañero especializado carga solo lo que necesita, manteniendo su contexto pequeño y su razonamiento enfocado. Además, facilita el debug: si algo falla, sabes exactamente qué sesión revisar.

Desarrollo en paralelo con Agent Teams

El paralelismo es el punto fuerte de un equipo de agentes.

Cuando el líder ha dividido el trabajo en tareas y ha iniciado a los compañeros, todos se ejecutan a la vez. Cada compañero es una sesión independiente de Claude Code, así que el trabajo no queda en cola detrás de una sola ventana de contexto. El tiempo total para terminar una funcionalidad de varias partes pasa de ser la suma de todas a ser el de la parte más lenta.

Estas tres combinaciones funcionan especialmente bien en paralelo:

• Frontend y backend en paralelo: cuando construyes una nueva funcionalidad que usa ambas capas, el compañero de backend puede crear el endpoint de la API mientras el de frontend crea el componente que lo consume. Se coordinan por mensajes directos. En cuanto backend decide la forma de la respuesta, se la envía a frontend y ambos siguen sin esperar a que el otro termine del todo.
• Implementación y testing en paralelo: el compañero de desarrollo escribe la implementación mientras el de testing redacta los tests contra el contrato acordado. Cuando el de desarrollo marca la tarea como completa, los tests ya están listos para ejecutarse. Es mucho más rápido que escribir primero el código y añadir tests al final.
• Documentación y code review en paralelo: cuando un compañero de desarrollo termina una parte, el de documentación puede empezar con docstrings y actualizaciones de README mientras el de revisión lee el diff en busca de bugs y problemas de estilo. Ninguno bloquea al otro y ambos entregan su salida para que el líder la combine.

El límite está en los conflictos de archivos. Dos compañeros escribiendo en el mismo archivo a la vez se sobrescribirán, así que el líder debe dividir el trabajo por archivos o módulos. Mientras las partes estén claras, puedes ejecutar tantos compañeros en paralelo como permita tu lista de tareas.

Claude Code Agent Teams para bases de código grandes

En bases de código grandes, los equipos de agentes pasan de ser un “nice-to-have” a algo imprescindible.

Un repositorio con cientos o miles de archivos no cabe en una sola ventana de contexto. Una sesión en solitario dedicada a una base de código grande gasta buena parte del presupuesto redescubriendo el código.

Con Agent Teams, cada compañero carga solo los archivos relevantes para su parte, así que la ventana de contexto por compañero se mantiene pequeña y enfocada. El equipo, como conjunto, puede razonar sobre todo el repositorio, pero ninguna sesión tiene que abarcarlo todo.

Esto importa especialmente en tres casos:

• Cambios transversales: un refactor que toca decenas de archivos en múltiples módulos es difícil para una sola sesión sin perder el hilo. Dividir por módulo y asignar cada uno a un compañero mantiene el alcance de cada cual bajo control.
• Auditorías de todo el repositorio: una revisión de seguridad o un análisis de rendimiento en una base de código grande se beneficia de ejecutar varios compañeros en paralelo, cada uno mirando una parte distinta. El líder luego combina sus hallazgos en un único informe.
• Proyectos de larga duración: un proyecto de varias semanas acumula contexto que una sola sesión no puede retener. Los equipos de agentes permiten dividir el trabajo en checkpoints, cada uno a cargo de un compañero que no necesita recordar todo lo anterior.

Hay un coste.

Cada compañero es una sesión completa de Claude Code con su propia ventana de contexto, así que el uso de tokens escala linealmente con el tamaño del equipo. Un equipo de cuatro usa aproximadamente cuatro veces los tokens de una sola sesión para la misma cantidad de trabajo. Algunas estimaciones lo sitúan incluso más alto. La contrapartida es menos tiempo de reloj y mayor profundidad por preocupación, lo que suele compensar en trabajos que una sola sesión no puede terminar de forma realista.

Cuanto más grande es el proyecto, más se gana con Agent Teams. Pero no lo sobreutilices: para un bug pequeño, una sola sesión es más barata e igual de efectiva.

Agent Teams y Claude Tag

Los equipos de agentes no son el único frente donde Anthropic está replanteando cómo encaja la IA en los flujos de trabajo de los equipos.

Claude Tag es una función aparte que lleva Claude a Slack como participante compartido de la organización. Etiquetas a @Claude en un canal y Claude asume trabajo usando las herramientas de tu organización y el contexto del canal. Recuerda lo tratado, hace seguimiento por iniciativa propia y actúa bajo la identidad de tu organización.

Ambas funciones resuelven problemas de coordinación distintos. Agent Teams coordina varias sesiones de Claude Code en el ordenador de un desarrollador para una tarea focalizada. Claude Tag coordina una identidad de Claude entre un equipo humano en Slack durante días y semanas. Pero la dirección es la misma: la IA pasa de ser una herramienta que usa una persona en solitario a un participante que opera dentro del flujo de trabajo del equipo.

Esto cambia qué debe saber hacer bien la IA.

Un asistente en solitario debe ser un gran generalista, pero un sistema coordinado debe ser un gran especialista que sepa planificar, traspasar trabajo, pedir ayuda y mantenerse alineado con otros agentes y personas. Agent Teams hace eso para los flujos de Claude Code, y Claude Tag lo visibiliza en el flujo de Slack.

Mejores prácticas para crear equipos de agentes

Un buen montaje de equipo de agentes va, sobre todo, de hacer bien la preparación. El equipo en sí es rápido, pero el tiempo que perderás vendrá de tareas mal acotadas y roles ambiguos.

Algunas buenas prácticas:

• Define claramente los roles: cada compañero debe tener un foco y un conjunto de archivos de los que es dueño. Al crearlo, indica exactamente de qué es responsable, de qué no y qué archivos o módulos puede tocar. Los roles vagos generan solapamientos, y los solapamientos generan conflictos de merge.

• Descompón tareas antes de paralelizar: planifica primero, paraleliza después. Haz una pasada de planificación para dividir el trabajo en tareas con entradas, salidas y dependencias claras, y luego entrega el plan al equipo para ejecutarlo. Un plan cuesta unos miles de tokens, pero un equipo yendo en la dirección equivocada puede costar cientos de miles.

• Comparte estándares con CLAUDE.md: cada compañero lee el archivo CLAUDE.md del directorio de trabajo al iniciarse, así que incluye ahí vuestras convenciones compartidas: estilo de código, estructura de archivos, enfoque de tests y formato de commits.

• Incluye checkpoints de revisión: verifica el progreso de los compañeros, redirige a quienes se desvíen y revisa la salida del líder antes de aceptarla. Para tareas arriesgadas, exige aprobación del plan antes de que cualquier compañero haga cambios. Obliga así a mostrar el plan primero y esperar la aprobación del líder.

• Limita el tamaño del equipo: empieza con entre tres y cinco compañeros en la mayoría de flujos. A partir de ahí, la sobrecarga de coordinación crece más rápido que la aceleración del paralelismo.

• Evita conflictos de archivos: divide el trabajo por archivos o módulos para separar claramente a cada compañero. Dos compañeros editando el mismo archivo se sobrescribirán. Si una tarea requiere que varios compañeros toquen el mismo archivo, ejecútala en secuencia en vez de en paralelo.

• Preaprueba operaciones comunes: las solicitudes de permiso de los compañeros escalan al líder, y un equipo con cuatro compañeros puede generar cuatro veces más prompts. Configura tu lista permissions.allow antes de iniciar el equipo para que operaciones rutinarias como leer archivos o ejecutar tests no interrumpan el trabajo.

• Ajusta el modelo al rol: ejecuta el líder en un modelo más potente como Opus, porque la coordinación se beneficia de mayor razonamiento, y a los compañeros en Sonnet para la ejecución.

En resumen: crea un plan de trabajo detallado, haz el briefing al equipo como a un grupo de ingenieros junior, dales alcances claros y estándares compartidos, y revisa su trabajo al final. Cuanto más se acerque tu configuración a cómo opera un equipo de ingeniería real, mejor rendirá el equipo de agentes.

Claude Code Agent Team en la práctica

Aquí tienes todo el proceso de principio a fin.

Veremos un ejemplo pequeño: una API REST “hello world” en FastAPI que lee un mensaje de una base de datos SQLite, más una mini página HTML que llama a la API y muestra el resultado. La app tiene una ruta de backend, una capa de base de datos, un frontend estático y documentación en el README, lo que la hace ideal para un equipo de cuatro.

Activa los equipos de agentes

Los equipos de agentes son una función experimental y vienen desactivados. Los activas definiendo una variable de entorno, ya sea en tu shell o en el archivo de configuración de Claude Code.

El archivo de configuración está en ~/.claude/settings.json. Ábrelo y añade:

{
  "env": {
    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
  }
}

Si prefieres no editar el archivo de configuración, puedes definir la variable en tu shell antes de iniciar Claude Code:

export CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1

Ambos enfoques funcionan. Una vez definida la variable, Claude Code reconocerá prompts relacionados con equipos e iniciará la capa de coordinación cuando se lo pidas.

Inicia Claude Code y haz el briefing al equipo

Crea un directorio vacío para el proyecto e inicia Claude Code dentro:

mkdir hello-api && cd hello-api
claude

Ahora haz el briefing al equipo. El prompt es lenguaje natural, pero cuanto más específico seas sobre roles y límites, mejor rendirá el equipo. Este es el prompt para la API hello world:

Create an agent team to build a small "hello world" REST API.

The project is a FastAPI service that returns a greeting from a SQLite
database, plus a tiny HTML page that calls the API and shows the result.
- One teammate on the database: create app/db.py with a sqlite3 connection
  to a greetings.db file. Define a get_greeting() function that returns
  the message column from the first row. On import, create the table if
  it doesn't exist and seed it with "Hello, World!" if empty.
- One teammate on the backend: build a FastAPI app in app/main.py with
  a GET /greeting endpoint that calls get_greeting() from app/db.py.
  Add permissive CORS and mount the static/ directory at the root so
  the HTML page is served from the same origin.
- One teammate on the frontend: build static/index.html as a single page
  that fetches /greeting on load, shows a spinner while loading, displays
  the greeting in a centered card on success, and shows an error message
  on failure. Inline the CSS and JavaScript.
- One teammate on docs: write README.md with installation, run, and
  open-in-browser steps, plus an API reference table. Also create
  requirements.txt with fastapi and uvicorn[standard].
Use Sonnet for each teammate. Require plan approval before any teammate
makes changes.

Hay tres cosas a destacar en este prompt. Los límites por archivo (app/db.py, app/main.py, static/index.html, README.md, requirements.txt) evitan solapes. La elección de modelo (Sonnet) mantiene los costes de tokens a raya. Y plan approval obliga a cada compañero a mostrar su plan antes de escribir código, lo que te da un punto de control para redirigir a quien haya entendido mal el briefing.

Mira al equipo en acción

Tras enviar el prompt, el líder divide el trabajo en tareas e inicia a los compañeros. Verás un panel de agentes en la parte inferior del terminal con una fila por compañero.

Agentes creados

Cada fila muestra el nombre del compañero y qué está haciendo. El líder rellena la lista de tareas compartida y asigna o libera tareas según dependencias. El compañero de backend espera a la capa de base de datos porque importa get_greeting() de ella. El compañero de docs espera hasta que el resto esté lo bastante avanzado como para describirlo con precisión.

También puedes ver la lista de tareas. Pulsa Ctrl+T para alternarla. La lista muestra cada tarea, su estado (pendiente, en progreso o completada) y qué compañero la tiene.

Muévete entre compañeros

Cada compañero es una sesión completa de Claude Code, y puedes hablar con cualquiera.

En el panel de agentes, usa las flechas arriba y abajo para seleccionar un compañero y pulsa Enter para abrir su transcripción. Ahora estás en la sesión de ese compañero, y lo que escribas irá a él, no al líder. Así es como das contexto extra a un compañero concreto o rediriges su enfoque sin involucrar al resto.

Pulsa Esc para volver al líder.

Redirige a un compañero que se desvía

A veces un compañero entiende mal el briefing o se pone con trabajo que no le corresponde. Lo detectas al revisar su plan durante la aprobación o al ver su progreso desviarse en el panel.

Si usas aprobación de plan, el compañero se detiene tras planificar y te muestra su propuesta antes de escribir archivos. Así se ve para el agente de base de datos:

Aprobación del agente de base de datos

Puedes leer el esquema y el enfoque propuestos, luego aprobar o rechazar con feedback. Si falta algo, responde con algo como "Usa SQLAlchemy en lugar de sqlite3 en crudo" y el compañero replanteará.

Si detectas un problema cuando ya ha empezado, selecciona al compañero en el panel, pulsa Enter para abrir su sesión y envíale un mensaje. También puedes pulsar x sobre un compañero seleccionado para detenerlo, o pedir al líder que inicie un sustituto si el actual está totalmente atascado.

Cierra y revisa

Cuando todos los compañeros terminen, el líder te devolverá un resumen breve y los comandos para ejecutar el proyecto.

Instrucciones finales del líder

Ahora revisa el trabajo. Puedes abrir los archivos generados en tu editor y leer los diffs.

El archivo app/main.py generado

También puedes inspeccionar la base de datos que creó y pobló el agente de base de datos.

La tabla greetings

Luego instala las dependencias, ejecuta uvicorn app.main:app --reload y abre http://localhost:8000 en tu navegador para confirmar que todo el stack funciona de extremo a extremo.

App final

Si quieres cambios, indica al líder qué ajustar y él mismo lo corregirá o iniciará un nuevo compañero para abordarlo. Cuando estés satisfecho con el resultado, puedes pedir al líder que haga el commit de los cambios. El líder apaga a los compañeros cuando la sesión termina y se limpia la configuración del equipo.

¡Y listo!

Conclusión

Claude Code Agent Teams va de dos cosas: especialización y coordinación. Cada compañero tiene su parte del trabajo y su propia ventana de contexto. El líder los mantiene alineados, la lista de tareas los sincroniza y la mensajería directa evita que tengan que esperar a que tú retransmitas información entre sesiones.

La gran foto es que el desarrollo asistido por IA está pasando de solitario a coordinado. Agent Teams es cómo aparece ese cambio hoy en Claude Code, y el mismo patrón se ve en Claude Tag para Slack. Quienes se acostumbren ahora a este enfoque pasarán menos tiempo lidiando con límites de contexto y más tiempo entregando funcionalidades reales.

¿Buscas certificarte en IA generativa? Aquí tienes las mejores certificaciones de IA generativa en 2026 con cursos destacados, consejos de preparación y FAQs.