Multi-Agent Coordination No es Añadir Más Agentes — Es Saber Cuándo No Usarlos

Multi-Agent Coordination No es Añadir Más Agentes — Es Saber Cuándo No Usarlos

Programming· 8 min read

El 90% de los Sistemas Multi-Agent en Producción No Son Multi-Agent

Abres el dashboard de tu agente. Ves tres "agentes" ejecutándose — análisis, redacción, revisión. Cada uno con su system prompt. Cada uno con su personalidad.

*El problema: son el mismo LLM con una máscara diferente. *

No hay coordinación real. No hay jerarquía. No hay validación cruzada. Lo que tienes no es un sistema multi-agente. Es un solo LLM instanciado tres veces con prompts distintos, lanzando mensajes al vacío y esperando que colaboren.

La industria te vende que más agentes = más capacidad.

La realidad: 3 agentes mal coordinados producen peores resultados que 1 agente bien diseñado.

Y el 90% de las implementaciones actuales — según datos del análisis interno del sector — son exactamente eso: un solo LLM disfrazado de múltiples agentes. La tasa de error compuesto — un agente que cascada su error sobre el siguiente — crece más rápido que cualquier ganancia de especialización.

Si estás buscando how to build ai agents 2026, el primer paso no es añadir más. Es quitarlos.

---

Por Qué Más Agentes No Escala Linealmente

Cada agente que añades introduce tres costes ocultos:

Latencia compuesta: Cada llamada a un LLM suma ~1-3 segundos. Tres agentes en serie = 3-9 segundos por respuesta. El usuario espera.

Desalineamiento de objetivos: Cada agente optimiza su sub-tarea. El agente de "análisis" quiere profundidad. El de "resumen" quiere brevedad. Se contradicen.

Acoplamiento frágil: El output del agente A es el input del agente B. Si A alucina, B arrastra la alucinación. Y no hay quien reconcilie.

El mito: "Cada agente se especializa y el conjunto supera a la suma."

La realidad: La literatura emergente muestra que la tasa de error compuesto en sistemas multi-agente sin coordinación crece exponencialmente. No linealmente. Cada agente adicional no suma capacidad — suma riesgo de contradicción.

Contraste: 1 agente con un prompt bien diseñado y un presupuesto de tokens equivalente rinde igual o mejor que 3 agentes peer-to-peer en el 80% de las tareas comunes.

La pregunta no es "¿cuántos agentes necesito?". Es "¿qué parte de esta tarea necesita realmente un LLM?".

---

Los 3 Patrones de Coordinación Que Sí Funcionan

Después de implementar sistemas multi-agente en producción — desde gestorías hasta emergencias médicas — he destilado los únicos 3 patrones que escalan sin romperse.

1. Patrón Supervisor: Jerarquía Real

El patrón más robusto. Un agente supervisor recibe la tarea, la descompone en subpasos, delega a subagentes especializados, y — esto es clave — valida y reconcilia los resultados antes de devolverlos.

[@portabletext/react] Unknown block type "code", specify a component for it in the `components.types` prop

Por qué funciona: El supervisor no solo delega. Valida. Si el analyst devuelve un hallazgo que contradice al reviewer, el supervisor lo detecta en el paso de reconciliación y pide una segunda opinión antes de devolver el resultado.

2. Patrón Orquestador-Enrutador: Múltiples Tipos de Consulta

No todas las consultas necesitan el mismo pipeline. Algunas requieren búsqueda. Otras, cálculo. Otras, simple formateo.

El patrón Router usa un agente orquestador que clasifica la consulta y la enruta al subagente correcto — o a una función determinista.

[@portabletext/react] Unknown block type "code", specify a component for it in the `components.types` prop

La clave: el 40-60% de las rutas pueden resolverse con código determinista — regex, cálculos, búsquedas exactas. Cada una de esas rutas ahorra ~2 segundos de latencia y ~0.01€ en coste de inferencia. En 10.000 requests, eso es tiempo y dinero real.

3. Patrón Pipeline Secuencial: Transformaciones Lineales

Para tareas donde los pasos son estrictamente secuenciales — transformar datos, traducir, resumir — no necesitas un supervisor. Necesitas un pipeline con validación entre cada paso.

Pipeline validado: Paso A → validación → Paso B → validación → output

Coreografía peer-to-peer: Agente A → Agente B → Agente C (sin validación intermedia, errores en cascada)

El secreto del Pipeline es la validación post-ejecución. Cada paso verifica que el output del paso anterior es coherente antes de continuar. Si falla, reintenta con el paso anterior, no desde cero.

---

El Framework: Cómo Decidir Cuándo Usar Multi-Agent

