Colaboración multiagente en la práctica: guía de 4 patrones de arquitectura

Los datos de investigación de Anthropic muestran que los sistemas multiagente superan a un solo Agent en un 90,2%. Un Agent único tiene tres puntos débiles: límite de contexto (200k tokens y empieza a alucinar), capacidades dispersas (demasiadas skills = «todólogo») y depuración difícil (cuando falla, no sabes dónde). La colaboración multiagente es la «arquitectura de microservicios» de la IA: cada Agent hace una cosa y coordina por mensajes claros.

Cuatro patrones encajan en escenarios distintos: Subagents (orquestación central) para dominios paralelos, Skills (carga bajo demanda) para flujos monohilo multietapa, Handoffs (impulsado por estado) para conversaciones por fases y Router (despacho paralelo) para consultas multi-fuente. Este artículo cubre criterios de elección, trampas en producción e implementación LangGraph.

Por qué hace falta un sistema multiagente

El problema del Agent único no es «si funciona», sino «cuánto aguanta».

¿Te ha pasado que un Agent escribía bien y de repente suelta basura? ¿Preguntas por A y acaba en Z? No es «tonto»: el contexto se llenó.

Límite de contexto. 200k tokens no son infinitos. Código + seguridad + rendimiento a la vez… a mitad de camino olvida la mitad. Vi uno que en la ronda 21 pasó de Python a JavaScript sin darse cuenta.

Capacidades dispersas. Más skills = más «aprendiz de todo». Pides code review y te escribe tests; pides docs y refactoriza. Dirección: inexistente.

Depuración difícil. Un solo Agent falla y no sabes si fue el prompt, una tool o contaminación de contexto.

Railway - Plataforma de despliegue moderna, sin ops complejas, en producción en minutos

Empezar ahora →Anuncio

Multiagente = microservicios para IA. Cada Agent una responsabilidad; colaboración por mensajes, no un «super Agent».

Google, LangChain y Anthropic empujan esta línea. Los papers sobre Agents en 2025 pasaron de ~820 a 2500+. La era del Agent único terminó.

Cuatro patrones de arquitectura

LangChain y Google resumen varios enfoques. Tras varios proyectos, cada uno tiene su escenario; elegir mal es «cañón para mosca» o «sopa con palillos».

Subagents — orquestación central

Un Agent «jefe» y sub-Agents como herramientas.

Petición → Agent principal → sub-Agents A/B/C → agregación → respuesta

Cuándo: dominios independientes (pedidos, reembolsos, quejas).

Código (LangGraph):

from langgraph.prebuilt import create_react_agent

order_agent = create_react_agent(
    model="claude-3-5-sonnet-20241022",
    tools=[query_order, update_order],
    prompt="Eres experto en pedidos; solo pedidos."
)

refund_agent = create_react_agent(
    model="claude-3-5-sonnet-20241022",
    tools=[check_refund_policy, process_refund],
    prompt="Eres experto en reembolsos; solo reembolsos."
)

main_agent = create_react_agent(
    model="claude-3-5-sonnet-20241022",
    tools=[order_agent, refund_agent],
    prompt="Eres el responsable de atención; enruta al experto adecuado."
)

Pros: contexto aislado, paralelismo. Contras: más tokens; estado compartido requiere coordinación extra.

Skills — carga bajo demanda

Un Agent, varias «personalidades» (prompts dinámicos).

Petición → Agent → Skill code_review → Skill doc_writer → …

Cuándo: flujo secuencial con expertise distinta por fase.

Pros: ligero, menos tokens. Contras: el contexto se acumula al cambiar de Skill.

Vultr - Servidor cloud NVMe de alto rendimiento, 32 ubicaciones globales, despliegue Docker con un clic

Ver precios →Anuncio

Handoffs — impulsado por estado

Relevo entre Agents como un relevo.

Agent A (recoger) → Handoff → Agent B (diagnóstico) → Agent C (solución)

Cuándo: soporte multietapa. Pros: flujo natural. Contras: formato de estado entre Agents debe ser correcto.

Router — despacho paralelo

Clasifica y consulta fuentes en paralelo; sintetiza.

Cuándo: varias fuentes (docs internos, API, BD). Pros: velocidad. Contras: poco apto para multivuelta.

