Frameworks de IA Agentica Comparados: LangGraph vs CrewAI vs OpenAI Agents SDK vs Claude Agent SDK

Los agentes de IA han pasado de demos de investigacion a sistemas en produccion. Se espera que mas del 60% de las aplicaciones de IA empresariales incluyan componentes agentivos para 2026. Pero construir agentes desde cero - gestionando bucles de tool, estado, memoria, manejo de errores y coordinacion multi-agente - es complejo. Ahi es donde entran los frameworks.

Cuatro frameworks dominan en 2026: LangGraph, CrewAI, OpenAI Agents SDK y Claude Agent SDK. Cada uno adopta un enfoque fundamentalmente diferente al mismo problema: dar a los LLM la capacidad de razonar, planificar, usar tool y colaborar.

Vista General

LangGraph: El Constructor de Grafos

LangGraph modela los workflows de agentes como grafos ciclicos dirigidos. Defines nodos (funciones que hacen el trabajo) y aristas (transiciones entre ellos, opcionalmente condicionales). El estado fluye a traves del grafo y se persiste mediante checkpointing.

Es el framework mas explicito y controlable - conectas cada paso tu mismo.

Conceptos Clave

• StateGraph: la definicion del grafo con estado tipado
• Nodes: funciones Python que transforman el estado
• Edges: conexiones entre nodos, pueden ser condicionales
• Checkpointing: persistencia integrada para workflows de larga duracion

Ejemplo de Codigo

from langgraph.graph import StateGraph, MessagesState, START, END
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o")

def call_agent(state: MessagesState):
    response = llm.invoke(state["messages"])
    return {"messages": [response]}

def should_continue(state: MessagesState):
    last = state["messages"][-1]
    if last.tool_calls:
        return "tools"
    return END

def call_tools(state: MessagesState):
    # Execute tool calls and return results
    results = []
    for tool_call in state["messages"][-1].tool_calls:
        result = execute_tool(tool_call)
        results.append(result)
    return {"messages": results}

graph = StateGraph(MessagesState)
graph.add_node("agent", call_agent)
graph.add_node("tools", call_tools)
graph.add_edge(START, "agent")
graph.add_conditional_edges("agent", should_continue, {"tools": "tools", END: END})
graph.add_edge("tools", "agent")

app = graph.compile()
result = app.invoke({"messages": [{"role": "user", "content": "What's the weather?"}]})

Fortalezas

• Control granular sobre cada paso y transicion
• Checkpointing integrado y human-in-the-loop
• Paridad completa con TypeScript
• Funciona con cualquier proveedor LLM
• Ideal para workflows complejos con ramificacion condicional y bucles

Debilidades

• Curva de aprendizaje pronunciada - necesitas entender conceptos de teoria de grafos
• Verboso para casos de uso simples - un agente basico requiere mas boilerplate que otros frameworks
• El debugging de flujos del grafo puede ser dificil sin LangSmith

Precios

Open-source (MIT). LangSmith (plataforma de observabilidad gestionada) tiene planes de pago para monitoreo en produccion.

CrewAI: El Ensamblador de Equipos

CrewAI usa una metafora humana: ensamblas un crew de agentes especializados, cada uno con un rol, un objetivo y una historia. Los agentes colaboran en tareas usando tool, coordinados por un proceso (secuencial, jerarquico o consensuado).

Piensalo como contratar un equipo donde cada miembro tiene un titulo y una especialidad especificos.

Conceptos Clave

• Agent: un persona con rol, objetivo, historia y tool
• Task: una asignacion con descripcion, salida esperada y agente asignado
• Crew: un grupo de agentes trabajando juntos
• Process: estrategia de ejecucion (secuencial, jerarquica, consensuada)
• Flow: capa de orquestacion event-driven para conectar multiples crews

Ejemplo de Codigo

from crewai import Agent, Task, Crew, Process

researcher = Agent(
    role="Senior Research Analyst",
    goal="Find comprehensive data about the given topic",
    backstory="You have 10 years of experience in technology research. "
              "You are thorough and always verify facts from multiple sources.",
    tools=[web_search_tool],
    verbose=True,
)

writer = Agent(
    role="Technical Writer",
    goal="Create clear, engaging technical content",
    backstory="You write for a developer audience. "
              "Your articles are practical and include code examples.",
    tools=[file_tool],
    verbose=True,
)

