Ejecuta varios agentes de Claude Code en paralelo: una guía visual

Claude Code es uno de los agentes de programación con IA más capaces que existen hoy. Razona a través de bases de código complejas, escribe código con calidad de producción y puede resolver de forma autónoma issues reales de GitHub. Pero si lo has usado en algún proyecto serio, habrás chocado con el mismo muro que encuentra todo usuario avanzado: solo puedes ejecutar un agente a la vez por terminal.

Esa restricción convierte lo que debería ser un flujo de trabajo en paralelo en un cuello de botella en serie. Quieres tu frontend refactorizado, tus endpoints de API actualizados y tu suite de tests ampliada, todo a la vez. En lugar de eso, te quedas haciendo de niñera de un solo terminal, esperando a que termine antes de empezar la siguiente tarea.

Esta guía te lleva paso a paso por la ejecución de varios agentes de Claude Code en paralelo usando SuperBuilder, una app de escritorio gratuita y de código abierto que te ofrece gestión visual de hilos, un sistema de cola inteligente y seguimiento de costes por agente. Al final, tendrás tres agentes trabajando simultáneamente en distintas partes de tu base de código.

Tabla de contenidos

• Por qué importan los agentes en paralelo
• El problema del CLI: qué falla con varios terminales
• El enfoque de SuperBuilder para la orquestación multiagente
• Paso 1: Configurar tu primer proyecto
• Paso 2: Lanzar tres agentes en paralelo
• Paso 3: Monitorizar el progreso de todos los agentes
• Paso 4: Revisar cambios y fusionar el trabajo
• Por dentro: arquitectura del sistema de cola
• Ejemplos de flujos de trabajo reales
• Consejos para ejecutar agentes en paralelo de forma eficaz
• Preguntas frecuentes
• Empieza con SuperBuilder

Por qué importan los agentes en paralelo

Los proyectos de software modernos no son de un solo hilo. Una funcionalidad típica implica cambios en varias capas: componentes de frontend, rutas de API de backend, migraciones de base de datos, tests y documentación. Cuando le pides a Claude Code que se encargue de una de esas capas, puede tardar entre dos y diez minutos según la complejidad.

Si trabajas de forma secuencial, una funcionalidad de tres capas se lleva entre 15 y 30 minutos de tiempo real en los que estás mayormente esperando. Si ejecutas tres agentes en paralelo, lo comprimes a 5-10 minutos. Eso no es una mejora marginal: es un cambio fundamental en la rapidez con la que puedes iterar.

Estos son los escenarios donde los agentes en paralelo aportan las mayores ganancias:

Desarrollo de funcionalidades full-stack. Un agente construye los componentes de React. Otro crea las rutas de API en Express. Un tercero escribe los tests de integración. Los tres trabajan en la misma base de código simultáneamente, cada uno en su propia rama o en su propia zona del código.

Refactorización a gran escala. Necesitas migrar 40 archivos de un patrón a otro. En lugar de pasárselos a un único agente de lote en lote, repartes el trabajo entre tres agentes que gestionan distintos directorios.

Investigación de bugs. Sospechas que el problema podría estar en la capa de autenticación, en las consultas a la base de datos o en la lógica de caché. Levanta tres agentes, cada uno investigando una hipótesis distinta. El que encuentre el bug termina primero; descartas los demás.

Ampliación de la cobertura de tests. Tu base de código tiene 200 archivos sin tests. Un agente escribe tests unitarios para las funciones de utilidad, otro se encarga de los handlers de API y un tercero cubre los componentes de React.

La cuenta es sencilla: si cada agente te ahorra 30 minutos al día y ejecutas tres en paralelo, recuperas una hora y media de tiempo productivo cada día.

El problema del CLI: qué falla con varios terminales

Claude Code se ejecuta en el terminal. Esa es una de sus fortalezas: se integra en los flujos de trabajo de desarrollo existentes sin obligarte a usar un IDE nuevo. Pero el terminal no se diseñó para orquestar varios agentes de IA de larga duración.

Esto es lo que ocurre cuando intentas ejecutar varias instancias de Claude Code manualmente:

