LangGraph vs CrewAI: Arquitectura, Ciclos de Memoria y Orquestación de Agentes Autónomos Multi-Rol

1. La Evolución de los Agentes de IA: Más Allá de los Scripts Secuenciales

Durante la primera fase del ecosistema de IA generativa, el concepto de 'cadena' (Chain) dominó las implementaciones. Se trataba de secuencias rígidas: paso A llama al modelo de embeddings, paso B busca en la base vectorial y paso C genera un texto. Esta estructura lineal resultaba adecuada para búsquedas simples, pero colapsaba ante tareas complejas de ingeniería.

Los problemas del mundo real exigen Agencia y Autonomía: la capacidad de descomponer un objetivo general en sub-tareas, invocar herramientas externas, analizar si el resultado fue satisfactorio, reescribir consultas defectuosas y solicitar aprobación humana si surge una ambigüedad. Para orquestar estos comportamientos han surgido dos filosofías de diseño dominantes: LangGraph (control de bajo nivel basado en grafos de estado) y CrewAI (orquestación de alto nivel basada en roles colaborativos).

2. Anatomía de LangGraph: Grafos Cíclicos Dirigidos con Estado Compartido

Desarrollado por el equipo de Harrison Chase en LangChain, LangGraph no es una simple librería de prompts; es un motor de computación para coordinar flujos cíclicos con estado persistente. Su arquitectura se fundamenta en tres conceptos matemáticos precisos:

1. State (El Estado Central): Un esquema tipado (usualmente una clase de TypedDict o modelo Pydantic) que representa la memoria compartida por todo el grafo. Cada nodo puede leer el estado y devolver modificaciones incrementales mediante operadores de reducción (reducers como operator.add).
2. Nodes (Nodos): Funciones estándar de Python o clases que reciben el estado actual, ejecutan una operación (llamar a un LLM, consultar una API, ejecutar un script) y retornan el nuevo estado parcial.
3. Edges (Aristas y Aristas Condicionales): Definen la topología de navegación. Las aristas condicionales inspeccionan el estado emitido por un nodo y deciden dinámicamente cuál es el siguiente paso (por ejemplo, si el validador devuelve aprobado: False, el flujo regresa al nodo de redacción; si devuelve True, transita al nodo de publicación).

# Implementación de un flujo cíclico con LangGraph
from typing import TypedDict, Annotated, Literal
import operator
from langgraph.graph import StateGraph, START, END
from langgraph.checkpoint.memory import MemorySaver

# 1. Definición del Estado Compartido
class EstadoAgente(TypedDict):
    consulta: str
    borrador_codigo: str
    iteraciones: Annotated[int, operator.add]
    es_valido: bool

# 2. Definición de Nodos de Procesamiento
def nodo_programador(state: EstadoAgente):
    print(f"👨‍💻 Programando solución (Iteración {state['iteraciones'] + 1})...")
    # Simulación de generación de código por el LLM
    codigo = "def suma(a, b): return a + b"
    return {"borrador_codigo": codigo, "iteraciones": 1}

def nodo_evaluador(state: EstadoAgente):
    print("🔍 Evaluando tests unitarios del código...")
    # Lógica de verificación determinista
    valido = len(state["borrador_codigo"]) > 10
    return {"es_valido": valido}

# 3. Arista Condicional de Decisión
def decidir_siguiente_paso(state: EstadoAgente) -> Literal["programador", END]:
    if state["es_valido"] or state["iteraciones"] >= 3:
        return END
    return "programador"

# 4. Construcción del Grafo
workflow = StateGraph(EstadoAgente)
workflow.add_node("programador", nodo_programador)
workflow.add_node("evaluador", nodo_evaluador)

workflow.add_edge(START, "programador")
workflow.add_edge("programador", "evaluador")
workflow.add_conditional_edges("evaluador", decidir_siguiente_paso)

# Compilación con soporte de persistencia (MemorySaver)
app = workflow.compile(checkpointer=MemorySaver())

# Ejecución del Grafo
estado_final = app.invoke(
    {"consulta": "Crea una función de suma", "iteraciones": 0, "borrador_codigo": "", "es_valido": False},
    config={"configurable": {"thread_id": "sesion-101"}}
)
print("Resultado final:", estado_final["borrador_codigo"])

