Cómo ejecutar varios agentes de IA al mismo tiempo

Ejecutar un agente de IA a la vez es lo habitual. Pero nada impide ejecutar dos, tres o cinco agentes en paralelo, cada uno trabajando en una parte distinta de tu proyecto. Aquí verás cómo hacerlo, qué debes vigilar y cuándo tiene sentido.

¿Por qué ejecutar varios agentes?

La razón más simple: el tiempo. Si tienes tres tareas independientes y cada una lleva 5 minutos de trabajo del agente, hacerlas en secuencia tarda 15 minutos. Hacerlas en paralelo tarda 5.

Pero el ahorro de tiempo no es la única ventaja:

• Especialización: distintos agentes pueden encargarse de distintos tipos de trabajo. Usa Claude Code para refactors complejos, Codex para prototipado rápido y un script de shell para tareas mecánicas.
• Bucles de revisión: un agente escribe código y otro lo revisa. Obtienes feedback inmediato sin esperar.
• Separación de contexto: cada agente recibe un contexto limpio centrado en su tarea específica, en lugar de un contexto sobrecargado que intenta hacer malabares con todo.

Método 1: varias ventanas de terminal

El enfoque más sencillo. Abre varias terminales e inicia un agente en cada una.

Terminal 1:

cd ~/project
claude  # Start Claude Code for auth refactoring

Terminal 2:

cd ~/project
claude  # Start Claude Code for API tests

Terminal 3:

cd ~/project
codex   # Start Codex for documentation

Esto funciona, pero tiene un gran inconveniente: solo puedes ver una terminal a la vez (o dividir la pantalla en paneles diminutos). Cuando el Agente 1 termina, no lo sabrás a menos que cambies a esa terminal y lo compruebes.

Método 2: paneles divididos con tmux

tmux te permite distribuir varias sesiones de terminal en una sola ventana:

tmux new-session -s agents
# Ctrl+b % to split vertically
# Ctrl+b " to split horizontally

Mejor que ventanas separadas: puedes ver varios agentes a la vez. Pero los paneles de tmux forman una cuadrícula fija. Con 3 o más agentes, cada panel se vuelve demasiado pequeño para leer cómodamente. Y no hay indicación visual del estado del agente (trabajando, esperando, terminado).

Método 3: espacio de trabajo basado en canvas

El enfoque más eficaz para 2 o más agentes es un espacio de trabajo visual basado en canvas. Coloca cada agente en un tile distinto sobre un canvas infinito. Organízalos espacialmente según su papel en el flujo de trabajo.

Ventajas frente a ventanas de terminal y tmux:

• Redimensionado libre: da más espacio al agente en el que estés centrado.
• Indicadores de estado del agente: ve de un vistazo cuáles están trabajando, esperando o terminados.
• Conexiones de enrutamiento: pasa automáticamente la salida de un agente a otro.
• Persistencia: tu disposición se guarda. Cierra y vuelve a abrir, y todo seguirá donde lo dejaste.

MadoHub está hecho para esto: te da un canvas infinito donde ejecutas agentes basados en terminal dentro de tiles arrastrables y redimensionables, con detección de estado en tiempo real.

Qué vigilar

Conflictos de archivos

Dos agentes editando el mismo archivo al mismo tiempo crearán conflictos. Antes de ejecutar agentes en paralelo, asegúrate de que trabajen en archivos o módulos distintos.

Buena división paralela:

• El Agente A trabaja en src/auth/ mientras el Agente B trabaja en src/api/

Mala división paralela:

• El Agente A y el Agente B modifican ambos src/config/database.ts

Uso de recursos

Cada sesión de agente de IA consume RAM (por el terminal y el proceso del agente) y créditos de API. Ejecutar 5 instancias de Claude Code al mismo tiempo significa 5 veces el uso de API. Vigila el consumo si tienes un plan medido.

Contaminación de contexto

Si varios agentes trabajan en el mismo repositorio git, los cambios no confirmados de uno pueden confundir a otro que lea los mismos archivos. Soluciones:

• Ramas git: cada agente trabaja en una rama distinta.
• Directorios independientes: si las tareas son realmente independientes, usa copias separadas del proyecto.
• Dependencias secuenciales: el Agente B solo empieza cuando el Agente A confirma sus cambios.

Cuándo usar varios agentes

La regla general: si puedes dividir el trabajo limpiamente en piezas independientes con fronteras claras, varios agentes serán más rápidos. Si el trabajo está muy acoplado, es mejor un solo agente con contexto completo.

Automatizar el traspaso

El mayor punto de fricción con varios agentes es mover información manualmente entre ellos. Cuando el Agente A termina y necesitas contarle al Agente B qué pasó, acabas copiando texto, reformulándolo como prompt y pegándolo.

El enrutamiento automatizado elimina esa fricción. Cuando el Agente A termina, el sistema:

1. Detecta la finalización (mediante patrones de salida o detección de inactividad).
2. Extrae la salida relevante.
3. La transforma en un prompt adecuado para el Agente B.
4. La entrega.

La fase de transformación es crítica. La salida cruda del terminal es ruidosa: códigos ANSI, barras de progreso, logs verbosos. Un buen sistema de enrutamiento extrae el contenido semántico y lo presenta como una instrucción accionable.

Cómo empezar

1. Elige dos tareas de tu proyecto actual que sean independientes.
2. Abre dos terminales una al lado de la otra.
3. Inicia un agente en cada una.
4. Observa cómo cambia tu patrón de atención: pasas de concentrarte en una tarea a escanear dos.
5. Cuando una termine, intenta enviar manualmente su salida clave a la otra.

Cuando hayas hecho esto manualmente y hayas notado la ventaja, entenderás por qué existen el enrutamiento automatizado y los espacios de trabajo visuales. Hacen que la versión manual resulte casi sin esfuerzo.