Frameworks de agentes de IA comparados: qué capa resuelve cada uno

"Qué framework de agentes uso" casi siempre es la segunda pregunta. La primera es "en qué capa del problema estoy realmente atascado", y cuando respondes eso la lista corta se arma sola.

Porque estas herramientas no compiten tan de frente como sugieren los posts de comparación. LangGraph y el Vercel AI SDK se solapan en quizás un tercio de su superficie. CrewAI resuelve un problema que el Vercel AI SDK ni intenta. Y hay una capa que ninguno toca, que es justo la que decide si tu agente tiene usuarios.

El stack

Todo agente en producción tiene seis capas. La mayoría de los frameworks resuelve una o dos, y son honestos al respecto.

Las guerras de frameworks pasan en la capa 2. La capa 5 es donde mueren los proyectos.

Los frameworks de orquestación

LangGraph modela el agente como un grafo de estados: los nodos son pasos, las aristas transiciones, y el estado es explícito. Es más ceremonia que un loop para un agente simple, y es exactamente lo correcto cuando necesitas ciclos, checkpoints, aprobación humana a mitad de camino, o poder retomar una corrida que se detuvo hace tres días. Su combinación con LangSmith para tracing es la historia de debugging más madura del grupo. Python y TypeScript.

El OpenAI Agents SDK es la cosa más pequeña que todavía es un framework de agentes: agentes, handoffs entre agentes, guardrails y tracing. Muy poco que aprender, con opinión hacia los modelos de OpenAI aunque sin quedar atado a ellos. Si tu arquitectura es "un agente que a veces pasa a un agente especialista", este es el menor código que vas a escribir. Python y TypeScript.

CrewAI está construido alrededor de roles. Defines agentes como cargos con objetivos e historia, los pones en un crew y le das una tarea al crew. Es genuinamente bueno en lo suyo, que es repartir un trabajo entre varios especialistas. Encaja raro para un único agente de soporte atendiendo a un cliente, que es la mayoría de los agentes en producción. Python.

El Vercel AI SDK es un toolkit TypeScript-first donde el loop es una llamada con tools y una condición de parada, no un grafo. Su abstracción de providers es la más limpia del grupo: cambiar OpenAI por Anthropic es un import. El streaming y los bindings de React son lo mejor que hay, lo cual importa si el agente tiene UI web y no importa nada si vive en WhatsApp. TypeScript.

Mastra es la opción TypeScript más completa de fábrica: agentes, workflows, RAG, evals y un playground local en un solo paquete. Bueno cuando quieres estructura sin ensamblar cinco librerías. TypeScript.

Pydantic AI trae salida estructurada tipada y validada a los agentes en Python, que es el instinto correcto si tus tools devuelven datos que tienen que ser correctos y no meramente plausibles.

LlamaIndex empezó como librería de retrieval y le crecieron workflows de agentes. Si el trabajo de tu agente es sobre todo "responder con precisión desde un corpus grande de documentos", partir de acá en vez de atornillarle RAG a un framework de orquestación suele ser menos trabajo.

Ningún framework merece una fila en esta tabla. Un loop con tool calls son unas treinta líneas, mostradas completas en cómo crear un agente de IA. Para un solo agente con cuatro tools, el SDK crudo del provider es con frecuencia la decisión de ingeniería correcta, y puedes adoptar un framework el día que necesites grafos o handoffs.

Elegir uno

Fíjate que ninguna de esas filas dice "y así es como los clientes llegan a él".

La capa 5, y por qué está vacía

Todos los frameworks de arriba asumen que alguien llama. Envuelves el agente en un endpoint HTTP, y algo lo llama.

En un demo, ese algo es un widget de chat. En producción tiene que ser donde tus clientes ya están: WhatsApp, SMS, email, una llamada. Eso no es un wrapper. Cada uno es su propia integración con sus propias reglas:

• WhatsApp: verificación de Meta Business, un webhook con verificación de firma, aprobación de templates antes de poder iniciar una conversación, y una ventana de 24 horas desde el último mensaje del cliente dentro de la cual puedes responder libremente. Fuera de ella, solo templates aprobados.
• SMS: registro A2P 10DLC en Estados Unidos antes de que las carriers entreguen, reglas de sender por país en todos lados, y conteo de segmentos que cambia cuando alguien manda un emoji.
• Email: DKIM, SPF y DMARC, un dominio de envío cuya reputación puedes destruir en una semana, más manejo de threading y adjuntos en el camino de vuelta.
• Voz: un pipeline de medios donde reconocimiento de voz, modelo y síntesis tienen que terminar en cerca de un segundo, o quien llama cree que se cortó.
• Telegram, Instagram, Messenger: tres modelos de identidad más, tres formatos de webhook más.

Construir esto una vez es un trimestre de ingeniería. Construirlo para cuatro canales es casi un año. Y además no diferencia nada: ningún cliente eligió jamás un producto porque sus registros DKIM estaban bien configurados.

