De un agente a múltiples agentes: guía práctica de migración

La mayoría de los desarrolladores que usan herramientas de programación con IA hoy ejecutan un solo agente cada vez. Abres Claude Code, le das una tarea, esperas a que termine y luego le das la siguiente. Funciona. Pero es secuencial.

En el momento en que ejecutas dos agentes en paralelo, algo cambia. Dejas de ser un mecanógrafo esperando una salida. Te conviertes en un orquestador: asignas trabajo, enrutas resultados y centras tu atención donde más importa.

Esta entrada repasa los pasos prácticos para pasar de desarrollo con un solo agente a desarrollo multiagente, y el cambio de modelo mental que lo hace productivo.

El cuello de botella del agente único

Un solo agente de IA, por capaz que sea, tiene una limitación fundamental: solo puede hacer una cosa a la vez. Cuando Claude Code está refactorizando tu módulo de autenticación, no puede estar escribiendo pruebas para tu capa de API. Tú esperas.

La matemática es sencilla. Si cada tarea lleva 5 minutos de trabajo del agente y tienes 10 tareas, un solo agente tarda 50 minutos. Dos agentes lo reducen a 25. Pero la ganancia real no es solo el tiempo de reloj: es el bucle de feedback.

Con dos agentes trabajando sobre código relacionado, la salida del refactor del Agente A puede alimentar inmediatamente el proceso de revisión del Agente B. Los problemas aparecen antes. El contexto está más fresco. Detectas los fallos de integración en minutos, no en horas.

Paso 1: identifica el trabajo paralelizable

No todas las tareas se benefician de la paralelización. Los mejores candidatos son:

• Módulos independientes: refactorizar autenticación mientras construyes un nuevo endpoint de API.
• Fases secuenciales: un agente escribe código y otro lo revisa.
• Perspectivas complementarias: un agente se centra en la implementación y otro en las pruebas.

Los peores candidatos son las tareas con acoplamiento fuerte: dos agentes editando el mismo archivo crearán conflictos de merge.

Como regla general: si asignarías las tareas a dos desarrolladores distintos, pueden ejecutarse en dos agentes distintos.

Paso 2: organización espacial

Los flujos basados en pestañas se desmoronan con varios agentes. No puedes escanear tres pestañas de terminal a la vez: se solapan, pierdes contexto y olvidas qué hace cada una.

Ahí es donde importa la disposición espacial. En un canvas, colocas los agentes donde puedas verlos. Terminal A a la izquierda, Terminal B a la derecha, una tile de notas en el centro siguiendo el plan. Con una sola mirada sabes el estado de todo.

El modelo espacial no es solo estético. Es cognitivo. La investigación sobre cognición externa muestra que la disposición física de la información reduce la carga de la memoria de trabajo. El canvas es una extensión de tu modelo mental.

Paso 3: define el flujo de información

Con varios agentes, necesitas un plan sobre cómo circula la información entre ellos. Hay tres patrones comunes:

Pipeline

Agente A → Agente B → Agente C

La salida de cada agente alimenta al siguiente. Ejemplo: A escribe código → B lo revisa → C escribe pruebas.

Fan-out / Fan-in

        → Agente B →
Agente A                 Agente D
        → Agente C →

Un agente distribuye trabajo, varios agentes lo ejecutan en paralelo y los resultados convergen. Ejemplo: A divide una tarea en subtareas → B y C resuelven una subtarea cada uno → D integra los resultados.

Bucle de revisión

Agente A ⇄ Agente B

Dos agentes iteran sobre el mismo trabajo. A escribe, B revisa, A revisa de nuevo. Esto converge más rápido de lo que parece: normalmente en 2 o 3 rondas.

Paso 4: automatiza el traspaso

La mayor fricción del trabajo multiagente está en el traspaso. Copiar manualmente la salida del Agente A, reformatearla como prompt y pegarla en el Agente B es tedioso y propenso a errores.

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.

Paso 5: supervisa e interviene

El trabajo multiagente requiere un patrón de atención distinto. En lugar de concentrarte profundamente en la salida de un solo agente, vas escaneando entre agentes y buscando:

• Agentes bloqueados: esperando permiso o entrada.
• Agentes completados: listos para la siguiente tarea o traspaso.
• Agentes desviados: yendo por el camino equivocado.

Los indicadores visuales ayudan muchísimo. Los indicadores de estado codificados por color (trabajando, esperando, detenido) te permiten priorizar de un vistazo. Las animaciones de pulso atraen la mirada hacia los agentes activos. El brillo en el borde de la pantalla te avisa de actividad fuera del canvas.

El objetivo es reducir la carga cognitiva de supervisión para que puedas centrarte en las decisiones creativas: qué construir, cómo arquitecturarlo y dónde invertir tu atención.

El cambio de modelo mental

El cambio más profundo del trabajo multiagente no es técnico. Es cómo piensas tu rol.

Con un solo agente, eres un compañero de programación. Tú y el agente compartís el foco en una sola cosa a la vez.

Con varios agentes, eres un tech lead. Marcas la dirección, asignas trabajo, revisas resultados y tomas decisiones arquitectónicas. Los agentes se encargan de la ejecución.

Este cambio resulta incómodo al principio. Sientes que deberías estar mirando cada línea de salida de cada agente. Pero eso no escala. En su lugar, aprendes a confiar en el proceso, intervenir cuando hace falta y centrarte en las decisiones que realmente requieren tu criterio.

Cómo empezar

Si hoy ejecutas un solo agente, prueba esto:

1. Abre una segunda terminal con el mismo agente en una tarea distinta.
2. Colócalas una al lado de la otra para ver ambas.
3. Cuando la primera termine, envía manualmente sus hallazgos clave a la segunda.
4. Observa cuánto más rápido avanza la segunda tarea con ese contexto.

Eso es el desarrollo multiagente en su forma más simple. Todo lo demás - enrutamiento automatizado, organización del canvas, detección de estado - es infraestructura para que ese patrón básico resulte sin esfuerzo.