Marco de decisión

¿Qué necesitas?
├─ Dominios paralelos → Subagents
├─ Un Agent, varias skills → Skills
├─ Flujo secuencial → Handoffs
└─ Multi-fuente → Router

Empieza simple: Skills o Handoffs para MVP; escala a Subagents/Router si hace falta.

Puntos clave en producción

Gestión de estado

Usa output_key: cada Agent escribe solo su clave (security_result, style_result, etc.).

Añade relevant_keys para evitar contaminación de contexto.

Optimización

Subagents ahorra ~67% tokens vs Skills en escenarios multi-dominio (LangChain).

KiloClaw - OpenClaw gestionado para empresas: orquestación de agentes IA y enrutamiento inteligente

Empezar →Anuncio

Modo con estado: 40-50% menos llamadas repetidas. Limita reflexión: max_iterations=2 o 3.

Trampas comunes

• Bucles infinitos: max_iterations + condición de salida.
• Contexto hinchado: patrón Blackboard, limpieza periódica.
• Impuesto de coordinación: >5 Agents → latencia; fusiona roles similares.

Ejemplo completo: revisión de código

Router + ParallelAgent: clasifica lenguaje → auditoría de seguridad, estilo y rendimiento en paralelo → informe.

from typing import TypedDict
from langgraph.graph import StateGraph, END
from langchain_anthropic import ChatAnthropic

class CodeReviewState(TypedDict):
    code: str
    language: str
    security_issues: list
    style_issues: list
    perf_issues: list
    final_report: str

llm = ChatAnthropic(model="claude-3-5-sonnet-20241022")

async def route_code(state: CodeReviewState) -> dict:
    code = state["code"]
    if "def " in code or "import " in code:
        language = "python"
    elif "function" in code or "const " in code:
        language = "javascript"
    else:
        language = "unknown"
    return {"language": language}

async def security_audit(state: CodeReviewState) -> dict:
    code = state["code"]
    prompt = f"""Eres experto en auditoría de seguridad. Revisa:
- Inyección SQL
- XSS
- Fugas de datos sensibles
- Dependencias inseguras

Código:
{code}

Salida: lista JSON con line, severity, description.
"""
    await llm.ainvoke(prompt)
    return {"security_issues": []}

async def style_check(state: CodeReviewState) -> dict:
    code = state["code"]
    language = state["language"]
    prompt = f"""Eres experto en estilo {language}. Revisa naming, formato y comentarios.

Código:
{code}

Salida: lista JSON.
"""
    await llm.ainvoke(prompt)
    return {"style_issues": []}

async def perf_analysis(state: CodeReviewState) -> dict:
    code = state["code"]
    prompt = f"""Eres experto en rendimiento. Revisa complejidad, bucles innecesarios y fugas de memoria.

Código:
{code}

Salida: lista JSON.
"""
    await llm.ainvoke(prompt)
    return {"perf_issues": []}

async def generate_report(state: CodeReviewState) -> dict:
    security = state.get("security_issues", [])
    style = state.get("style_issues", [])
    perf = state.get("perf_issues", [])
    total = len(security) + len(style) + len(perf)
    report = f"""# Informe de revisión

- Idioma: {state['language']}
- Problemas totales: {total}
"""
    return {"final_report": report}

graph = StateGraph(CodeReviewState)
graph.add_node("router", route_code)
graph.add_node("security", security_audit)
graph.add_node("style", style_check)
graph.add_node("perf", perf_analysis)
graph.add_node("report", generate_report)
graph.set_entry_point("router")
graph.add_edge("router", "security")
graph.add_edge("router", "style")
graph.add_edge("router", "perf")
graph.add_edge("security", "report")
graph.add_edge("style", "report")
graph.add_edge("perf", "report")
graph.add_edge("report", END)
app = graph.compile()

~100 líneas de código: 3-5 s en paralelo frente a ~10 s en serie. En producción añade caché, revisión incremental y feedback humano.

Conclusión

Lógica: el patrón importa más que el framework.

Estrategia: MVP simple, escala después.

Producción: estado, coste, bucles y contexto.

Siguiente paso: elige un patrón y 50 líneas en LangGraph. Primero hazlo correr.