Proliferación de pestañas de terminal. Abres tres o cuatro pestañas de terminal, cada una ejecutando una sesión distinta de Claude Code. En cuestión de minutos, pierdes la pista de qué hace cada pestaña. Cambias entre ellas intentando recordar si la pestaña 3 era el agente del frontend o el de testing. La carga mental borra las ganancias de productividad.

Sin vista unificada del progreso. Cada instancia de Claude Code transmite su propia salida de forma independiente. No hay un panel que te muestre de un vistazo el estado de todos los agentes. Tienes que comprobar manualmente cada terminal para ver si un agente sigue en marcha, esperando entrada o ya ha terminado.

Caos de rate limits. La API de Anthropic tiene límites de velocidad. Cuando ejecutas varios agentes a la vez, compiten por el mismo presupuesto de rate limit. Un agente recibe un error 429 y se detiene. No te das cuenta durante cinco minutos porque estabas mirando otro terminal. El agente se queda parado, perdiendo el tiempo.

Sin visibilidad de costes. Cada sesión de Claude Code hace seguimiento de su propio uso de tokens, pero no hay una vista agregada. Terminas una sesión multiagente y no tienes ni idea de cuánto ha costado. ¿Esa tarea de refactorización fueron 2 dólares o 20? Tendrías que sumar manualmente los costes de cada terminal.

Procesos zombi. Si un proceso de Claude Code se cuelga (por un problema de red, una respuesta malformada o un error de PTY), se queda ahí consumiendo recursos en silencio. No hay ningún vigilante que detecte los procesos atascados y los reinicie. Descubres el zombi diez minutos después, cuando revisas el terminal y ves que no ha producido salida.

Sin gestión de cola. Quieres enviar cinco tareas pero solo puedes ejecutar dos a la vez (rate limits). En el CLI, tendrías que esperar manualmente a que una termine y luego iniciar la siguiente. No hay un mecanismo de cola que gestione esto automáticamente.

Estos no son casos extremos. Son la realidad diaria de cualquier desarrollador que intente usar Claude Code a escala. La herramienta en sí es excelente; lo que falta es la capa de orquestación.

El enfoque de SuperBuilder para la orquestación multiagente

SuperBuilder es una app de escritorio gratuita y de código abierto (macOS, con Linux y Windows próximamente) que envuelve Claude Code en una interfaz visual creada específicamente para flujos de trabajo multiagente. No reemplaza a Claude Code: ejecuta el propio CLI de Claude Code por debajo mediante node-pty, preservando la compatibilidad total con tu configuración actual.

Esto es lo que añade por encima:

Barra lateral visual de hilos. Cada agente aparece como un hilo en una barra lateral, mostrando su estado actual (en marcha, inactivo, en cola, requiere atención), la tarea en la que trabaja y su tiempo de ejecución. Ves todos los agentes de un vistazo sin cambiar de pestaña.

Cola de mensajes inteligente. Cuando envías una tarea y no hay un slot de agente disponible, entra en una cola. SuperBuilder procesa la cola automáticamente a medida que los agentes se liberan. Puedes lanzar cinco tareas y marcharte: se ejecutarán en orden.

Reintento automático ante rate limits. Cuando un agente alcanza un rate limit, SuperBuilder lo detecta y reintenta automáticamente con backoff. Se acabaron los agentes parados por un error 429 que no habías notado.

Seguimiento de costes por agente. Cada hilo muestra su coste acumulado en tiempo real. Sabes exactamente cuánto cuesta cada tarea a medida que se ejecuta, y puedes ver el total de todos los agentes.

Detección de hilos zombi. Un recolector en segundo plano comprueba los procesos atascados cada 15 segundos. Si un agente no produce salida durante 60 segundos, se marca. Los agentes inactivos durante demasiado tiempo se eliminan y reinician automáticamente, manteniendo tu cola en movimiento.

Modos de ejecución. Cada agente puede ejecutarse en distintos modos: normal, plan (piensa primero, ejecuta después), verificar (revisa los cambios dos veces), depurar (prueba sistemática de hipótesis) o preguntar (solo responde una pregunta). Eliges el modo por tarea.

Veamos un flujo de trabajo multiagente completo desde cero.

Paso 1: Configurar tu primer proyecto