research_task = Task(
    description="Research the latest developments in WebAssembly in 2026. "
                "Focus on WASI, Component Model, and production use cases.",
    expected_output="A structured research document with key findings and sources.",
    agent=researcher,
)

writing_task = Task(
    description="Write a blog post based on the research. "
                "Include code examples and Mermaid diagrams.",
    expected_output="A complete blog post in Markdown format.",
    agent=writer,
    context=[research_task],  # Writer receives researcher's output
)

crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    process=Process.sequential,
    verbose=True,
)

result = crew.kickoff()
print(result.raw)

Fortalezas

• Abstraccion basada en roles intuitiva - facil de razonar
• Mas de 100 integraciones de tool incorporadas
• Memoria compartida entre agentes (corto plazo, largo plazo, por entidad)
• Mayor comunidad (~40k estrellas GitHub)
• Proceso jerarquico con un agente "manager" que delega y valida

Debilidades

• Menos control granular que LangGraph - defines roles, no rutas de ejecucion exactas
• El proceso jerarquico puede ser impredecible cuando los agentes no estan de acuerdo
• El debugging de conversaciones multi-agente es mas dificil que los flujos de un solo agente

Precios

Core open-source (gratuito). CrewAI Platform: $99/mes (Teams) hasta $120k/anio (Enterprise). Precios basados en crews activos y ejecuciones mensuales.

OpenAI Agents SDK: El Router

El OpenAI Agents SDK (sucesor espiritual de Swarm) se enfoca en los handoff - agentes que transfieren conversaciones a otros agentes especializados. Es el framework mas minimalista: agentes, tool, handoff y guardrail. Eso es todo.

Conceptos Clave

• Agent: modelo + instrucciones + tool + handoff
• Handoff: una transferencia a otro agente (modelada como un tool que el LLM puede llamar)
• Guardrail: validacion de entrada/salida que se ejecuta en paralelo con el agente
• Runner: ejecuta el bucle del agente
• Tracing: observabilidad integrada para todas las llamadas LLM, invocaciones de tool y handoff

Ejemplo de Codigo

from agents import Agent, Runner, handoff, InputGuardrail, GuardrailFunctionOutput
from pydantic import BaseModel

class SafetyCheck(BaseModel):
    is_safe: bool
    reason: str

async def content_safety(ctx, agent, input_text):
    result = await Runner.run(
        Agent(name="Safety", instructions="Check if input is safe. No PII."),
        input_text,
        context=ctx,
    )
    output = SafetyCheck.model_validate_json(result.final_output)
    return GuardrailFunctionOutput(
        output_info=output, tripwire_triggered=not output.is_safe
    )

billing_agent = Agent(
    name="Billing Agent",
    instructions="You handle billing inquiries. Be precise with numbers.",
    tools=[lookup_invoice, process_payment],
)

refund_agent = Agent(
    name="Refund Agent",
    instructions="You process refund requests. Always verify the order first.",
    tools=[lookup_order, issue_refund],
)

triage_agent = Agent(
    name="Triage Agent",
    instructions="Route the customer to the right specialist. "
                 "Ask clarifying questions if needed.",
    handoffs=[billing_agent, refund_agent],
    input_guardrails=[InputGuardrail(guardrail_function=content_safety)],
)

result = await Runner.run(triage_agent, "I need a refund for order #4521")
print(result.final_output)
# The triage agent routes to refund_agent, which processes the refund

Fortalezas

• Patron de handoff limpio - natural para workflows de routing/triage
• Los guardrail se ejecutan en paralelo con la ejecucion (fail-fast, no bloqueantes)
• Dashboard de tracing integrado para debugging
• A pesar del nombre, soporta modelos no-OpenAI
• Abstraccion minima - facil de entender y extender

Debilidades

• Gestion de estado menos madura que LangGraph
• Sin persistencia ni checkpointing integrados
• El ecosistema de tool de terceros es mas reducido
• El disenio centrado en handoff puede no adaptarse a toda arquitectura

Precios

Open-source (MIT). Se paga por token segun el modelo utilizado.

Claude Agent SDK: El Desarrollador

El Claude Agent SDK adopta un enfoque diferente: en lugar de definir workflows o roles, le das al agente un conjunto de tool y lo dejas descubrir como realizar la tarea. Utiliza el mismo bucle autonomo que impulsa Claude Code - leer, actuar, verificar, iterar.

