1~
2AI agents have moved from research demos to production systems. Over 60% of enterprise AI applications are expected to include agentic components by 2026. But building agents from scratch  -  managing tool loops, state, memory, error handling, and multi-agent coordination  -  is complex. That's where frameworks come in.
3~
4Four frameworks dominate in 2026: **LangGraph**, **CrewAI**, **OpenAI Agents SDK**, and **Claude Agent SDK**. Each takes a fundamentally different approach to the same problem: giving LLMs the ability to reason, plan, use tools, and collaborate.
5~
6## At a Glance
7~
8| Aspect | LangGraph | CrewAI | OpenAI Agents SDK | Claude Agent SDK |
9|--------|-----------|--------|-------------------|-----------------|
10| **By** | LangChain | CrewAI Inc. | OpenAI | Anthropic |
11| **Architecture** | Graph-based | Role-based | Handoff-based | Autonomous loop |
12| **Philosophy** | Maximum control | Team collaboration | Minimal abstraction | Give agent a computer |
13| **Languages** | Python, TypeScript | Python | Python | Python, TypeScript |
14| **Model support** | Any (OpenAI, Claude, local) | Any | Any (despite the name) | Claude only |
15| **GitHub stars** | ~29k | ~40k | ~21k | ~6k |
16| **Best for** | Complex stateful workflows | Multi-agent specialization | Routing and triage | Coding and file-heavy tasks |
17~
18## LangGraph: The Graph Builder
19~
20LangGraph models agent workflows as **directed cyclic graphs**. You define nodes (functions that do work) and edges (transitions between them, optionally conditional). State flows through the graph and persists via checkpointing.
21~
22This is the most explicit and controllable framework  -  you wire every step yourself.
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### Core Concepts
35~
36- **StateGraph**: the graph definition with typed state
37- **Nodes**: Python functions that transform state
38- **Edges**: connections between nodes, can be conditional
39- **Checkpointing**: built-in persistence for long-running workflows
40~
41### Code Example
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### Strengths
79~
80- Fine-grained control over every step and transition
81- Built-in checkpointing and human-in-the-loop
82- Full TypeScript parity
83- Works with any LLM provider
84- Best for complex workflows with conditional branching and loops
85~
86### Weaknesses
87~
88- Steep learning curve  -  you need to understand graph theory concepts
89- Verbose for simple use cases  -  a basic agent requires more boilerplate than other frameworks
90- Debugging graph flows can be challenging without LangSmith
91~
92### Pricing
93~
94Open-source (MIT). LangSmith (managed observability platform) has paid tiers for production monitoring.
95~
96## CrewAI: The Team Assembler
97~
98CrewAI takes a human metaphor: you assemble a **crew** of specialized agents, each with a **role**, **goal**, and **backstory**. Agents collaborate on **tasks** using **tools**, coordinated by a **process** (sequential, hierarchical, or consensual).
99~
100Think of it as hiring a team where each member has a specific job title and specialty.
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### Core Concepts
114~
115- **Agent**: a persona with role, goal, backstory, and tools
116- **Task**: an assignment with description, expected output, and assigned agent
117- **Crew**: a group of agents working together
118- **Process**: execution strategy (sequential, hierarchical, consensual)
119- **Flow**: event-driven orchestration layer for connecting multiple crews
120~
121### Code Example
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### Strengths
171~
172- Intuitive role-based abstraction  -  easy to reason about
173- 100+ built-in tool integrations
174- Shared memory across agents (short-term, long-term, entity)
175- Largest community (~40k GitHub stars)
176- Hierarchical process with a "manager" agent that delegates and validates
177~
178### Weaknesses
179~
180- Less fine-grained control than LangGraph  -  you define roles, not exact execution paths
181- Hierarchical process can be unpredictable when agents disagree
182- Debugging multi-agent conversations is harder than single-agent flows
183~
184### Pricing
185~
186Open-source core (free). CrewAI Platform: $99/month (Teams) to $120k/year (Enterprise). Pricing based on live crews and monthly executions.
187~
188## OpenAI Agents SDK: The Router
189~
190The OpenAI Agents SDK (spiritual successor to Swarm) focuses on **handoffs**  -  agents transferring conversations to other specialized agents. It is the most minimal framework: agents, tools, handoffs, and guardrails. That's it.
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### Core Concepts
204~
205- **Agent**: model + instructions + tools + handoffs
206- **Handoff**: a transfer to another agent (modeled as a tool the LLM can call)
207- **Guardrail**: input/output validation that runs in parallel with the agent
208- **Runner**: executes the agent loop
209- **Tracing**: built-in observability for all LLM calls, tool invocations, and handoffs
210~
211### Code Example
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### Strengths
258~
259- Clean handoff pattern  -  natural for routing/triage workflows
260- Guardrails run in parallel with execution (fail-fast, not blocking)
261- Built-in tracing dashboard for debugging
262- Despite the name, supports non-OpenAI models
263- Minimal abstraction  -  easy to understand and extend
264~
265### Weaknesses
266~
267- Less mature state management than LangGraph
268- No built-in persistence or checkpointing
269- Ecosystem of third-party tools is smaller
270- Handoff-centric design may not fit every architecture
271~
272### Pricing
273~
274Open-source (MIT). You pay per-token for whatever model you use.
275~
276## Claude Agent SDK: The Developer
277~
278The Claude Agent SDK takes a different approach: instead of defining workflows or roles, you give the agent a **set of tools and let it figure out how to accomplish the task**. It uses the same autonomous loop that powers Claude Code  -  read, act, verify, iterate.
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### Core Concepts
291~
292- **query()**: the main entry point that starts the agent loop
293- **Built-in tools**: Read, Write, Edit, Bash, Glob, Grep, WebSearch, WebFetch
294- **Custom tools via MCP**: define tools as in-process MCP servers
295- **Sub-agents**: specialized agents the parent can delegate to
296- **Sessions**: maintain context across multiple interactions
297~
298### Code Example
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### Strengths
336~
337- First-class MCP integration  -  connect to any MCP server ecosystem
338- Built-in tools for file operations, terminal, and web access
339- Automatic context compaction for large codebases
340- Sub-agent parallelism for complex tasks
341- Same engine as Claude Code  -  battle-tested on real development workflows
342~
343### Weaknesses
344~
345- Claude models only  -  no multi-provider support
346- Newer framework with a smaller community
347- Requires Node.js runtime even for the Python SDK
348- Less explicit workflow control compared to LangGraph
349~
350### Pricing
351~
352Open-source. Standard Claude API token rates. Managed Agents (hosted version): $0.08 per session-hour in addition to token costs.
353~
354## When to Choose Which
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### Choose LangGraph if:
371- You need precise control over every step of the workflow
372- Your use case involves complex conditional logic and loops
373- You want built-in persistence and human-in-the-loop checkpoints
374- You need to use multiple LLM providers in the same workflow
375~
376### Choose CrewAI if:
377- You want an intuitive, role-based abstraction
378- Your task involves multiple agents with distinct specialties
379- You need agents to collaborate and pass context between each other
380- You value the largest community and most built-in integrations
381~
382### Choose OpenAI Agents SDK if:
383- Your primary pattern is routing conversations to specialists
384- You need guardrails that validate input/output in parallel
385- You want the simplest possible abstraction with minimal boilerplate
386- Built-in tracing and observability are important
387~
388### Choose Claude Agent SDK if:
389- Your agents need to read, write, and execute code
390- You want first-class MCP server integration
391- You need autonomous agents that iterate and self-correct
392- You are already using Claude and want the deepest integration
393~
394## Can You Combine Frameworks?
395~
396Yes. A common pattern is using one framework for orchestration and another for individual agents:
397~
398- **LangGraph** for the overall workflow graph
399- **CrewAI** for a specific node that requires multi-agent collaboration
400- **Claude Agent SDK** for coding-related sub-tasks via MCP
401- **OpenAI Agents SDK** for customer-facing triage and routing
402~
403The frameworks are not mutually exclusive. Use what fits each part of your system.
404~
405## Conclusion
406~
407Each framework makes a clear bet:
408~
409- **LangGraph** optimizes for control  -  you decide every transition
410- **CrewAI** optimizes for collaboration  -  agents work as a team
411- **OpenAI Agents SDK** optimizes for simplicity  -  minimal abstraction, clean handoffs
412- **Claude Agent SDK** optimizes for autonomy  -  give it tools and let it work
413~
414The right choice depends on your workflow, your team, and your existing stack. Pick the one that matches your primary use case, learn it well, and pull in others when you hit their sweet spot.
415~