Contenido
Una vez que has comprendido el concepto de "coordinar varias IA" en ¿Qué es un sistema multi-agente?, la siguiente pregunta es cómo construir uno de verdad. Este artículo recorre un proceso práctico de 5 pasos para principiantes, usando el estándar de facto de 2026: el patrón supervisor.
Antes de hablar de cualquier framework, este es el principio más importante: "construye primero con un solo agente y añade más — de forma mínima — solo cuando topes con un límite." Empezar en modo multi desde el principio suele ser sobreingeniería. El código se muestra como pseudocódigo independiente del framework, así que aplica tanto si usas MCP como cualquier SDK.
Construye pequeño, mide y luego amplía
— El patrón supervisor, desde una configuración mínima
* Los pasos y las cifras de este artículo se citan de materiales públicos, guías de profesionales e informes de investigación (a junio de 2026). El código es pseudocódigo conceptual; consulta la documentación oficial de cada framework para la API real.
1. Antes de construir: ¿de verdad necesitas multi?
La primera barrera no es técnica, es una cuestión de criterio. Multi-agente es potente, pero cerca del 80% de los casos de uso se resuelven con un solo agente. Si no se cumple ninguna de las siguientes condiciones, construye primero con un solo agente.
3 señales de que deberías pasar a multi
- División por especialización: el conocimiento no cabe en un solo prompt (los dominios abarcan investigación, legal, código, etc.)
- Paralelismo: hacer varias tareas a la vez es claramente más rápido
- Separación de decisiones: la calidad mejora cuando separas "el que ejecuta" y "el que verifica"
Al contrario, usar multi para un proceso simple de un solo carril — como vimos la vez anterior — infla el coste 3-10x y, en realidad, baja la precisión en tareas secuenciales (investigación de Google reporta −39-70% frente a un solo agente). Parte de la premisa de que "más agentes no significa más inteligente".
2. La forma base: supervisor (el estándar de 2026)
Si no sabes con qué patrón empezar, ve con el patrón supervisor, sin más. Los subagentes de Claude Code, LangGraph Supervisor, los handoffs de OpenAI Agents SDK — las implementaciones principales han convergido todas en esta forma. Las razones son claras.
El soporte de frameworks más amplio
Soporte nativo en los principales frameworks. Abundantes implementaciones de referencia.
Modo de fallo conocido
El fallo principal es la "delegación excesiva", acotada por un tope de iteraciones.
Fácil de auditar
"Quién hizo qué" queda claro, lo que facilita la depuración.
El funcionamiento es simple. El supervisor recibe la tarea global, la divide en subtareas, las delega en workers especializados y agrega los resultados. El supervisor no necesita saber cómo hace su trabajo un worker, solo a qué worker llamar y en qué formato de salida. La experticia vive en los workers.
3. Constrúyelo en 5 pasos
Monta una configuración de supervisor mínima en cinco pasos. La regla práctica: empieza con 2-3 workers y añade más solo cuando la medición lo justifique.
PASO 1. Descompón la tarea
Anota el "objetivo final" y los "roles especializados" necesarios. Ejemplo: para un informe de estudio de mercado, "1) reunir información → 2) analizar → 3) redactar → 4) verificar hechos". Descompón con claridad desde el principio — la vaguedad aquí derrumba todo el conjunto.
PASO 2. Define los workers (hasta 3-5)
Dale a cada worker un solo rol, las herramientas que necesita y un formato de salida. No seas ambicioso al principio — 3-5 como máximo. Cada worker es independiente y solo dispone de sus propias herramientas (búsqueda, ejecución de código, etc.).
PASO 3. Diseña el supervisor
En el prompt del supervisor, enumera explícitamente los nombres de los workers a los que puede llamar (un tope estricto). El truco: dedica más tiempo al supervisor que a cualquier worker individual. Esto determina la calidad general.
PASO 4. Decide el handoff y el reparto de contexto
Define qué se pasa entre workers y en qué formato. Pasar todo el contexto a todos infla los tokens, así que pasa solo la información necesaria. El protocolo estándar para la coordinación entre agentes es A2A.
PASO 5. Mide y ejecuta con topes
Instrumenta cada handoff antes de añadir agentes (la observabilidad no es opcional). Pon topes a las iteraciones, los tokens y el coste. Configura evals y guardrails al mismo tiempo.
4. Ejemplo de código mínimo (pseudocódigo)
La esencia del patrón supervisor es sorprendentemente corta. Aquí tienes pseudocódigo independiente del framework que muestra el bucle en el que el supervisor elige un worker y lo ejecuta (consulta la documentación oficial de cada SDK para la API real).
# Define los workers: un rol + herramientas dedicadas
workers = {
"researcher": Agent(tools=[web_search]),
"writer": Agent(tools=[]),
"factcheck": Agent(tools=[web_search]),
}
# Supervisor: tope estricto a los nombres de workers que puede llamar
supervisor = Agent(
instructions="Decompose the goal and pick one worker to call next. "
"Return 'DONE' when finished.",
allowed_workers=["researcher", "writer", "factcheck"],
)
# Bucle de ejecución (un tope de iteraciones evita la delegación excesiva)
state = {"goal": "Write an AI market report", "history": []}
for step in range(MAX_STEPS): # <- un tope es esencial
next_worker = supervisor.decide(state)
if next_worker == "DONE":
break
result = workers[next_worker].run(state)
state["history"].append({next_worker: result}) # comparte solo el contexto necesario
log_handoff(next_worker, result) # <- instrumenta cada handoffTres conclusiones: 1) cada worker es un solo rol + herramientas dedicadas, 2) el conjunto al que puede llamar el supervisor está limitado, 3) el bucle siempre tiene un tope de iteraciones. Añade medición, guardrails y evals sobre este esqueleto y te acercarás a la calidad de producción. Claude Agent SDK y los subagentes de Claude Code siguen la misma idea.
5. Errores comunes y soluciones
Los puntos donde la gente tropieza al desarrollar multi-agente son bastante predecibles. Anticípate a ellos.
| Error | Solución |
|---|---|
| Delegación excesiva (el supervisor itera sin fin) | Tope de iteraciones + limitar los workers que se pueden llamar |
| Inflado de tokens (coste 3-10x) | Deja de compartir todo el contexto; pasa solo lo necesario + caché |
| Comportamiento inestable y no determinista | Mantén pocos workers (3-5) + fija los formatos de salida |
| Caída de precisión en tareas secuenciales (−39-70%) | Vuelve a un solo agente para el trabajo de un único carril |
| No puedes saber dónde falló | Instrumenta cada handoff antes de escalar (observabilidad) |
La lección compartida: "los prompts, el diseño de herramientas y el arnés de evals deciden el éxito más que el framework." Por encima de una arquitectura llamativa, la disciplina de construir pequeño, medir y ampliar solo cuando compensa es lo más rápido al final.
Resumen
Construir un sistema multi-agente no da miedo si empiezas con el patrón supervisor desde una configuración mínima. Recapitulemos.
Puntos clave
- 🚦 Primero un solo agente. Añade agentes solo cuando aparezcan señales de especialización / paralelismo / separación de decisiones.
- 🧠 La forma base es el supervisor (estándar de 2026). Dedica el máximo tiempo al diseño del supervisor.
- 🔢 5 pasos: descomponer → definir workers (3-5) → diseñar el supervisor → handoff → medir.
- ⚠️ Errores: delegación excesiva, inflado de tokens, inestabilidad. Soluciónalos con topes, reparto de solo lo necesario y medición.
- 📏 Disciplina: los prompts, las herramientas y los evals deciden el éxito más que el framework.
"Construye pequeño, mide y luego amplía." Mantén esa disciplina y un sistema multi-agente se convierte en un socio potente para el trabajo complejo. Para el concepto, consulta ¿Qué es un sistema multi-agente?; para construir uno solo, Cómo construir un agente de IA.
FAQ
Q. ¿Con qué patrón debería empezar?
A. El patrón supervisor, sin dudarlo. Los principales frameworks lo soportan, su modo de fallo es conocido y las implementaciones de referencia son las más abundantes. Explora otros patrones cuando ya te sientas cómodo.
Q. ¿Con cuántos workers debería empezar?
A. Empieza con 2-3 y mantenlo en 3-5 como mucho. Cuantos más añadas, más inestable se vuelve y más se disparan los tokens. La norma es añadir más solo cuando la medición demuestre la necesidad.
Q. ¿Es obligatorio un framework?
A. No es obligatorio. Como muestra el pseudocódigo, un bucle más prompts permite construir una configuración mínima. Pero si necesitas persistencia de estado, observabilidad y recuperación en producción, un framework de apoyo es un atajo.
Q. ¿Cómo evito que el coste se dispare?
A. Ayudan tres cosas: 1) poner tope al número de iteraciones, 2) compartir solo el contexto necesario en lugar de todo, y 3) usar caché de prompts. Pasar a multi puede costar 3-10x lo de un solo agente, así que los topes son esenciales desde el primer día.