Conceptos Clave

• query(): el punto de entrada principal que inicia el bucle del agente
• Tool integrados: Read, Write, Edit, Bash, Glob, Grep, WebSearch, WebFetch
• Tool personalizados via MCP: define tool como servidores MCP in-process
• Sub-agents: agentes especializados a los que el padre puede delegar
• Sessions: mantienen el contexto a traves de multiples interacciones

Ejemplo de Codigo

import { tool, createSdkMcpServer, query } from "@anthropic-ai/claude-agent-sdk";
import { z } from "zod";

const searchDocs = tool(
  "search_docs",
  "Search the internal documentation for relevant information",
  { query: z.string().describe("Search query") },
  async ({ query }) => {
    const results = await vectorStore.similaritySearch(query, 5);
    return {
      content: [{ type: "text", text: results.map(r => r.pageContent).join("\n\n") }],
    };
  }
);

const docsServer = createSdkMcpServer({
  name: "docs",
  version: "1.0.0",
  tools: [searchDocs],
});

for await (const message of query({
  prompt: "Find how authentication works in our system and write a summary",
  options: {
    mcpServers: { docs: docsServer },
    allowedTools: ["Read", "Glob", "Grep", "mcp__docs__search_docs"],
  },
})) {
  if (message.type === "result" && message.subtype === "success") {
    console.log(message.result);
  }
}

Fortalezas

• Integracion MCP de primera clase - conectate a cualquier ecosistema de servidores MCP
• Tool integrados para operaciones de archivos, terminal y acceso web
• Compactacion automatica del contexto para bases de codigo grandes
• Paralelismo de sub-agents para tareas complejas
• Mismo motor que Claude Code - probado en batalla en workflows de desarrollo reales

Debilidades

• Solo modelos Claude - sin soporte multi-proveedor
• Framework mas reciente con una comunidad mas pequenia
• Requiere el runtime Node.js incluso para el SDK de Python
• Menos control explicito del workflow comparado con LangGraph

Precios

Open-source. Tarifas estandar por token de la API de Claude. Managed Agents (version alojada): $0.08 por hora de sesion ademas de los costos por token.

Cuando Elegir Cual

Elige LangGraph si:

• Necesitas control preciso sobre cada paso del workflow
• Tu caso de uso implica logica condicional compleja y bucles
• Quieres persistencia integrada y checkpoints human-in-the-loop
• Necesitas usar multiples proveedores LLM en el mismo workflow

Elige CrewAI si:

• Quieres una abstraccion intuitiva basada en roles
• Tu tarea involucra multiples agentes con especialidades distintas
• Necesitas que los agentes colaboren y se pasen contexto entre si
• Valoras la comunidad mas grande y la mayor cantidad de integraciones

Elige OpenAI Agents SDK si:

• Tu patron principal es enrutar conversaciones hacia especialistas
• Necesitas guardrail que validen entrada/salida en paralelo
• Quieres la abstraccion mas simple posible con boilerplate minimo
• El tracing y la observabilidad integrados son importantes

Elige Claude Agent SDK si:

• Tus agentes necesitan leer, escribir y ejecutar codigo
• Quieres integracion de primera clase con servidores MCP
• Necesitas agentes autonomos que iteren y se auto-corrijan
• Ya usas Claude y quieres la integracion mas profunda

Se Pueden Combinar los Frameworks?

Si. Un patron comun es usar un framework para la orquestacion y otro para los agentes individuales:

• LangGraph para el grafo del workflow general
• CrewAI para un nodo especifico que requiere colaboracion multi-agente
• Claude Agent SDK para sub-tareas relacionadas con coding via MCP
• OpenAI Agents SDK para triage y routing orientado al cliente

Los frameworks no son mutuamente excluyentes. Usa el que se adapte a cada parte de tu sistema.

Conclusion

Cada framework hace una apuesta clara:

• LangGraph optimiza para el control - tu decides cada transicion
• CrewAI optimiza para la colaboracion - los agentes trabajan en equipo
• OpenAI Agents SDK optimiza para la simplicidad - abstraccion minima, handoff limpios
• Claude Agent SDK optimiza para la autonomia - dale tool y dejalo trabajar

La eleccion correcta depende de tu workflow, tu equipo y tu stack existente. Elige el que coincida con tu caso de uso principal, aprendelo bien e incorpora los demas cuando llegues a su punto fuerte.