# Equipo de agentes de IA: manager, roles y traspasos

URL: https://agentvera.dev/es/blog/ai-agent-team/ · Publicado: 2026-10-18

Crea un equipo de agentes de IA con manager, roles claros y líneas de reporte: cuándo supera a un solo agente o a una ejecución paralela y cómo montarlo paso a paso.

**En resumen:**

- Un equipo de agentes tiene cuatro partes: manager, roles, líneas de reporte y traspasos; admite hasta 24 miembros, pero lo práctico son de 3 a 5 agentes.
- Guardar un equipo no inicia nada; el trabajo empieza al darle una tarea al equipo, que por defecto va al manager, y los agentes se escriben entre sí aunque usen CLI distintas.
- Un equipo paralelo es distinto: divide un trabajo en hasta 8 partes, cada una en su propio worktree, y las fusiona en una rama de integración.

Un agente de código es un gran compañero de programación en pareja. Cuando el trabajo incluye varios tipos de tareas (planificar, escribir código, revisarlo, probarlo), un solo agente empieza a hacer malabares. Pierde el hilo del plan mientras arregla un test, o revisa su propio código y no encuentra nada mal. Un equipo de agentes de IA reparte esa carga como lo haría un equipo humano: un agente lidera, los demás se encargan de un rol y todos saben a quién pasarle el trabajo.

En este artículo explico qué es realmente un equipo multiagente, cuándo compensa el esfuerzo extra de configuración frente a un solo agente o una ejecución paralela, y cómo montar uno en la vista de equipo de AgentVera.

## Qué es un equipo de agentes de IA

Un equipo de agentes de IA es un conjunto de agentes de código que trabajan hacia un mismo objetivo con una estructura alrededor. Esa estructura es lo que separa a un equipo de unas cuantas terminales que casualmente están abiertas a la vez. Tiene cuatro partes:

- **Un manager:** un agente recibe la petición, la divide en piezas, las reparte y comprueba lo que vuelve.
- **Roles:** cada miembro tiene un trabajo, como investigador, desarrollador, revisor o tester, más instrucciones que dicen qué debe tocar y qué no.
- **Líneas de reporte:** cada miembro reporta a alguien. Si no lo configuras, reporta al manager.
- **Traspasos:** un miembro también puede tener una siguiente parada fija para su trabajo terminado; por ejemplo, el desarrollador se lo pasa al revisor y el revisor al tester.

Los agentes hablan entre sí directamente. Un tester que encuentra un bug no espera a que copies el fallo en la terminal del desarrollador; envía el mensaje él mismo.

## Cuándo un equipo supera a un solo agente

Un equipo cuesta más tokens y más atención que un único agente, así que tiene que ganarse su sitio. Así lo decido yo con esta tabla:

| Situación | Mejor opción | Por qué |
| --- | --- | --- |
| Un arreglo pequeño en uno o dos archivos | Un agente | Dividir añade sobrecarga y no hay nada que dividir |
| Una funcionalidad con planificación, código, revisión y tests | Equipo de agentes | Cada etapa tiene un objetivo distinto y una mirada nueva ayuda |
| Un trabajo grande con partes claramente separadas | Equipo paralelo | Las partes se ejecutan en sus propios worktrees y se fusionan en una rama |
| Trabajo continuo durante horas o días | Equipo de agentes | El equipo sigue abierto y mantiene sus roles entre tareas |
| Comparar dos enfoques para un mismo problema | Dos agentes lado a lado | Quieres respuestas independientes, no coordinación |

La versión corta: recurre a un equipo cuando el trabajo tiene **distintos tipos de pasos** que se benefician de roles separados, y cuando quieres que los agentes sigan coordinándose a medida que el trabajo cambia. Si solo necesitas rendimiento bruto en piezas independientes, una ejecución paralela es más sencilla. Escribí sobre ese lado en [Agentes de código en paralelo](/es/blog/parallel-coding-agents/) y [Ejecutar varios agentes de Claude Code](/es/blog/run-multiple-claude-code-agents/).