Esta es la capa que resuelve Zavu, y por eso conviene ser preciso: Zavu no compite con LangGraph ni con el Vercel AI SDK. Es las capas 4 y 5, más las capas 1, 2, 3 y 6 opcionalmente, si las quieres.

Dos formas de combinarlos

Te quedas con tu framework, Zavu lleva los mensajes

Tu agente queda exactamente como está, en el framework que ya elegiste. Zavu entrega el mensaje entrante y manda la respuesta.

Ese adapter no lo escribes a mano. Instalas las skills y el CLI una vez, y después dices lo que quieres:

terminal
npx skills add zavudev/zavu-skills
npx zavudev@latest login

> Envuelve mi agente de LangGraph existente para que responda en WhatsApp. Los mensajes entrantes deben alimentar el grafo, y la respuesta final debe volver por el mismo canal. Deployalo y pruébalo.

Las skills cargan las reglas de canal que tu coding agent nunca vio: la ventana de 24 horas, la verificación de firma, qué eventos existen. Lo que escribe se ve así:

TypeScript
import { defineFunction } from "@zavudev/functions"
import { generateText } from "ai"
import { openai } from "@ai-sdk/openai"
import Zavudev from "@zavudev/sdk"

const zavu = new Zavudev({ apiKey: process.env.ZAVU_API_KEY })

export default defineFunction({
  on: ["message.inbound"],
  handler: async (event) => {
    const { text } = await generateText({
      model: openai("gpt-4o-mini"),
      prompt: event.data.text,
      tools: myTools,
    })

    await zavu.messages.send({ to: event.data.from, text })
  },
})

El Vercel AI SDK está corriendo tu loop. Zavu se hace cargo del webhook, la firma, el canal, la ventana de 24 horas y la entrega. Declara ai y @ai-sdk/openai en package.json y se instalan en build time. ZAVU_API_KEY se provisiona automáticamente al crear la function, así que el callback no necesita configuración.

La misma forma funciona con LangGraph, CrewAI o un SDK de provider pelado, y funciona desde tu propia infraestructura también: apunta un webhook a tu servidor en vez de correr dentro de una Zavu Function.

También te saltas la capa 2

Si tu agente es un prompt más tools y no un grafo, puedes declararlo y dejar que el runtime se haga cargo del loop. De nuevo, lo describes:

> Construye un agente de soporte para una tienda online. Una tool que busque un pedido por ID contra nuestra API. Dos frases máximo por respuesta, nunca inventar una fecha de entrega.

Y revisas lo que vuelve:

TypeScript
import { defineAgent, defineTool } from "@zavudev/functions"

defineAgent({
  senderId: process.env.SENDER_ID!,
  name: "Nora",
  provider: "zavu",
  model: "openai/gpt-4o-mini",
  prompt: "Eres Nora, soporte de una tienda online. Dos frases máximo.",
})

defineTool({
  name: "lookup_order",
  description: "Get the status of a customer order. Use when they ask where their package is.",
  parameters: {
    type: "object",
    properties: { orderId: { type: "string" } },
    required: ["orderId"],
  },
  handler: async ({ orderId }) => {
    const res = await fetch(https://api.example.com/orders/${orderId})
    return res.json()
  },
})

npx zavudev deploy y ya está respondiendo en todos los canales que tenga el sender.

El trade-off es real y vale decirlo claro. Renuncias a control de flujo con forma de grafo y a handoff entre varios agentes. Ganas el loop, el estado de conversación por contacto, retrieval sobre knowledge base, registros de ejecución y todos los canales, sin escribir nada de eso. El campo provider acepta openai, anthropic, google y mistral con tu propia key, así que esto no es lock-in de modelos.

Cuándo la opción dos está mal: necesitas un paso de aprobación humana a mitad de una corrida, varios agentes negociando, o un workflow que se pausa dos días y retoma. Usa LangGraph y la opción uno.

La pregunta que sí predice el resultado

Después de todo esto, la elección de framework rara vez es lo que determina si un agente funciona. Seis meses viéndolos salir a producción, el patrón es consistente: los agentes viven o mueren por sus tools y por su canal.

Buenas tools con un framework mediocre le ganan a un grafo hermoso con descripciones de tools vagas. Y un agente en WhatsApp con un loop simple recibe diez veces el uso de un agente con orquestación multi-agente perfecta detrás de un widget que nadie abre.

Elige el framework en una tarde. Gasta la semana en las tools y en estar donde tus clientes ya están.

Para seguir leyendo

• Cómo crear un agente de IA: el loop desde cero y después deployado.
• Qué es un agente de IA: la definición y las cuatro partes.
• Agente de IA vs chatbot: la decisión anterior a la del framework.
• Crea agentes de IA con tu coding agent: el flujo de CLI y skills.
• Agentes de IA en WhatsApp con Next.js, NestJS o FastAPI: la capa 5, framework por framework.