Descarga SuperBuilder desde superbuilder.sh e instálalo. En el primer arranque, detectará automáticamente tu instalación existente de Claude Code y tu clave de API.

1. Añade tu proyecto. Haz clic en el botón "+" de la barra lateral y selecciona el directorio de tu proyecto. SuperBuilder indexa la estructura de carpetas (respetando .gitignore) para que los agentes tengan contexto sobre tu base de código.

2. Verifica el acceso a Claude Code. SuperBuilder lanza Claude Code usando las mismas credenciales que ya tienes configuradas. Si puedes ejecutar claude en tu terminal, SuperBuilder funcionará. No se requieren claves de API ni configuración adicionales.

3. Comprueba tu CLAUDE.md. Si tu proyecto tiene un archivo CLAUDE.md (instrucciones para Claude Code), SuperBuilder lo pasa automáticamente. Tus agentes seguirán las mismas convenciones y patrones de programación que ya hayas definido.

4. Confirma que el proyecto aparece en la barra lateral. Deberías ver el nombre de tu proyecto con un icono de carpeta. Haz clic en él para abrir el espacio de trabajo del proyecto.

Eso es todo en cuanto a configuración. Sin contenedores de Docker, sin configuración de servidor, sin variables de entorno. SuperBuilder se ejecuta en local en tu máquina y se comunica directamente con la API de Anthropic a través de Claude Code.

Paso 2: Lanzar tres agentes en paralelo

Ahora pongamos a trabajar tres agentes simultáneamente. Usaremos un escenario realista: estás construyendo una nueva funcionalidad de ajustes de usuario que requiere componentes de frontend, endpoints de API y tests.

Agente 1: Componentes de frontend

Crea un nuevo hilo haciendo clic en "New Thread" o pulsando Cmd+N. En el campo de entrada del prompt, escribe:

Build a UserSettings page component with sections for profile info, 
notification preferences, and account security. Use our existing 
component library (see src/components/common/). Include form 
validation and loading states.

Pulsa Enter. El agente empieza a trabajar de inmediato. Verás cómo su estado cambia a "Running" en la barra lateral, y una vista de streaming muestra lo que está haciendo en tiempo real.

Agente 2: Endpoints de API

Sin esperar a que el Agente 1 termine, crea otro hilo nuevo (Cmd+N):

Create REST API endpoints for user settings: GET /api/settings, 
PUT /api/settings/profile, PUT /api/settings/notifications, 
PUT /api/settings/security. Follow the patterns in 
src/api/routes/. Include input validation with zod and proper 
error handling.

Este agente empieza de inmediato en su propio hilo. Ahora tienes dos agentes ejecutándose en paralelo.

Agente 3: Suite de tests

Crea un hilo más:

Write comprehensive tests for the user settings feature. Cover:
1. Unit tests for the settings API route handlers (use our 
   existing test setup in tests/api/)
2. Integration tests for the settings endpoints
3. Component tests for UserSettings using React Testing Library
Generate test fixtures and mock data as needed.

Ahora tienes tres agentes ejecutándose en paralelo, cada uno visible en la barra lateral con su propio indicador de estado. La barra lateral muestra:

• Hilo 1: "UserSettings page component..." -- En marcha (2m 15s)
• Hilo 2: "REST API endpoints for user..." -- En marcha (1m 42s)
• Hilo 3: "Tests for user settings..." -- En marcha (0m 58s)

Si tu rate limit solo permite dos sesiones concurrentes, el tercer agente entra en la cola automáticamente y arranca en cuanto se libera un slot. No necesitas gestionar esto manualmente.

Paso 3: Monitorizar el progreso de todos los agentes

Mientras los agentes están en marcha, tienes varias formas de monitorizar el progreso:

Barra lateral de hilos

La barra lateral te da una vista general de todos los agentes activos. Cada hilo muestra:

• Insignia de estado: En marcha (verde), En cola (amarillo), Inactivo (gris), Requiere atención (rojo)
• Vista previa de la tarea: la primera línea del prompt que enviaste
• Tiempo de ejecución: cuánto tiempo lleva trabajando el agente
• Coste: coste de API acumulado de este hilo

Vista de conversación