Basado en implementaciones reales, aquí está el marco de decisión:

Paso 1: Audita tu sistema actual

Identifica cuántos de tus "agentes" son realmente necesarios. Mide la tasa de contradicción: ejecuta el mismo input contra tres agentes y cuenta cuántas veces sus outputs son incompatibles. Si es >15%, tienes un problema de coordinación, no de capacidad.

Paso 2: Elige el patrón según el caso

| Tipo de tarea | Patrón recomendado | Por qué |

|---|---|---|

| Tareas complejas con subpasos | Supervisor | Validación centralizada |

| Múltiples tipos de consulta | Router | Enrutamiento eficiente |

| Transformaciones lineales | Pipeline | Simplicidad + validación por paso |

| Tareas simples (1 paso) | 1 agente, no multi | Añadir agentes empeora el resultado |

Paso 3: Implementa un contrato de comunicación explícito

Cada subagente debe tener un formato de entrada y salida definido. JSON tipado. Esquemas. Sin "devuélveme lo que creas correcto". El orquestador no puede reconciliar outputs que no entiende.

[@portabletext/react] Unknown block type "code", specify a component for it in the `components.types` prop

Paso 4: Añade validación post-ejecución

El paso que casi nadie implementa. Después de que los subagentes devuelvan sus resultados, el orquestador debe:

  1. Comparar outputs en busca de contradicciones
  2. Calcular un score de confianza combinado
  3. Decidir si el resultado es aceptable o necesita reintento

Paso 5: Mide contra un baseline justo

No compares tu sistema multi-agente contra "un solo agente sin prompt engineering". Compáralo contra un solo agente con el mismo presupuesto de tokens, el mismo prompt engineering y el mismo fine-tuning.

Cuando haces esa comparación controlada, las ventajas del multi-agente se reducen drásticamente. Se limitan a casos donde necesitas perspectivas verdaderamente ortogonales — no tres versiones del mismo modelo pensando igual.

---

El Anti-Patrón: Lo Que La Mayoría Hace Mal

Aquí está el código que veo en el 90% de los proyectos que audito:

[@portabletext/react] Unknown block type "code", specify a component for it in the `components.types` prop

Problemas:

  • El error de agent_a se arrastra a agent_c sin corrección
  • No hay validación intermedia
  • Cada agente gasta tokens en el contexto completo — coste 3x innecesario
  • Si agent_b alucina, agent_c asume que es verdad y empeora la salida

La solución: aplica el patrón Supervisor. Un solo agente que coordina, valida y decide.

---

Cuándo NO Usar un Agente (Sí, Leíste Bien)

El punto ciego más común: asumir que todo debe ser un LLM.

En producción, estas tareas no deberían ser agentes:

  • Formateo de datos: json.dumps() es más barato y no alucina
  • Validación de esquemas: Pydantic o Zod. No un prompt.
  • Búsqueda exacta: Índices vectoriales o SQL. No "busca en la base de datos" como tool call.
  • Transformaciones predecibles: Regex. Expresiones aritméticas. Mapeo de valores.

Un sistema multi-agente bien diseñado sabe cuándo llamar a una función en lugar de a otro agente. Cada llamada determinista que eliminas reduce costes de inferencia y latencia entre un 40-60% en tareas híbridas.

La decisión más inteligente que puedes tomar al aprender how to build ai agents 2026 no es qué framework usar. Es qué parte de tu pipeline no necesita un LLM.

---

Conclusión: Menos Agentes, Mejor Coordinación

El hype del multi-agente te está vendiendo complejidad innecesaria.

Microsoft, Google y Anthropic lanzan frameworks (AutoGen, CrewAI, etc.) que estandarizan la coordinación — pero ningún framework arregla el problema de fondo: añadir agentes sin un patrón de coordinación real empeora los resultados.

Los 3 patrones que realmente funcionan:

  1. Supervisor: para tareas complejas con subpasos que requieren validación
  2. Router: para múltiples tipos de consulta con enrutamiento eficiente
  3. Pipeline: para transformaciones lineales con validación por paso

Y el patrón más importante de todos: no usar un agente cuando una función determinista sirve.

La próxima vez que alguien te diga "necesitamos más agentes", pregúntale: "¿Has probado con uno bien hecho, una función determinista, y un prompt mejor?"

La respuesta, casi siempre, será que no.

Y esa es la diferencia entre un sistema que escala y uno que colecciona agentes.

Artículos relacionados

---

¿Quieres recibir contenido como este cada semana? Suscríbete a mi newsletter

Brian Mena

Brian Mena

Software engineer building profitable digital products: SaaS, directories and AI agents. All from scratch, all in production.

LinkedIn