### Equipo de agentes frente a equipo paralelo

Ambos aparecen en AgentVera y resuelven problemas distintos:

- **La vista de equipo** organiza agentes que ya están abiertos en un equipo duradero. Mantienen sus roles, hablan entre sí y comparten una lista de tareas y un tablero.
- **Un [equipo paralelo](/es/features/parallel-team/)** lo inicia un agente para un trabajo concreto. Divide el trabajo en hasta 8 partes, ejecuta cada una en su propio git worktree, fusiona las partes terminadas en una rama de integración y lanza una comprobación final. Ahí termina, y tú decides si abres un pull request.

También se combinan bien: el manager de un equipo puede iniciar un equipo paralelo cuando una de sus tareas es lo bastante grande como para dividirla.

## Diseñar el equipo

Antes de abrir ninguna ventana, esboza el equipo en papel. Tres preguntas cubren casi todo.

### 1. ¿Quién lidera?

El manager debería ser el agente en el que más confíes para planificar. Lee la petición, la desglosa y decide quién hace qué. Dale instrucciones sobre cómo quieres que se revise el trabajo, por ejemplo «no marques una tarea como terminada hasta que el tester haya ejecutado los tests».

### 2. ¿Qué roles necesita realmente el trabajo?

Empieza con poco. Un desarrollador, un revisor y un tester bajo un manager cubren la mayor parte del trabajo de funcionalidades. Añade un investigador cuando el trabajo requiera leer antes de programar, o un rol de documentación cuando el cambio toque APIs públicas. Cada agente extra es otro contexto que llenar y otro puñado de tokens que gastar.

### 3. ¿Por dónde fluye el trabajo?

Dibuja dos tipos de líneas:

1. **Reporta a:** quién responde ante quién. Decide a quién pregunta el agente cuando se atasca.
2. **Pasa su trabajo a:** la siguiente parada del trabajo terminado. Una cadena típica es desarrollador → revisor → tester.

Mantén la cadena corta. Una cadena larga significa que un cambio pequeño espera muchos turnos antes de que nadie te diga que está listo.

## Montarlo en la vista de equipo de AgentVera

La [vista de equipo](/es/features/team-view/) convierte ese esbozo en un equipo funcional. La abres desde el icono de equipo de un grupo o desde la parte superior de la barra lateral.

### Paso 1: coloca los agentes

La ventana muestra **Team structure** junto a una reserva llamada **Agents in the workspace**. Arrastra agentes desde la reserva a la estructura, o usa **Open a new agent** para iniciar uno para un rol que aún no tengas. El primer agente que marques como **Manager** lidera el equipo. Un equipo tiene un manager y hasta 24 miembros, y cada miembro debe ser un agente del proyecto del grupo. Las sesiones de terminal quedan fuera.

Si prefieres no empezar de cero, **Ready-made teams** te da un kit completo:

- **Software team:** un tech lead con un planificador, desarrollador, revisor y tester.
- **Research team:** un líder de investigación con un investigador y un redactor de informes.
- **Social media team:** un social media manager con un investigador de tendencias, copywriter, diseñador visual y especialista en anuncios. Redacta borradores y te pregunta antes de publicar nada o gastar dinero.

Un kit abre por ti los agentes nuevos que necesita.

### Paso 2: dale un rol a cada agente

Selecciona un agente y define su **Role** y sus **Instructions**. **Ready-made roles** rellenan un nombre e instrucciones por ti: investigador, planificador, desarrollador, revisor, tester, DevOps, diseñador, documentación y seguridad. Varios agentes pueden compartir un rol, lo cual es útil cuando dos desarrolladores se reparten el front end y el back end.

### Paso 3: dibuja las líneas