Haz clic en cualquier hilo para ver su flujo completo de conversación. La salida de Claude Code aparece en tiempo real: puedes ver qué archivos está leyendo, qué ediciones está haciendo y qué comandos está ejecutando. Es la misma salida que verías en el terminal, pero formateada para facilitar la lectura.

Cambiar entre agentes

Haz clic entre los hilos de la barra lateral para comprobar distintos agentes. Cada hilo mantiene su propia posición de scroll y su propio estado. No pierdes contexto al cambiar: todo se conserva.

Seguimiento de costes

Cada hilo muestra su coste en marcha. Tras una sesión multiagente, puedes ver exactamente cuánto costó cada tarea. Un desglose típico podría verse así:

• Componentes de frontend: 1,20 dólares
• Endpoints de API: 0,85 dólares
• Suite de tests: 1,45 dólares
• Total de la sesión: 3,50 dólares

Esta visibilidad te permite tomar decisiones informadas sobre qué tareas merece la pena automatizar y cuáles es mejor hacer manualmente.

Paso 4: Revisar cambios y fusionar el trabajo

Una vez que los tres agentes terminan, necesitas revisar e integrar sus cambios. Este es el flujo de trabajo recomendado:

Revisa la salida de cada agente. Recorre cada hilo y revisa la conversación. Claude Code te muestra exactamente qué archivos creó o modificó, con diffs. Comprueba que el código cumple tus expectativas.

Ejecuta tus comprobaciones habituales. Abre un hilo nuevo y pídele a Claude Code que ejecute tu linting, tu comprobación de tipos y tu suite de tests sobre los cambios combinados:

Run the full test suite, type checking, and linter. Fix any 
issues that come up from the recent changes to user settings.

Gestiona los conflictos. Si los agentes modificaron archivos solapados (poco frecuente cuando las tareas están bien delimitadas, pero posible), verás conflictos de fusión. Puedes pedirle a un nuevo agente que los resuelva:

There are merge conflicts in src/types/settings.ts between the 
API and frontend changes. Resolve them, keeping both sets of 
type definitions.

Itera. Si la salida de un agente necesita refinamiento, envía un mensaje de seguimiento en ese mismo hilo. El agente conserva todo el contexto de la conversación y puede hacer ajustes precisos sin releer toda la base de código.

Por dentro: arquitectura del sistema de cola

La fiabilidad de SuperBuilder viene de su sistema de cola, que gestiona las complicadas realidades de ejecutar varios procesos de Claude Code. Entender cómo funciona te ayuda a usarlo de forma más eficaz.

Procesamiento de la cola de mensajes

Cuando envías un mensaje en un hilo, entra en una cola persistente respaldada por SQLite. El procesador de la cola comprueba dos cosas antes de despachar:

1. ¿Ya se está ejecutando el hilo? Si es así, el mensaje espera hasta que la tarea actual se complete.
2. ¿Hay slots disponibles? SuperBuilder respeta tus límites de concurrencia para evitar machacar los rate limits.

Los mensajes se procesan en orden por hilo, pero los distintos hilos se procesan de forma independiente. Esto significa que el Hilo 2 no espera a la cola del Hilo 1, solo a la suya propia.

Detección de hilos zombi

Uno de los problemas más frustrantes con los agentes CLI de larga duración es el colgado de procesos. Un timeout de red, una respuesta de API malformada o un error de PTY pueden dejar un proceso atascado indefinidamente. SuperBuilder gestiona esto en varios niveles:

Seguimiento de fallos de parseo. Cada respuesta de Claude Code se parsea como JSON (Claude Code usa --output-format stream-json). Si un hilo genera más de 10 fallos de parseo en 5 segundos (normalmente causados por una salida corrupta con códigos de escape ANSI en lugar de JSON válido), SuperBuilder elimina y reinicia el proceso automáticamente.

Detección de inactividad. Un recolector en segundo plano se ejecuta cada 15 segundos y comprueba todos los hilos activos. Cualquier hilo que no haya producido salida en 60 segundos se marca como potencialmente atascado. La función de eliminación de emergencia termina el proceso de PTY y libera el slot de la cola.