3. Anatomía de CrewAI: Equipos Basados en Roles e Intenciones

Fundado por João Moura, CrewAI adopta una perspectiva antropomórfica de la inteligencia artificial. En lugar de pensar en nodos y aristas de grafos, diseñas un equipo de profesionales virtuales dotados de personalidad, metas, herramientas y jerarquías:

• Agent (Agente): Se define mediante tres atributos centrales: role (su cargo profesional), goal (su objetivo innegociable) y backstory (su contexto biográfico y sesgos profesionales).
• Task (Tarea): La descripción explícita de lo que debe realizarse y el expected_output (el formato y rigor esperado en la entrega).
• Crew (La Cuadrilla): La entidad que agrupa a los agentes y define el proceso de ejecución (secuencial o jerárquico con un agente mánager que delega).

# Implementación de un equipo de investigación con CrewAI
from crewai import Agent, Task, Crew, Process

# 1. Agente Investigador
investigador = Agent(
    role="Investigador de Mercado Senior",
    goal="Descubrir las tendencias tecnológicas emergentes en computación cuántica",
    backstory="Eres un analista implacable con 15 años de experiencia en fondos de inversión tecnológica.",
    verbose=True,
    memory=True
)

# 2. Agente Redactor Técnico
redactor = Agent(
    role="Redactor Tecnológico Principal",
    goal="Traducir análisis complejos en resúmenes ejecutivos comprensibles",
    backstory="Especialista en comunicación corporativa capaz de simplificar conceptos matemáticos densos.",
    verbose=True
)

# 3. Asignación de Tareas
tarea_investigar = Task(
    description="Identifica los 3 mayores hitos de hardware cuántico en 2026.",
    expected_output="Lista de 3 viñetas con nombres de empresas, tecnologías y fechas clave.",
    agent=investigador
)

tarea_redactar = Task(
    description="Redacta un informe ejecutivo de 300 palabras basado en los hallazgos.",
    expected_output="Un documento estructurado con título, resumen e impacto en el mercado.",
    agent=redactor
)

# 4. Orquestación del Equipo
equipo = Crew(
    agents=[investigador, redactor],
    tasks=[tarea_investigar, tarea_redactar],
    process=Process.sequential
)

resultado = equipo.kickoff()
print(resultado)

4. Cuándo Elegir Cada Herramienta en Entornos Corporativos Reales

Casos de Uso Ideales para CrewAI

• Generación Automatizada de Informes y Contenido: Donde varios perfiles deben aportar puntos de vista divergentes (un crítico de estilo, un verificador de hechos y un redactor).
• Simulación de Escenarios y Análisis de Decisión: Probar cómo reaccionarían diferentes 'arquetipos' de clientes o competidores ante el lanzamiento de un nuevo producto.
• Prototipado Rápido de Agentes Autónomos: Cuando necesitas validar el valor de negocio de un flujo de agentes en días sin construir infraestructura compleja.

Casos de Uso Mandatorios para LangGraph

• Operaciones Críticas en Finanzas o Salud: Donde cada bifurcación lógica debe ser auditable y seguir reglas deterministas sin que el modelo decida 'inventar' rutas arbitrarias.
• Sistemas Transaccionales con Aprobación Humana: Por ejemplo, un agente que prepara transferencias bancarias o despliega código en servidores, requiriendo que un operario humano valide el estado antes de continuar.
• Agentes de Larga Duración (Long-Running Tasks): Procesos que duran horas o días y deben sobrevivir a reinicios de servidores reteniendo su estado en PostgreSQL.

5. Artículos Relacionados en The Calata

Continúa dominando el desarrollo de agentes autónomos y arquitecturas de software para IA:

• Garantiza respuestas estructuradas sin fallos con Structured Outputs y JSON Schemas con Outlines.
• Conecta tus agentes a herramientas locales siguiendo la Guía de Function Calling en Modelos Locales.
• Optimiza las instrucciones internas de tus nodos con DSPy y Programación Modular de Prompts.
• Aprende a proteger tus agentes de instrucciones hostiles en Seguridad y Validación de Entradas en LLMs.