LangGraph vs CrewAI vs AutoGen: comparativa de frameworks para agentes IA

La pregunta "¿qué framework uso para mis agentes?" es una de las más frecuentes en equipos que están pasando de prototipos a producción. LangGraph, CrewAI y AutoGen son los tres nombres que aparecen en casi cualquier conversación técnica sobre el tema.

Esta comparativa va al grano: qué hace bien cada uno, dónde falla y cómo elegir.

Visión general

| | LangGraph | CrewAI | AutoGen | |--|-----------|--------|---------| | Mantenido por | LangChain | CrewAI | Microsoft | | Modelo mental | Grafo de estados | Equipo de roles | Conversación multi-agente | | Curva de aprendizaje | Alta | Baja | Media | | Control del flujo | Total (explícito) | Implícito | Semi-implícito | | Mejor para | Producción compleja | Prototipado rápido | Investigación y colaboración |

---

LangGraph

Concepto

LangGraph modela el comportamiento del agente como un grafo de estados. Defines nodos (acciones o llamadas al LLM) y aristas (transiciones entre estados). El agente avanza por el grafo en función del estado actual.

from langgraph.graph import StateGraph, END
from typing import TypedDict, List

class AgentState(TypedDict):
    messages: List[str]
    next_step: str
    resultado: str

def llamar_llm(state: AgentState) -> AgentState:
    # Lógica de llamada al LLM
    respuesta = llm.invoke(state["messages"])
    return {**state, "resultado": respuesta.content}

def usar_herramienta(state: AgentState) -> AgentState:
    # Ejecutar herramienta
    resultado = ejecutar_busqueda(state["resultado"])
    return {**state, "messages": state["messages"] + [resultado]}

def decidir_siguiente_paso(state: AgentState) -> str:
    if "necesito buscar" in state["resultado"].lower():
        return "herramienta"
    return END

# Construir el grafo
workflow = StateGraph(AgentState)
workflow.add_node("llm", llamar_llm)
workflow.add_node("herramienta", usar_herramienta)
workflow.add_conditional_edges("llm", decidir_siguiente_paso)
workflow.add_edge("herramienta", "llm")
workflow.set_entry_point("llm")

app = workflow.compile()

Fortalezas

Control total del flujo: sabes exactamente por dónde va el agente en cada momento. Puedes inspeccionar el estado, pausar, reanudar, retroceder.

Human-in-the-loop nativo: LangGraph tiene soporte explícito para pausar en puntos de decisión y esperar aprobación humana.

Persistencia de estado: integración con checkpointers para guardar y recuperar el estado del agente en cualquier punto.

Producción robusta: el control explícito del grafo hace que los bugs sean predecibles y los errores más fáciles de diagnosticar.

Debilidades

Verbosidad: construir incluso un agente simple requiere bastante código. La curva de aprendizaje inicial es pronunciada.

Overhead conceptual: pensar en términos de grafos no es natural para todos los casos de uso. Para flujos lineales, es matar moscas a cañonazos.

Cuándo elegir LangGraph

• Agentes complejos con múltiples ramas de decisión
• Cuando necesitas human-in-the-loop en puntos específicos
• Sistemas de producción donde el debugging y la observabilidad son críticos
• Flujos con estado persistente entre sesiones

---

CrewAI

Concepto

CrewAI modela los agentes como un equipo de roles. Defines agentes con un rol, objetivo y backstory, y asignas tareas a cada uno. El framework gestiona la comunicación entre agentes.

from crewai import Agent, Task, Crew

# Definir agentes con roles claros
investigador = Agent(
    role="Investigador de mercado",
    goal="Encontrar información relevante y actualizada sobre el tema",
    backstory="Eres un analista experto con acceso a múltiples fuentes de información",
    tools=[busqueda_web, busqueda_arxiv],
    llm="claude-sonnet-4-5",
    verbose=True
)

redactor = Agent(
    role="Redactor de informes",
    goal="Transformar la investigación en un informe ejecutivo claro y accionable",
    backstory="Especialista en comunicación empresarial con 10 años de experiencia",
    llm="claude-sonnet-4-5",
    verbose=True
)

# Definir tareas
tarea_investigacion = Task(
    description="Investiga las últimas tendencias en {tema}. Incluye datos cuantitativos y ejemplos concretos.",
    expected_output="Lista de 5-7 hallazgos clave con fuentes",
    agent=investigador
)

tarea_informe = Task(
    description="Crea un informe ejecutivo basado en la investigación. Máximo 500 palabras.",
    expected_output="Informe con resumen ejecutivo, hallazgos y recomendaciones",
    agent=redactor,
    context=[tarea_investigacion]  # Recibe el output de la investigación
)

# Ejecutar
equipo = Crew(
    agents=[investigador, redactor],
    tasks=[tarea_investigacion, tarea_informe],
    verbose=True
)