Cada miembro tiene **Reports to** y **Hands its work to**. Puedes definirlos desde los campos o arrastrando un agente sobre otro y eligiendo «Report to…», «Hand its work to…» o «Swap places with…». **Arrange automatically** ordena la disposición. Un miembro sin línea de reporte reporta al manager, y si creas un bucle por accidente, se redirige de nuevo al manager.

### Paso 4: dale herramientas al equipo

En **Team’s MCP servers** eliges los servidores que recibe cada miembro. Cada rol puede añadir los suyos además, por ejemplo Playwright para el tester o una herramienta de diseño para el diseñador. Un agente puede excluirse en sus propios ajustes. Si un servidor sugerido aún no está instalado, recibes un aviso y puedes añadirlo desde el catálogo. Los agentes cuyas herramientas cambiaron se reinician cuando termina su turno actual, así que nada se corta a mitad de tarea. Explico los servidores MCP con más detalle en [Qué es un servidor MCP](/es/blog/what-is-mcp-server/).

### Paso 5: guarda y dale trabajo al equipo

**Save and open the team** mete a los agentes en el grupo, para que puedan escribirse y compartir la lista de tareas y el tablero. Guardar no inicia nada. El trabajo empieza cuando usas **Give to the team**: la petición va por defecto al manager, o a cualquier agente que elijas. Cada agente recibe una explicación de su rol, y esa explicación solo se repite cuando el equipo cambia. Si la mensajería entre agentes estaba desactivada, se activa.

## Ver trabajar al equipo

La pestaña **Team** muestra la estructura en directo. Los agentes que trabajan brillan, los mensajes viajan como luz por las líneas y aparece un bocadillo sobre el agente que está hablando. Junto a ella:

- **Team status** muestra el paso actual de cada agente: editando, leyendo, ejecutando un comando, buscando, planificando o enviando mensajes.
- **Activity** es el feed de mensajes, trabajo y eventos de agentes, con filtros para All, Messages, Work y Agents.
- **Tasks** es la lista compartida a la que los agentes añaden, reclaman y terminan tareas.
- **Waiting for you** reúne las solicitudes de permiso, que puedes aprobar o rechazar ahí mismo.

Cuando necesitas dirigir, **Status report** le pide al manager un resumen breve de lo que hace cada agente, qué está hecho y dónde se atasca el equipo. Cuando escribes a un agente, **Interrupt and redirect** detiene lo que está haciendo y le pasa tu mensaje de inmediato, mientras que **Queue** se lo pasa cuando termina su trabajo actual. **Interrupt all** interrumpe a todos los agentes que estén trabajando tras una confirmación.

### Cómo hablan los agentes

Por debajo, la [mensajería entre agentes](/es/features/agent-messaging/) da a cada agente herramientas para listar a los demás, enviar un mensaje (y opcionalmente esperar la respuesta), responder y trabajar con la lista de tareas compartida. Un agente ocupado recibe el mensaje cuando termina su turno, así que nadie es interrumpido a mitad de una edición. Los mensajes se marcan como procedentes de otro agente, y cada remitente tiene un límite de frecuencia para que dos agentes no entren en un bucle infinito. Funciona entre CLI: Claude Code, Codex, Gemini CLI y las demás usan las mismas herramientas.

## Errores comunes

- **Demasiados agentes desde el primer día.** Cinco agentes en un cambio pequeño gastan la mayoría de sus turnos leyendo los mensajes de los demás. Empieza con tres y añade roles cuando aparezca un hueco.
- **Roles vagos.** «Ayudar con el código» no es un rol. Di qué posee el agente, qué carpetas puede cambiar y qué significa «hecho» para él.
- **Sin revisor ni tester.** Un equipo donde el desarrollador comprueba su propio trabajo es solo un agente con pasos de más.
- **Archivos con propietarios solapados.** Dos desarrolladores en los mismos archivos se pisarán. Divide por carpetas, o deja que el manager inicie un [equipo paralelo](/es/features/parallel-team/) para que cada parte tenga su propio worktree. Consulta [Git worktrees para agentes en paralelo](/es/blog/git-worktree-parallel-agents/).
- **Dar trabajo a todos los agentes a la vez.** Deja que el manager lo reparta. Para eso sirve tener uno.
- **Ignorar las aprobaciones.** Un agente que espera una solicitud de permiso bloquea a todos los que vienen después. Vigila la barra de atención.

