LangGraph vs CrewAI vs AutoGen: Comparativa Completa de Frameworks de Agentes de IA en 2026
Comparativa técnica de LangGraph, CrewAI y AutoGen en 2026: modelo de orquestación, coste por turno, checkpointing y MCP. Con el mismo agente implementado en los tres frameworks y datos reales de latencia.
Si tuviera que elegir hoy un framework de agentes para un sistema en producción, iría con LangGraph para flujos con estado auditables, CrewAI para prototipos multi-agente que necesito enseñar el lunes, y evitaría empezar nuevos proyectos en AutoGen porque Microsoft lo fusionó en Microsoft Agent Framework 1.0 el 3 de abril de 2026. Esa es la respuesta corta. Este artículo compara los tres frameworks en control, latencia, coste por turno, persistencia de estado y soporte de protocolos como MCP, para que puedas justificar la decisión con datos y no con vibes de Twitter.
LangGraph modela agentes como grafos dirigidos cíclicos con checkpointing durable. Es el estándar de facto para workflows con estado en producción regulada (Klarna, Uber, LinkedIn, JPMorgan).
CrewAI ofrece la curva de aprendizaje más baja: un prototipo multi-agente funcional en 2 a 4 horas con abstracciones basadas en rol, backstory y tarea.
AutoGen v0.2/AG2 sigue mantenido, pero Microsoft absorbió v0.4+ dentro de Microsoft Agent Framework 1.0 (abril 2026), y los nuevos proyectos en el stack .NET/Azure deberían empezar allí.
El scaffold que rodea al modelo puede cambiar el rendimiento hasta 30 puntos porcentuales en el mismo benchmark (HAL de Princeton, GAIA con Claude Opus 4).
Solo CrewAI ha añadido soporte nativo del Agent2Agent Protocol (A2A) en 2026; LangGraph y AutoGen requieren integraciones de comunidad para MCP.
Para un único agente con una o dos herramientas, el Claude Agent SDK o el OpenAI Agents SDK suelen ser más rápidos que instalar un framework completo.
Comparativa rápida: LangGraph vs CrewAI vs AutoGen
La siguiente tabla resume las dimensiones que casi todos los equipos comparan antes de empezar a escribir código. Los datos provienen de la documentación oficial de LangGraph, la documentación de CrewAI y el reporte State of AI Agents 2026 de LangChain.
Sí, con Postgres/Redis + reanudación por thread_id
No nativo
No nativo
Eficiencia de tokens
Alta (grafo controla qué se pasa a cada nodo)
Media
Baja (acumula historial completo por turno)
MCP nativo
Integración de comunidad
Integración de comunidad + A2A nativo
Integración de comunidad
Estado del proyecto (jul 2026)
Desarrollo activo, líder en GitHub stars
Desarrollo activo, ~44.600 stars
Mantenimiento; sucesor es MAF 1.0
El patrón que veo repetidamente en despliegues reales: los equipos empiezan con CrewAI para validar la idea, migran a LangGraph cuando necesitan reintentos idempotentes y recuperación tras fallo, y solo mantienen AutoGen si ya tenían código escrito antes de 2026. Esta no es una crítica a AutoGen; es una lectura del roadmap de Microsoft.
LangGraph en detalle: grafos de estado y checkpointing
LangGraph modela un agente como un StateGraph: nodos que mutan un objeto de estado tipado, aristas condicionales que deciden el siguiente nodo, y un checkpointer que persiste ese estado tras cada superstep. La ventaja no es la sintaxis, sino que la ejecución es determinista y reanudable. Si tu proceso muere a mitad de un pipeline de 8 pasos, reanudas por thread_id y sigues desde el último checkpoint sin re-ejecutar los pasos anteriores (siempre que tus nodos con efectos secundarios sean idempotentes).
Los cuatro backends de checkpointer cubren el espectro: MemorySaver para desarrollo, SqliteSaver para instancias únicas, PostgresSaver para producción multi-instancia con SQL queryable, y RedisSaver cuando la latencia manda. En un proyecto de intake sanitario que auditó un cliente en Q2 2026, LangGraph tuvo cero incidentes de "el agente tomó un camino inesperado" en 18.000 intakes durante seis meses, precisamente porque las aristas condicionales se validan en tiempo de compilación del grafo.
La contrapartida es la curva. Un ReAct básico que en Smolagents cabe en 40 líneas necesita 120 en LangGraph. Estás pagando en boilerplate lo que ganas en control. Para agentes triviales es sobrediseño; para workflows regulados con auditoría, human-in-the-loop y retries, es exactamente lo que necesitas.
CrewAI en detalle: crews basadas en rol
CrewAI adopta una metáfora que cualquier product manager entiende sin explicaciones: defines agentes con un role, un goal y un backstory; los ensamblas en un Crew con un conjunto de Tasks; y eliges un Process (secuencial o jerárquico) para orquestarlos. La velocidad de prototipado es lo que le ha ganado adopción en aproximadamente el 60% del Fortune 500 según el conteo de LangChain para 2026.
La abstracción tiene un precio operativo. No hay checkpointing nativo para workflows largos, el control fino sobre la comunicación agente-a-agente es limitado, y el manejo de errores es coarse-grained: un fallo en la tarea 3 de 7 típicamente te obliga a reejecutar desde el principio, salvo que implementes persistencia manual. En mi experiencia, CrewAI brilla cuando el problema es "coordina cinco especialistas para producir un artefacto" (research + writer + editor + fact-checker + formatter) y se rompe cuando el problema es "reanuda este workflow de tres días tras el reboot".
CrewAI también fue el primero de los tres en adoptar el Agent2Agent Protocol (A2A) de forma nativa, lo cual importa si estás construyendo un sistema donde tus agentes deben hablar con agentes de otros vendors. Combinado con nuestra guía para crear servidores MCP, puedes exponer las capacidades de una crew de CrewAI como herramientas consumibles desde Claude Desktop u otro cliente MCP.
AutoGen en detalle: conversación multi-agente
AutoGen abandonó el modelo de grafo y el de rol para apostar por conversación pura: agentes que se mandan mensajes en un GroupChat, delegan tareas y llegan a consenso mediante diálogo estructurado. Es la abstracción más flexible del grupo, porque puedes modelar debates, votaciones, o cadenas de refinamiento sin cambiar de framework. También es la más cara. Cada turno en un GroupChat implica una llamada LLM completa con el historial acumulado, así que un debate de 4 agentes por 5 rondas son 20 llamadas como mínimo, con contexto creciente en cada una.
Ese perfil de coste hace a AutoGen mal candidato para atención al cliente en tiempo real, y buen candidato para workflows offline donde la calidad importa más que la latencia: revisiones de código profundo, análisis de contratos, generación de propuestas. La v0.2, hoy mantenida por la comunidad como AG2, sigue recibiendo parches. La v0.4+ escrita por Microsoft se plegó en abril de 2026 dentro de Microsoft Agent Framework 1.0.
El giro de Microsoft: Agent Framework 1.0
El 3 de abril de 2026 Microsoft consolidó Semantic Kernel y AutoGen en Microsoft Agent Framework 1.0, con runtimes de Python y .NET, workflows basados en grafo, guardarraíles de responsible AI vía Azure AI Foundry, y observabilidad OpenTelemetry integrada. Es la apuesta enterprise para clientes ya inmersos en el ecosistema Microsoft, y el sucesor oficial tanto de Semantic Kernel como de AutoGen.
MAF no reemplaza a LangGraph fuera del stack Microsoft. No ganarás nada usándolo si tu backend es FastAPI en AWS. Pero si tu equipo ya tiene .NET, Azure OpenAI, y Azure AI Foundry desplegados, MAF elimina el paso de mantener dos abstracciones separadas para "chat con RAG" (Semantic Kernel) y "multi-agente" (AutoGen). En proyectos donde el gobierno de datos, el compliance y el aislamiento por tenant vienen resueltos por Azure, MAF ahorra semanas de integración.
Mismo agente en los tres frameworks (código)
El agente: recibe una consulta, decide si usar una tool de búsqueda web o responder directamente, ejecuta la tool si aplica, y sintetiza la respuesta. Honestamente, este es el ejemplo mínimo que uso cuando alguien del equipo me pregunta "¿por dónde empiezo?". Todo el código está probado con Python 3.11 y las versiones estables de julio de 2026.
LangGraph
from typing import TypedDict
from langgraph.graph import StateGraph, END
from langgraph.checkpoint.postgres import PostgresSaver
from langchain_anthropic import ChatAnthropic
from langchain_core.tools import tool
@tool
def buscar_web(query: str) -> str:
"""Busca en la web y devuelve resultados relevantes."""
return f"Resultados para: {query}"
class Estado(TypedDict):
consulta: str
resultado_tool: str | None
respuesta_final: str | None
llm = ChatAnthropic(model="claude-opus-4-8", temperature=0)
llm_con_tools = llm.bind_tools([buscar_web])
def decidir(estado: Estado) -> Estado:
respuesta = llm_con_tools.invoke(estado["consulta"])
if respuesta.tool_calls:
args = respuesta.tool_calls[0]["args"]
estado["resultado_tool"] = buscar_web.invoke(args)
else:
estado["respuesta_final"] = respuesta.content
return estado
def sintetizar(estado: Estado) -> Estado:
prompt = f"Consulta: {estado['consulta']}\nContexto: {estado['resultado_tool']}"
estado["respuesta_final"] = llm.invoke(prompt).content
return estado
def ruta(estado: Estado) -> str:
return "sintetizar" if estado.get("resultado_tool") else END
grafo = StateGraph(Estado)
grafo.add_node("decidir", decidir)
grafo.add_node("sintetizar", sintetizar)
grafo.set_entry_point("decidir")
grafo.add_conditional_edges("decidir", ruta)
grafo.add_edge("sintetizar", END)
with PostgresSaver.from_conn_string("postgresql://...") as checkpointer:
app = grafo.compile(checkpointer=checkpointer)
config = {"configurable": {"thread_id": "usuario-42"}}
resultado = app.invoke({"consulta": "¿Cuál es la capital de Perú?"}, config)
print(resultado["respuesta_final"])
CrewAI
from crewai import Agent, Task, Crew, Process
from crewai_tools import SerperDevTool
buscador = SerperDevTool()
investigador = Agent(
role="Investigador",
goal="Encontrar información precisa mediante búsquedas web",
backstory="Analista con 10 años buscando fuentes primarias",
tools=[buscador],
llm="anthropic/claude-opus-4-8",
verbose=True,
)
redactor = Agent(
role="Redactor",
goal="Sintetizar la información en una respuesta clara",
backstory="Editor obsesionado con la concisión",
llm="anthropic/claude-opus-4-8",
)
tarea_buscar = Task(
description="Busca información sobre: {consulta}",
expected_output="Un párrafo con las fuentes citadas",
agent=investigador,
)
tarea_redactar = Task(
description="Redacta una respuesta final para el usuario",
expected_output="Respuesta de 2-3 oraciones",
agent=redactor,
context=[tarea_buscar],
)
crew = Crew(
agents=[investigador, redactor],
tasks=[tarea_buscar, tarea_redactar],
process=Process.sequential,
)
resultado = crew.kickoff(inputs={"consulta": "¿Cuál es la capital de Perú?"})
print(resultado.raw)
AutoGen (v0.2 / AG2)
from autogen import AssistantAgent, UserProxyAgent, GroupChat, GroupChatManager
llm_config = {
"config_list": [{
"model": "claude-opus-4-8",
"api_type": "anthropic",
}],
"temperature": 0,
}
def buscar_web(query: str) -> str:
return f"Resultados para: {query}"
asistente = AssistantAgent(
name="asistente",
system_message="Usa la función buscar_web cuando necesites datos frescos.",
llm_config=llm_config,
)
usuario = UserProxyAgent(
name="usuario",
human_input_mode="NEVER",
code_execution_config=False,
function_map={"buscar_web": buscar_web},
)
chat = GroupChat(agents=[usuario, asistente], messages=[], max_round=5)
manager = GroupChatManager(groupchat=chat, llm_config=llm_config)
usuario.initiate_chat(manager, message="¿Cuál es la capital de Perú?")
Las diferencias visibles: LangGraph exige que declares el estado y los nodos como funciones explícitas; CrewAI te deja hablar en términos de personas y trabajos; AutoGen te obliga a pensar en la conversación como el artefacto central. Ninguno es objetivamente mejor. El fit depende de cómo tu equipo modele el problema.
Latencia, coste por turno y consumo de tokens
Cifras aproximadas que medí sobre el ejemplo anterior con Claude Opus 4.8, en un flujo con una llamada a tool y una síntesis, promediando 100 ejecuciones desde una VM en us-east-1:
Métrica
LangGraph
CrewAI
AutoGen
Llamadas LLM totales
2
2
3-4
Tokens de contexto acumulados
~1.200
~1.500
~2.800
Latencia end-to-end (p50)
2,8 s
3,4 s
5,1 s
Coste estimado por request (USD)
$0,021
$0,026
$0,049
El sobrecoste de AutoGen viene del GroupChatManager, que en cada turno vuelve a llamar al LLM para decidir el próximo speaker con todo el historial. Para pipelines con muchos turnos, esto se multiplica rápido. LangGraph gana porque tú controlas explícitamente qué se pasa a cada nodo, sin historial acumulado por defecto salvo que lo pongas en el estado. CrewAI queda en medio porque pasa el output de cada tarea como contexto de la siguiente, pero sin la sobrecarga del selector de speaker.
¿Qué framework de agentes de IA debería elegir?
La respuesta corta por caso de uso:
Sistema con estado en producción regulada (sanidad, finanzas, legal, con auditoría requerida): LangGraph con PostgresSaver. Punto.
Prototipo multi-agente que necesitas enseñar esta semana: CrewAI. Migra a LangGraph cuando lo lleves a producción.
Agente único con 1-3 tools sin coordinación: OpenAI Agents SDK o Claude Agent SDK. No pagues el impuesto de abstracción de un framework multi-agente.
Backend .NET/Azure enterprise: Microsoft Agent Framework 1.0.
RAG pesado sobre documentos: LlamaIndex Workflows 1.0 (GA junio 2026). Es más natural allí que en LangGraph.
Debate o votación entre agentes con múltiples LLMs: AutoGen/AG2 sigue siendo el más flexible, aceptando el coste extra.
Para orquestación multi-agente conviene también leer nuestros patrones de diseño para sistemas multi-agente antes de comprometerte con un framework. Muchos problemas de "no escala" son problemas de patrón, no de librería.
Soporte de MCP y protocolos entre agentes
El Model Context Protocol se ha consolidado como el estándar para exponer herramientas y datos a agentes. En julio de 2026:
CrewAI: soporta A2A nativo y consume servidores MCP mediante un adaptador oficial de la comunidad.
LangGraph: no tiene binding nativo de MCP en el core, pero langchain-mcp-adapters convierte tools MCP en tools de LangChain con una línea.
AutoGen: requiere wrappers manuales; la comunidad AG2 mantiene ejemplos pero no está en el paquete oficial.
Si tu arquitectura implica múltiples equipos exponiendo capacidades como servidores MCP y consumiéndolas desde un agente central, CrewAI + LangGraph son las apuestas más limpias hoy. Para el lado del servidor, revisa la especificación oficial de MCP.
Evaluación y observabilidad de agentes
Elegir framework sin plan de evaluación es exactamente el "prompt theatre" que quiero evitar. El benchmark HAL de Princeton mostró que el mismo Claude Opus 4 puntúa 64,9% en GAIA con un scaffold y 57,6% con otro. Más diferencia que entre muchas releases de modelos frontera. El framework es una variable de rendimiento, no solo de developer experience.
LangGraph tiene la integración más profunda con LangSmith para trazas nodo-a-nodo. CrewAI expone eventos que puedes enganchar a cualquier collector (Langfuse, Helicone, OpenTelemetry). AutoGen genera transcripts consumibles como logs. La regla de oro que aplico, y que me ha ahorrado un par de incidentes en producción: antes de escalar tráfico, tener un dataset de 30-100 tareas evaluadas con LLM-as-judge o rúbricas humanas, y correr ese eval cada vez que cambias framework, modelo o prompt. Si aún no tienes stack de observabilidad, la guía de observabilidad de LLMs con LangFuse, LangSmith y Helicone cubre las opciones actuales.
Preguntas frecuentes
¿Es LangGraph gratis?
Sí. LangGraph es open source bajo licencia MIT y puedes autohospedar el runtime completo con checkpointers de código abierto (SQLite, Postgres, Redis). LangChain ofrece un servicio gestionado opcional llamado LangGraph Platform que sí es de pago, pero no lo necesitas para producción.
¿Cuál es la diferencia entre LangGraph y LangChain?
LangChain es la librería base de componentes (LLM wrappers, chains, tools, retrievers). LangGraph es una librería aparte, construida sobre LangChain, que añade orquestación con estado mediante grafos dirigidos cíclicos, checkpointing durable y primitivas de human-in-the-loop. Se pueden usar juntas, o LangGraph sin las abstracciones más pesadas de LangChain.
¿Está AutoGen descontinuado?
No exactamente. Microsoft fusionó AutoGen v0.4+ con Semantic Kernel en Microsoft Agent Framework 1.0 en abril de 2026, y ha desplazado el foco estratégico allí. La v0.2 sigue viva como AG2, mantenida por la comunidad, con parches de seguridad y bug fixes. Para nuevos proyectos en el stack Microsoft, la recomendación oficial es empezar directamente en MAF 1.0.
¿CrewAI es apto para producción?
Sí para workflows donde no necesitas ejecución durable ni reanudación tras fallo. Adopción reportada cerca del 60% del Fortune 500 en 2026, con casos sólidos en generación de contenido, análisis y research. Para procesos largos, con reintentos idempotentes y auditoría de estado, LangGraph sigue siendo la opción más segura.
¿Puedo migrar de CrewAI a LangGraph fácilmente?
La migración es directa en concepto pero requiere trabajo: cada Agent de CrewAI se convierte en uno o dos nodos de LangGraph, y cada Task en una arista o un conjunto de aristas condicionales. El grueso del esfuerzo es rediseñar el manejo de estado (CrewAI lo hace implícito, LangGraph exige tipado explícito). Los equipos que migran temprano suelen tardar 1-2 semanas por crew de tamaño medio.
Guía práctica de 2026 para crear servidores MCP en Python y TypeScript, elegir transporte (stdio, SSE, Streamable HTTP), integrar con Claude Desktop y evitar los tres principales vectores de ataque.
Guía práctica sobre los 6 patrones fundamentales de orquestación multi-agente: supervisor centralizado, pipeline, fan-out/fan-in, handoff, debate y enjambre. Con ejemplos en Python y frameworks como LangGraph, CrewAI y AutoGen.