resultado = equipo.kickoff(inputs={"tema": "IA generativa en retail 2025"})

Fortalezas

Rapidez de prototipado: puedes tener un sistema multi-agente funcionando en 30 minutos. La abstracción de roles es intuitiva.

Legibilidad: el código CrewAI es fácil de leer y mantener. Los agentes y tareas se definen declarativamente.

Colaboración natural: el modelo mental de "equipo de roles" se mapea bien a muchos procesos empresariales reales.

Debilidades

Menor control del flujo: el flujo de ejecución es más opaco que en LangGraph. Es difícil intervenir en el medio de una ejecución.

Debugging complejo: cuando algo falla en el medio de una conversación multi-agente larga, encontrar el punto de fallo puede ser tedioso.

Producción menos madura: para sistemas de producción críticos, el control implícito puede ser un riesgo.

Cuándo elegir CrewAI

• Prototipado rápido de sistemas multi-agente
• Equipos que prefieren abstracciones de alto nivel
• Procesos que se mapean naturalmente a roles humanos
• Cuando la velocidad de desarrollo importa más que el control fino

---

AutoGen (Microsoft)

Concepto

AutoGen modela la interacción como una conversación entre agentes. Los agentes se comunican mediante mensajes y el framework gestiona los turnos de conversación.

from autogen import AssistantAgent, UserProxyAgent, GroupChat, GroupChatManager

# Agente asistente con capacidad de código
asistente = AssistantAgent(
    name="AsistenteIA",
    llm_config={
        "model": "gpt-4o",
        "api_key": "...",
        "temperature": 0,
    },
    system_message="Eres un asistente experto en análisis de datos. Escribe código Python cuando sea necesario."
)

# Proxy que ejecuta código automáticamente
ejecutor = UserProxyAgent(
    name="Ejecutor",
    human_input_mode="NEVER",  # No pide confirmación humana
    code_execution_config={"work_dir": "workspace"},
    max_consecutive_auto_reply=10
)

# Iniciar conversación
ejecutor.initiate_chat(
    asistente,
    message="Analiza el archivo ventas_2024.csv y genera un gráfico de tendencias mensuales"
)

Para sistemas multi-agente con roles más complejos:

# GroupChat para coordinar múltiples agentes
analista = AssistantAgent(name="Analista", ...)
critico = AssistantAgent(name="Critico", ...)
sintetizador = AssistantAgent(name="Sintetizador", ...)

groupchat = GroupChat(
    agents=[analista, critico, sintetizador, ejecutor],
    messages=[],
    max_round=12
)

manager = GroupChatManager(groupchat=groupchat, llm_config={...})
ejecutor.initiate_chat(manager, message="Investiga y debate las implicaciones de [tema]")

Fortalezas

Ejecución de código nativa: AutoGen está diseñado para agentes que ejecutan código Python. La integración es la más madura del mercado.

Debate y refinamiento: el patrón de múltiples agentes que debaten y critican las respuestas de los demás produce mejores resultados en tareas de razonamiento complejo.

Investigación activa: al ser un proyecto de Microsoft Research, tiene actualizaciones frecuentes y soporte para los últimos modelos.

Debilidades

Conversaciones difíciles de controlar: el flujo conversacional puede ser impredecible en sistemas complejos.

Coste elevado: las conversaciones largas entre múltiples agentes generan muchos tokens.

Menos adecuado para producción de bajo nivel: está más orientado a tareas de análisis y razonamiento que a sistemas de producción con flujos bien definidos.

Cuándo elegir AutoGen

• Tareas que requieren ejecución de código Python
• Investigación y análisis donde el debate entre agentes mejora la calidad
• Prototipado de sistemas donde el razonamiento complejo es clave
• Equipo familiarizado con el ecosistema Microsoft/Azure

---

La decisión: criterios prácticos

Usa LangGraph si:

• Vas a producción y necesitas control y observabilidad
• Tu flujo tiene puntos de decisión complejos o human-in-the-loop
• El debugging y la reproducibilidad son críticos

Usa CrewAI si:

• Necesitas prototipar rápido
• El caso de uso se mapea bien a roles humanos
• El equipo prefiere código declarativo y legible

Usa AutoGen si:

• Los agentes necesitan escribir y ejecutar código
• Quieres que los agentes debatan y refinen entre sí
• Estás en fase de investigación más que de producción

Una opción más: no usar framework

Para muchos casos de uso en producción, el mejor agente es el más simple posible: un bucle while que llama al LLM, procesa tool calls, y repite. Sin dependencias de frameworks, sin overhead, sin curva de aprendizaje para el equipo que lo mantenga.

Los frameworks añaden valor cuando la complejidad del caso de uso lo justifica — no antes.