## Lista de comprobación

- [ ] Un manager con instrucciones sobre cómo revisar el trabajo
- [ ] Cada rol tiene un responsable, un alcance y una definición de «hecho» claros
- [ ] Líneas de reporte y traspasos dibujados, con la cadena corta
- [ ] Un revisor o tester en algún punto de la cadena
- [ ] Servidores MCP del equipo y de los roles elegidos e instalados
- [ ] La primera petición escrita para el manager, no para cada agente

## Para terminar

Un equipo de agentes de IA compensa cuando el trabajo tiene pasos distintos y quieres que los gestionen agentes que sigan coordinándose sin que tú retransmitas mensajes. La estructura es sencilla: un manager, unos pocos roles bien descritos y líneas cortas de reporte y traspaso. Empieza poco a poco, observa la primera ejecución en la pestaña Team y afina los roles donde veas agentes esperando o repitiéndose. Si prefieres pensar en etapas fijas, [los pipelines de flujo de trabajo con agentes de IA](/es/blog/ai-agent-workflow-pipeline/) cubren ese enfoque.

AgentVera te deja montar el equipo con los agentes que ya tienes abiertos, sea cual sea la CLI que ejecuten. Puedes [empezar gratis](/es/) y consultar los [planes](/es/pricing/) cuando necesites más.

## Preguntas frecuentes

**¿Qué es un equipo de agentes de IA?** Es un grupo de agentes de código que trabajan en un mismo objetivo con una estructura clara: un manager que divide y revisa el trabajo, miembros con roles como desarrollador o tester, y líneas definidas de quién reporta a quién y quién pasa el trabajo a quién.

**¿Puede un equipo de agentes de IA mezclar Claude Code, Codex y otras CLI?** Sí. En AgentVera cualquier agente abierto en el proyecto puede unirse al equipo, sea cual sea la CLI que ejecute. Los agentes se escriben mediante las mismas herramientas, así que Claude Code puede hacerle una pregunta a Codex y recibir la respuesta.

**¿Cuántos agentes puede haber en un equipo?** Un equipo de AgentVera admite hasta 24 miembros con un manager. En la práctica, un equipo pequeño de tres a cinco agentes es más fácil de seguir y gasta menos tokens.

**¿En qué se diferencia un equipo de agentes de un equipo paralelo?** Un equipo de agentes es un grupo duradero de agentes abiertos que siguen hablando entre sí. Un equipo paralelo divide un trabajo en partes, ejecuta cada una en su propio git worktree y termina como una única rama fusionada desde la que puedes abrir un pull request.

**¿El equipo empieza a trabajar en cuanto lo guardo?** No. Guardar solo configura la estructura y el grupo. Nada empieza hasta que le das trabajo al equipo, que va por defecto al manager o a cualquier agente que elijas.

---

**Sobre AgentVera.** AgentVera es una app de escritorio para macOS, Windows y Linux, desarrollada por Solviera Teknoloji. Ejecuta 18 agentes de programación con IA (Claude Code, Codex, Gemini CLI, Copilot, Cursor, Antigravity, opencode, Hermes, Qwen Code, Kimi Code, Kiro, Amp, Droid, Goose, Vibe, Crush, Aider, Cline) en paralelo, por proyecto, en terminales reales con las instalaciones y sesiones de CLI del propio usuario. El plan gratuito tiene agentes ilimitados. Descargar: https://agentvera.dev/es/download/ · Precios: https://agentvera.dev/es/pricing/