Sistemas multi-agente: orquestación y coordinación de agentes IA

Anthropic distingue dos cosas que se confunden. Un **workflow** orquesta LLM y herramientas por caminos de código predefinidos: es predecible y consistente. Un **agente** dirige dinámicamente su propio proceso y uso de herramientas: es flexible pero no determinista. Para tareas bien definidas, un workflow suele bastar; el agente entra cuando se necesita flexibilidad a escala.

La jerarquía de complejidad, de menor a mayor: una sola llamada al LLM con buen contexto y recuperación → un workflow con pasos fijos → un agente autónomo → un sistema multi-agente. Cada salto agrega capacidad, pero también costo, latencia y posibilidad de error en cascada. La regla: subir un escalón solo cuando el anterior se queda corto.

Anthropic documenta cinco patrones de workflow más el agente autónomo. Esta es la taxonomía de facto del sector:

• **Prompt chaining:** pasos secuenciales donde cada llamada procesa la salida de la anterior, con chequeos intermedios. Para tareas que se descomponen limpiamente (ej. redactar y luego traducir).
• **Routing:** clasifica la entrada y la dirige a una tarea especializada. Para categorías distintas mejor atendidas por separado (ej. tipos de consulta de soporte).
• **Parallelization:** subtareas independientes en paralelo (sectioning) o la misma tarea varias veces para más confianza (voting). Para velocidad o múltiples perspectivas.
• **Orchestrator-workers:** un LLM central descompone la tarea, delega en workers y sintetiza resultados. Clave: las subtareas no están predefinidas, las decide el orquestador. Para tareas complejas impredecibles.
• **Evaluator-optimizer:** un LLM genera y otro evalúa en un loop de mejora. Para criterios de evaluación claros y refinamiento iterativo.

El patrón supervisor —un agente líder que coordina y delega a subagentes especializados— es orchestrator-workers aplicado. Es el mismo patrón que LangGraph llama "supervisor" y que el SDK de OpenAI implementa con handoffs y agents-as-tools: tres nombres para la misma idea.

En AI SDK 6, la clase de agente production-ready es ToolLoopAgent: corre el loop de tool-calling (llama al modelo, ejecuta las herramientas, agrega los resultados, repite hasta una condición de parada). Un agente base:

import { ToolLoopAgent, tool, stepCountIs } from "ai";
import { z } from "zod";

const agente = new ToolLoopAgent({
  model: "anthropic/claude-sonnet-4.5",
  instructions: "Eres un asistente de investigación.",
  tools: {
    buscar: tool({
      description: "Busca información en la web",
      inputSchema: z.object({ query: z.string() }),
      execute: async ({ query }) => ({ resultados: await runSearch(query) }),
    }),
  },
  stopWhen: stepCountIs(20), // tope de seguridad contra loops infinitos
});

const r = await agente.generate({ prompt: "Investiga el mercado X" });
console.log(r.text);

El patrón multi-agente idiomático en el AI SDK es envolver cada subagente como una herramienta del orquestador (equivale a orchestrator-workers). No hay una primitiva "multi-agente" dedicada: es composición de agentes.

// Subagente especialista, con su propio contexto
const subagente = new ToolLoopAgent({
  model: "anthropic/claude-sonnet-4.5",
  instructions: "Investigas un aspecto puntual y devuelves un resumen breve.",
  tools: { buscar },
});

// Orquestador (lead) que delega a subagentes
const orquestador = new ToolLoopAgent({
  model: "anthropic/claude-opus-4.5",
  instructions: "Descompones la consulta y delegas en subagentes.",
  tools: {
    delegar: tool({
      description: "Delega una sub-investigación a un subagente con su propio contexto",
      inputSchema: z.object({ subPregunta: z.string() }),
      execute: async ({ subPregunta }) => {
        const sr = await subagente.generate({ prompt: subPregunta });
        return { resumen: sr.text }; // retorno comprimido al lead
      },
    }),
  },
  stopWhen: stepCountIs(30),
});

Cada llamada a "delegar" corre un subagente con ventana propia y devuelve solo el resumen, igual que el principio de compresión de Anthropic. La paralelización real se logra disparando varias delegaciones a la vez. LangGraph es la alternativa cuando necesitas un grafo de estado explícito con ciclos, ramas y persistencia; el AI SDK favorece un loop de herramientas liviano y tipado en TypeScript.