1~
2Los 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.
3~
4Cuatro 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.
5~
6## Vista General
7~
8| Aspecto | LangGraph | CrewAI | OpenAI Agents SDK | Claude Agent SDK |
9|--------|-----------|--------|-------------------|-----------------|
10| **Creado por** | LangChain | CrewAI Inc. | OpenAI | Anthropic |
11| **Arquitectura** | Basada en grafos | Basada en roles | Basada en handoff | Bucle autonomo |
12| **Filosofia** | Maximo control | Colaboracion de equipo | Abstraccion minima | Dale un ordenador al agente |
13| **Lenguajes** | Python, TypeScript | Python | Python | Python, TypeScript |
14| **Soporte de modelos** | Cualquiera (OpenAI, Claude, local) | Cualquiera | Cualquiera (a pesar del nombre) | Solo Claude |
15| **Estrellas GitHub** | ~29k | ~40k | ~21k | ~6k |
16| **Ideal para** | Workflows stateful complejos | Especializacion multi-agente | Routing y triage | Coding y tareas con archivos |
17~
18## LangGraph: El Constructor de Grafos
19~
20LangGraph 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.
21~
22Es el framework mas explicito y controlable  -  conectas cada paso tu mismo.
23~
24```mermaid
25graph LR
26    Start --> Router[Router Node]
27    Router -->|needs research| Research[Research Node]
28    Router -->|needs code| Code[Code Node]
29    Research --> Synthesize[Synthesize Node]
30    Code --> Synthesize
31    Synthesize --> End
32```
33~
34### Conceptos Clave
35~
36- **StateGraph**: la definicion del grafo con estado tipado
37- **Nodes**: funciones Python que transforman el estado
38- **Edges**: conexiones entre nodos, pueden ser condicionales
39- **Checkpointing**: persistencia integrada para workflows de larga duracion
40~
41### Ejemplo de Codigo
42~
43```python
44from langgraph.graph import StateGraph, MessagesState, START, END
45from langchain_openai import ChatOpenAI
46~
47llm = ChatOpenAI(model="gpt-4o")
48~
49def call_agent(state: MessagesState):
50    response = llm.invoke(state["messages"])
51    return {"messages": [response]}
52~
53def should_continue(state: MessagesState):
54    last = state["messages"][-1]
55    if last.tool_calls:
56        return "tools"
57    return END
58~
59def call_tools(state: MessagesState):
60    # Execute tool calls and return results
61    results = []
62    for tool_call in state["messages"][-1].tool_calls:
63        result = execute_tool(tool_call)
64        results.append(result)
65    return {"messages": results}
66~
67graph = StateGraph(MessagesState)
68graph.add_node("agent", call_agent)
69graph.add_node("tools", call_tools)
70graph.add_edge(START, "agent")
71graph.add_conditional_edges("agent", should_continue, {"tools": "tools", END: END})
72graph.add_edge("tools", "agent")
73~
74app = graph.compile()
75result = app.invoke({"messages": [{"role": "user", "content": "What's the weather?"}]})
76```
77~
78### Fortalezas
79~
80- Control granular sobre cada paso y transicion
81- Checkpointing integrado y human-in-the-loop
82- Paridad completa con TypeScript
83- Funciona con cualquier proveedor LLM
84- Ideal para workflows complejos con ramificacion condicional y bucles
85~
86### Debilidades
87~
88- Curva de aprendizaje pronunciada  -  necesitas entender conceptos de teoria de grafos
89- Verboso para casos de uso simples  -  un agente basico requiere mas boilerplate que otros frameworks
90- El debugging de flujos del grafo puede ser dificil sin LangSmith
91~
92### Precios
93~
94Open-source (MIT). LangSmith (plataforma de observabilidad gestionada) tiene planes de pago para monitoreo en produccion.
95~
96## CrewAI: El Ensamblador de Equipos
97~
98CrewAI 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).
99~
100Piensalo como contratar un equipo donde cada miembro tiene un titulo y una especialidad especificos.
101~
102```mermaid
103graph TD
104    Crew[Crew Manager] --> R[Researcher\nRole: Find data\nTools: WebSearch]
105    Crew --> W[Writer\nRole: Write content\nTools: FileWrite]
106    Crew --> E[Editor\nRole: Review quality\nTools: FileRead]
107    R --> Task1[Research Task]
108    W --> Task2[Writing Task]
109    E --> Task3[Review Task]
110    Task1 --> Task2 --> Task3
111```
112~
113### Conceptos Clave
114~
115- **Agent**: un persona con rol, objetivo, historia y tool
116- **Task**: una asignacion con descripcion, salida esperada y agente asignado
117- **Crew**: un grupo de agentes trabajando juntos
118- **Process**: estrategia de ejecucion (secuencial, jerarquica, consensuada)
119- **Flow**: capa de orquestacion event-driven para conectar multiples crews
120~
121### Ejemplo de Codigo
122~
123```python
124from crewai import Agent, Task, Crew, Process
125~
126researcher = Agent(
127    role="Senior Research Analyst",
128    goal="Find comprehensive data about the given topic",
129    backstory="You have 10 years of experience in technology research. "
130              "You are thorough and always verify facts from multiple sources.",
131    tools=[web_search_tool],
132    verbose=True,
133)
134~
135writer = Agent(
136    role="Technical Writer",
137    goal="Create clear, engaging technical content",
138    backstory="You write for a developer audience. "
139              "Your articles are practical and include code examples.",
140    tools=[file_tool],
141    verbose=True,
142)
143~
144research_task = Task(
145    description="Research the latest developments in WebAssembly in 2026. "
146                "Focus on WASI, Component Model, and production use cases.",
147    expected_output="A structured research document with key findings and sources.",
148    agent=researcher,
149)
150~
151writing_task = Task(
152    description="Write a blog post based on the research. "
153                "Include code examples and Mermaid diagrams.",
154    expected_output="A complete blog post in Markdown format.",
155    agent=writer,
156    context=[research_task],  # Writer receives researcher's output
157)
158~
159crew = Crew(
160    agents=[researcher, writer],
161    tasks=[research_task, writing_task],
162    process=Process.sequential,
163    verbose=True,
164)
165~
166result = crew.kickoff()
167print(result.raw)
168```
169~
170### Fortalezas
171~
172- Abstraccion basada en roles intuitiva  -  facil de razonar
173- Mas de 100 integraciones de tool incorporadas
174- Memoria compartida entre agentes (corto plazo, largo plazo, por entidad)
175- Mayor comunidad (~40k estrellas GitHub)
176- Proceso jerarquico con un agente "manager" que delega y valida
177~
178### Debilidades
179~
180- Menos control granular que LangGraph  -  defines roles, no rutas de ejecucion exactas
181- El proceso jerarquico puede ser impredecible cuando los agentes no estan de acuerdo
182- El debugging de conversaciones multi-agente es mas dificil que los flujos de un solo agente
183~
184### Precios
185~
186Core open-source (gratuito). CrewAI Platform: $99/mes (Teams) hasta $120k/anio (Enterprise). Precios basados en crews activos y ejecuciones mensuales.
187~
188## OpenAI Agents SDK: El Router
189~
190El 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.
191~
192```mermaid
193graph LR
194    User --> Triage[Triage Agent]
195    Triage -->|billing question| Billing[Billing Agent]
196    Triage -->|refund request| Refund[Refund Agent]
197    Triage -->|technical issue| Support[Support Agent]
198    Billing --> Response[Response]
199    Refund --> Response
200    Support --> Response
201```
202~
203### Conceptos Clave
204~
205- **Agent**: modelo + instrucciones + tool + handoff
206- **Handoff**: una transferencia a otro agente (modelada como un tool que el LLM puede llamar)
207- **Guardrail**: validacion de entrada/salida que se ejecuta en paralelo con el agente
208- **Runner**: ejecuta el bucle del agente
209- **Tracing**: observabilidad integrada para todas las llamadas LLM, invocaciones de tool y handoff
210~
211### Ejemplo de Codigo
212~
213```python
214from agents import Agent, Runner, handoff, InputGuardrail, GuardrailFunctionOutput
215from pydantic import BaseModel
216~
217class SafetyCheck(BaseModel):
218    is_safe: bool
219    reason: str
220~
221async def content_safety(ctx, agent, input_text):
222    result = await Runner.run(
223        Agent(name="Safety", instructions="Check if input is safe. No PII."),
224        input_text,
225        context=ctx,
226    )
227    output = SafetyCheck.model_validate_json(result.final_output)
228    return GuardrailFunctionOutput(
229        output_info=output, tripwire_triggered=not output.is_safe
230    )
231~
232billing_agent = Agent(
233    name="Billing Agent",
234    instructions="You handle billing inquiries. Be precise with numbers.",
235    tools=[lookup_invoice, process_payment],
236)
237~
238refund_agent = Agent(
239    name="Refund Agent",
240    instructions="You process refund requests. Always verify the order first.",
241    tools=[lookup_order, issue_refund],
242)
243~
244triage_agent = Agent(
245    name="Triage Agent",
246    instructions="Route the customer to the right specialist. "
247                 "Ask clarifying questions if needed.",
248    handoffs=[billing_agent, refund_agent],
249    input_guardrails=[InputGuardrail(guardrail_function=content_safety)],
250)
251~
252result = await Runner.run(triage_agent, "I need a refund for order #4521")
253print(result.final_output)
254# The triage agent routes to refund_agent, which processes the refund
255```
256~
257### Fortalezas
258~
259- Patron de handoff limpio  -  natural para workflows de routing/triage
260- Los guardrail se ejecutan en paralelo con la ejecucion (fail-fast, no bloqueantes)
261- Dashboard de tracing integrado para debugging
262- A pesar del nombre, soporta modelos no-OpenAI
263- Abstraccion minima  -  facil de entender y extender
264~
265### Debilidades
266~
267- Gestion de estado menos madura que LangGraph
268- Sin persistencia ni checkpointing integrados
269- El ecosistema de tool de terceros es mas reducido
270- El disenio centrado en handoff puede no adaptarse a toda arquitectura
271~
272### Precios
273~
274Open-source (MIT). Se paga por token segun el modelo utilizado.
275~
276## Claude Agent SDK: El Desarrollador
277~
278El 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.
279~
280```mermaid
281graph TD
282    Prompt[User Prompt] --> Loop[Autonomous Agent Loop]
283    Loop --> Reason[Reason about next step]
284    Reason --> Act[Execute tool]
285    Act --> Verify[Check result]
286    Verify -->|not done| Loop
287    Verify -->|done| Output[Final output]
288```
289~
290### Conceptos Clave
291~
292- **query()**: el punto de entrada principal que inicia el bucle del agente
293- **Tool integrados**: Read, Write, Edit, Bash, Glob, Grep, WebSearch, WebFetch
294- **Tool personalizados via MCP**: define tool como servidores MCP in-process
295- **Sub-agents**: agentes especializados a los que el padre puede delegar
296- **Sessions**: mantienen el contexto a traves de multiples interacciones
297~
298### Ejemplo de Codigo
299~
300```typescript
301import { tool, createSdkMcpServer, query } from "@anthropic-ai/claude-agent-sdk";
302import { z } from "zod";
303~
304const searchDocs = tool(
305  "search_docs",
306  "Search the internal documentation for relevant information",
307  { query: z.string().describe("Search query") },
308  async ({ query }) => {
309    const results = await vectorStore.similaritySearch(query, 5);
310    return {
311      content: [{ type: "text", text: results.map(r => r.pageContent).join("\n\n") }],
312    };
313  }
314);
315~
316const docsServer = createSdkMcpServer({
317  name: "docs",
318  version: "1.0.0",
319  tools: [searchDocs],
320});
321~
322for await (const message of query({
323  prompt: "Find how authentication works in our system and write a summary",
324  options: {
325    mcpServers: { docs: docsServer },
326    allowedTools: ["Read", "Glob", "Grep", "mcp__docs__search_docs"],
327  },
328})) {
329  if (message.type === "result" && message.subtype === "success") {
330    console.log(message.result);
331  }
332}
333```
334~
335### Fortalezas
336~
337- Integracion MCP de primera clase  -  conectate a cualquier ecosistema de servidores MCP
338- Tool integrados para operaciones de archivos, terminal y acceso web
339- Compactacion automatica del contexto para bases de codigo grandes
340- Paralelismo de sub-agents para tareas complejas
341- Mismo motor que Claude Code  -  probado en batalla en workflows de desarrollo reales
342~
343### Debilidades
344~
345- Solo modelos Claude  -  sin soporte multi-proveedor
346- Framework mas reciente con una comunidad mas pequenia
347- Requiere el runtime Node.js incluso para el SDK de Python
348- Menos control explicito del workflow comparado con LangGraph
349~
350### Precios
351~
352Open-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.
353~
354## Cuando Elegir Cual
355~
356```mermaid
357graph TD
358    Start{What's your priority?}
359    Start -->|Full control over workflow| LG[LangGraph]
360    Start -->|Multi-agent collaboration| CA[CrewAI]
361    Start -->|Routing and triage| OA[OpenAI Agents SDK]
362    Start -->|Coding and file automation| CS[Claude Agent SDK]
363~
364    LG --> LGU[Complex stateful workflows\nConditional branching\nHuman-in-the-loop]
365    CA --> CAU[Team of specialized agents\nResearch + writing pipelines\nContent generation]
366    OA --> OAU[Customer service routing\nMulti-step handoffs\nInput validation]
367    CS --> CSU[Code generation and review\nFile-heavy automation\nMCP tool ecosystem]
368```
369~
370### Elige LangGraph si:
371- Necesitas control preciso sobre cada paso del workflow
372- Tu caso de uso implica logica condicional compleja y bucles
373- Quieres persistencia integrada y checkpoints human-in-the-loop
374- Necesitas usar multiples proveedores LLM en el mismo workflow
375~
376### Elige CrewAI si:
377- Quieres una abstraccion intuitiva basada en roles
378- Tu tarea involucra multiples agentes con especialidades distintas
379- Necesitas que los agentes colaboren y se pasen contexto entre si
380- Valoras la comunidad mas grande y la mayor cantidad de integraciones
381~
382### Elige OpenAI Agents SDK si:
383- Tu patron principal es enrutar conversaciones hacia especialistas
384- Necesitas guardrail que validen entrada/salida en paralelo
385- Quieres la abstraccion mas simple posible con boilerplate minimo
386- El tracing y la observabilidad integrados son importantes
387~
388### Elige Claude Agent SDK si:
389- Tus agentes necesitan leer, escribir y ejecutar codigo
390- Quieres integracion de primera clase con servidores MCP
391- Necesitas agentes autonomos que iteren y se auto-corrijan
392- Ya usas Claude y quieres la integracion mas profunda
393~
394## Se Pueden Combinar los Frameworks?
395~
396Si. Un patron comun es usar un framework para la orquestacion y otro para los agentes individuales:
397~
398- **LangGraph** para el grafo del workflow general
399- **CrewAI** para un nodo especifico que requiere colaboracion multi-agente
400- **Claude Agent SDK** para sub-tareas relacionadas con coding via MCP
401- **OpenAI Agents SDK** para triage y routing orientado al cliente
402~
403Los frameworks no son mutuamente excluyentes. Usa el que se adapte a cada parte de tu sistema.
404~
405## Conclusion
406~
407Cada framework hace una apuesta clara:
408~
409- **LangGraph** optimiza para el control  -  tu decides cada transicion
410- **CrewAI** optimiza para la colaboracion  -  los agentes trabajan en equipo
411- **OpenAI Agents SDK** optimiza para la simplicidad  -  abstraccion minima, handoff limpios
412- **Claude Agent SDK** optimiza para la autonomia  -  dale tool y dejalo trabajar
413~
414La 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.
415~