Timeout de arranque. Cuando se lanza un nuevo proceso de Claude Code, arranca un temporizador de 30 segundos. Si el proceso no confirma que está en marcha dentro de esa ventana, se elimina y la tarea se vuelve a poner en cola. Esto evita que la cola se quede permanentemente bloqueada por un proceso que no arrancó.

Gestión de rate limits

Cuando Claude Code recibe un rate limit 429 de la API de Anthropic, SuperBuilder detecta el error en el flujo de salida. En lugar de dejar que el agente falle:

1. Pausa el hilo
2. Espera a que pase la ventana del rate limit (usando backoff exponencial)
3. Reintenta la solicitud automáticamente
4. Actualiza el estado del hilo para que puedas ver qué pasó

Esto significa que puedes encolar más tareas de las que tu rate limit permite técnicamente, y SuperBuilder las irá soltando poco a poco a medida que haya capacidad disponible.

Difusión e IPC

Todos los eventos de los agentes (nueva salida, cambios de estado, actualizaciones de coste, finalización de hilos) se difunden a cada ventana abierta usando el sistema IPC de Electron. Esto evita el bug de fallo silencioso que aqueja a los enfoques manuales: si una ventana estuviera temporalmente no disponible cuando se disparó un evento, no se pierde ningún dato. La difusión recorre todas las ventanas activas y entrega a cada una de forma independiente.

Ejemplos de flujos de trabajo reales

Aquí tienes tres flujos de trabajo de producción que demuestran la potencia de los agentes en paralelo.

Flujo 1: Sprint en una rama de funcionalidad

Estás construyendo una renovación de la autenticación. Creas cuatro agentes:

Tiempo secuencial: ~24 minutos. Tiempo en paralelo: ~8 minutos. Los agentes trabajan en archivos distintos, así que los conflictos son mínimos. El agente de documentación termina primero y lo revisas mientras los demás siguen en marcha.

Flujo 2: Migración de la base de código

Necesitas migrar 120 componentes de CSS Modules a Tailwind. Los repartes en tres lotes por directorio:

• Agente 1: src/components/common/ (40 componentes)
• Agente 2: src/components/features/ (45 componentes)
• Agente 3: src/components/layouts/ (35 componentes)

Cada agente recibe las mismas instrucciones con un alcance de directorio distinto. Se ejecutan simultáneamente y terminan con pocos minutos de diferencia entre sí. Después ejecutas un cuarto agente para verificar que todos los cambios compilan y que no se rompió ningún estilo.

Flujo 3: Investigación de un bug

Tu monitorización de producción muestra errores 500 intermitentes. No estás seguro de dónde está el bug, así que despliegas en abanico:

• Agente 1: "Investiga el middleware de autenticación en busca de condiciones de carrera. Revisa src/middleware/auth.ts y archivos relacionados."
• Agente 2: "Investiga el pool de conexiones de la base de datos en busca de patrones de fugas. Revisa src/db/pool.ts y los logs de consultas."
• Agente 3: "Investiga la capa de caché de Redis en busca de problemas de datos obsoletos. Revisa src/cache/ y las configuraciones de TTL."

El Agente 2 encuentra el bug (una conexión que no se libera en una ruta de error) en 4 minutos. Detienes los otros dos agentes y le pides al Agente 2 que implemente el arreglo. Tiempo total de investigación: 4 minutos en lugar de los más de 12 que habría llevado de forma secuencial.

Consejos para ejecutar agentes en paralelo de forma eficaz

Delimita las tareas para minimizar el solapamiento de archivos. La mayor fuente de problemas con los agentes en paralelo es que dos agentes editen el mismo archivo a la vez. Diseña tus prompts para que cada agente trabaje en una parte distinta de la base de código. Reparte por directorio, por capa (frontend/backend/tests) o por límite de funcionalidad.

Usa el modo plan para tareas arriesgadas. Si un agente trabaja en código crítico, usa el modo de ejecución "Plan". El agente describirá qué planea hacer y esperará tu aprobación antes de hacer cambios. Esto añade un paso de revisión sin perder los beneficios del paralelismo en tus otros agentes.

Empieza con dos agentes y luego escala. Si eres nuevo en los flujos de trabajo multiagente, empieza con dos agentes en paralelo. Acostúmbrate al flujo de monitorización y revisión antes de añadir un tercero o cuarto. La carga cognitiva de gestionar cuatro agentes es real: SuperBuilder ayuda, pero aun así tienes que revisar la salida.

Usa rutas de archivo específicas en los prompts. Cuanto más específico sea tu prompt, menos tiempo dedica el agente a explorar. En lugar de "actualiza los tests", di "escribe tests para src/api/routes/settings.ts en tests/api/settings.test.ts". Esto reduce el tiempo de ejecución, el coste y la probabilidad de conflictos de archivos.

Deja que la cola trabaje por ti. No necesitas esperar a que los agentes terminen antes de enviar más tareas. Encola todas tus tareas de una vez y deja que SuperBuilder gestione la programación. Esto es especialmente útil al final del día: encola cinco tareas, márchate y revisa los resultados por la mañana.

Monitoriza los costes sobre la marcha. El seguimiento de costes por hilo no es solo para la facturación: es una señal de la complejidad de la tarea. Si un agente está quemando tokens, puede estar atascado en un bucle o explorando demasiado en amplitud. Compruébalo y refina el prompt si es necesario.

Preguntas frecuentes

¿Cuántos agentes puedo ejecutar simultáneamente?

SuperBuilder en sí no tiene un límite estricto de hilos concurrentes. El límite práctico viene de los rate limits de la API de Anthropic en el nivel de tu cuenta. La mayoría de los desarrolladores encuentran que de 2 a 4 agentes concurrentes es el punto óptimo: suficiente para ver aceleraciones significativas sin chocar constantemente con los rate limits.

¿Esto requiere una clave de API o suscripción especial?

No. SuperBuilder usa tu configuración existente de Claude Code. Si tienes Claude Code funcionando en tu terminal, SuperBuilder funcionará. Ejecuta el mismo binario del CLI claude por debajo.

¿Entrarán en conflicto los agentes en paralelo entre sí?

Pueden hacerlo, si los pones a trabajar en los mismos archivos. La clave es delimitar tus tareas para que cada agente trabaje en una parte distinta de la base de código. SuperBuilder no impone bloqueos de archivos: confía en que diseñes tareas sin solapamiento. Si se producen conflictos, puedes resolverlos con un agente de seguimiento.

¿Es gratis SuperBuilder?

Sí. SuperBuilder es gratuito y de código abierto (licencia MIT). Puedes descargarlo desde superbuilder.sh o compilarlo desde el código fuente en GitHub.

¿Funciona SuperBuilder en Linux y Windows?

La versión de macOS está disponible ahora. Las builds de Linux y Windows están en marcha y se esperan pronto. Como SuperBuilder está construido sobre Electron, el trabajo multiplataforma es principalmente empaquetado y testing.

¿Qué pasa si un agente se cae?

El sistema de detección de zombis de SuperBuilder captura los agentes caídos o colgados automáticamente. El proceso se elimina, el slot de la cola se libera y puedes volver a ejecutar la tarea. Los detalles del fallo quedan registrados para que puedas ver qué salió mal.

¿Puedo usar esto con otras herramientas de programación con IA además de Claude Code?

Actualmente SuperBuilder está construido específicamente para Claude Code. La compatibilidad con otros agentes de programación basados en CLI (como Aider u OpenCode) está en la hoja de ruta.

Empieza con SuperBuilder

Ejecutar varios agentes de Claude Code en paralelo es el mayor desbloqueo de productividad para los desarrolladores que ya usan Claude Code a diario. SuperBuilder lo hace práctico con gestión visual, manejo automático de la cola y las funciones de fiabilidad necesarias para sesiones multiagente de larga duración.

Descarga SuperBuilder gratis en superbuilder.sh.

Lleva menos de dos minutos instalarlo y no requiere configuración adicional más allá de lo que ya tienes para Claude Code. Ábrelo, añade tu proyecto y empieza hoy mismo tu primer flujo de trabajo multiagente.

Si te resulta útil, dale una estrella al repo en GitHub y compártelo con tu equipo. Cada contribución y cada comentario ayudan a mejorar el desarrollo multiagente para todos.