LangChain vs CrewAI vs OpenAI Agents SDK 2026

Building AI Agents Got Complicated

In 2023, "building an AI agent" meant wrapping GPT-4 in a while loop with tool calling. In 2026, the frameworks have caught up to the complexity of real production agent systems. LangChain has LangGraph for stateful multi-agent workflows. CrewAI has role-based teams and enterprise orchestration. OpenAI released its official Agents SDK (formerly Swarm) with guardrails, handoffs, and tracing built in.

Each framework reflects a different philosophy about what "agent development" means, and choosing the wrong one adds technical debt that's painful to remove after you've built on top of it.

This comparison cuts through the feature lists to the architectural differences that actually matter: how each framework models agents, how it handles state, how it fails, and what it costs to operate.

TL;DR

LangChain/LangGraph is the right choice for complex, stateful agent workflows with precise control over execution flow, memory, and multi-model routing. It's the most flexible but requires the most engineering. CrewAI is the right choice when you want multi-agent collaboration with a clear mental model — assign roles, define tasks, let agents collaborate. Lower code, faster iteration. OpenAI Agents SDK is the right choice for teams already committed to OpenAI APIs who want minimal abstraction, first-class guardrails, and official support without a third-party framework dependency.

Key Takeaways

• LangChain: ~222M monthly PyPI downloads (langchain); LangGraph 1.0 went GA October 2025 — first stable major release; most flexible and most complex
• CrewAI: ~2M monthly PyPI downloads; v1.10.1 adds native MCP + A2A support; "Flows" event-driven layer added alongside Crews; ~46K GitHub stars
• OpenAI Agents SDK: v0.12.2 (pre-1.0); Assistants API being deprecated mid-2026 — Agents SDK is the migration path; native Responses API integration
• Language support: All three have Python; LangChain and OpenAI SDK have TypeScript (full parity); CrewAI is Python-only
• Observability: LangSmith Plus ($39/seat/month), CrewAI AMP Pro ($99/month), OpenAI Traces (included in platform)
• Best for beginners: OpenAI Agents SDK (functional agent in under an hour) or CrewAI (clearest mental model, 1-3 day ramp)
• Best for production complexity: LangGraph 1.0 (checkpointing, interrupt(), durable execution)

Architecture Comparison

LangChain: Chains and Graphs

LangChain v0.3+ has two distinct layers:

LCEL (LangChain Expression Language): For sequential pipelines and chains. The | operator composes components.

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

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

# LCEL chain: prompt | llm | parser
chain = (
    ChatPromptTemplate.from_template("Summarize this: {text}")
    | llm
    | StrOutputParser()
)

result = chain.invoke({"text": "..."})

# Streaming
for chunk in chain.stream({"text": "..."}):
    print(chunk, end="", flush=True)

LangGraph: For stateful, multi-step, multi-agent workflows. Models execution as a directed graph with explicit state.

from langgraph.graph import StateGraph, END
from langgraph.prebuilt import ToolNode
from typing import TypedDict, Annotated
import operator

# Define state schema
class AgentState(TypedDict):
    messages: Annotated[list, operator.add]
    research: str
    draft: str

# Define nodes
async def research_node(state: AgentState) -> AgentState:
    # Call research agent
    result = await research_agent.ainvoke(state["messages"])
    return {"research": result.content}

async def writer_node(state: AgentState) -> AgentState:
    # Call writing agent with research context
    result = await writer_agent.ainvoke({
        "messages": state["messages"],
        "research": state["research"]
    })
    return {"draft": result.content}

def router(state: AgentState) -> str:
    # Conditional routing logic
    if needs_revision(state["draft"]):
        return "revise"
    return END

# Build the graph
workflow = StateGraph(AgentState)
workflow.add_node("research", research_node)
workflow.add_node("writer", writer_node)
workflow.add_node("tools", ToolNode(tools))

workflow.set_entry_point("research")
workflow.add_edge("research", "writer")
workflow.add_conditional_edges("writer", router, {"revise": "writer", END: END})

app = workflow.compile()
result = await app.ainvoke({"messages": [HumanMessage(content="Write about AI agents")]})

LangGraph gives you precise control over every state transition. You can implement complex patterns: human-in-the-loop checkpoints, parallel execution, conditional branching, and persistent memory across sessions.

CrewAI: Roles and Teams

CrewAI models multi-agent systems as teams of specialized agents working on tasks:

from crewai import Agent, Task, Crew, Process
from crewai_tools import SerperDevTool, FileReadTool

# Define agents with roles
researcher = Agent(
    role="Research Analyst",
    goal="Find accurate, current information on the topic",
    backstory="Expert researcher with 10 years in tech journalism",
    tools=[SerperDevTool()],
    llm="gpt-4o",
    verbose=True
)

writer = Agent(
    role="Content Writer",
    goal="Write engaging, accurate content from research",
    backstory="Experienced technical writer who makes complex topics accessible",
    llm="gpt-4o-mini",  # cheaper model for writing
    verbose=True
)

# Define tasks
research_task = Task(
    description="Research the current state of AI agents in 2026",
    expected_output="A comprehensive research brief with sources",
    agent=researcher
)

write_task = Task(
    description="Write a 1000-word article based on the research",
    expected_output="A complete article ready for publication",
    agent=writer,
    context=[research_task]  # writer receives research output
)

# Assemble the crew
crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, write_task],
    process=Process.sequential,  # or Process.hierarchical for manager agents
    verbose=True
)

result = crew.kickoff(inputs={"topic": "AI agents in production"})

CrewAI's mental model maps naturally to how teams work: assign people (agents) roles, give them tasks, let them collaborate. The context parameter passes task outputs between agents automatically.

CrewAI also introduced Flows — an event-driven orchestration layer that runs alongside Crews for workloads requiring deterministic control rather than autonomous agent judgment:

from crewai.flow.flow import Flow, listen, start

class ContentFlow(Flow):
    @start()
    def fetch_data(self):
        return {"topic": "serverless databases"}

    @listen(fetch_data)
    def research(self, data):
        # Deterministic step: always runs after fetch_data
        return run_researcher_crew(data["topic"])

    @listen(research)
    def publish(self, research_output):
        return publish_article(research_output)

Flows are suitable when you want sequential guarantees that Crew's autonomous process doesn't provide.

# Hierarchical process: manager agent delegates to specialists
crew = Crew(
    agents=[manager, researcher, writer, reviewer],
    tasks=[analysis_task],
    process=Process.hierarchical,
    manager_llm="gpt-4o",  # more capable model for management
)

# Parallel tasks for efficiency
parallel_research_tasks = [
    Task(description="Research aspect 1", agent=researcher_1),
    Task(description="Research aspect 2", agent=researcher_2),
]
# Both run concurrently; synthesis_task receives both outputs

OpenAI Agents SDK: Minimal Abstraction

The OpenAI Agents SDK (released March 2025, evolved from Swarm, now at v0.12.2) provides the thinnest useful abstraction layer around OpenAI API calls. It's also the official migration path for Assistants API users — the Assistants API is slated for deprecation with a mid-2026 sunset target.

from agents import Agent, Runner, handoff, input_guardrail, GuardrailFunctionOutput
from agents.extensions.models.litellm_model import LitellmModel

# Define an agent
research_agent = Agent(
    name="Research Agent",
    instructions="You research topics and provide factual summaries. Only use information you can verify.",
    model="gpt-4o",
    tools=[web_search, read_url],
)

# Guardrails — validate inputs before processing
@input_guardrail
async def check_safe_content(ctx, agent, input) -> GuardrailFunctionOutput:
    # Run safety check in parallel with the main agent
    result = await safety_check_agent.run(input)
    return GuardrailFunctionOutput(
        output_info=result,
        tripwire_triggered=result.is_unsafe
    )

writing_agent = Agent(
    name="Writing Agent",
    instructions="Write clear, engaging content from research briefs.",
    model="gpt-4o-mini",
    input_guardrails=[check_safe_content],
)

# Handoffs — agent transfers control to another agent
triage_agent = Agent(
    name="Triage Agent",
    instructions="Determine if this request needs research or writing and route accordingly.",
    handoffs=[
        handoff(research_agent),
        handoff(writing_agent),
    ]
)

# Run with tracing
result = await Runner.run(
    triage_agent,
    "Write an article about serverless databases",
    trace=True  # Traces visible in OpenAI dashboard
)

print(result.final_output)

The Agents SDK's key feature is handoffs — when one agent decides another is better suited for the task, it transfers the conversation context cleanly. This models call-center style orchestration: a triage agent routes to specialists.

# Multi-turn conversation with maintained context
from agents import Runner

# Run is stateless — pass history manually
history = []
result1 = await Runner.run(agent, "What's the capital of France?")
history.extend(result1.to_input_messages())

result2 = await Runner.run(agent, "And what's the population?", input=history)
# Agent has context from previous exchange

# Streaming
async for event in Runner.run_streamed(agent, "Tell me a story"):
    if event.type == "raw_response_event":
        print(event.data.delta, end="")

Feature Comparison

Feature	LangChain/LangGraph	CrewAI	OpenAI Agents SDK
Python support	✅	✅	✅
TypeScript support	✅	Limited	✅
Multi-agent	✅ (LangGraph)	✅ (native)	✅ (handoffs)
Stateful workflows	✅ (LangGraph state machines)	Limited	Limited
Human-in-the-loop	✅ (interrupt/resume)	✅	✅ (callback)
Streaming	✅	✅	✅
Memory (persistent)	✅ (multiple backends)	✅	Manual
Tool calling	✅	✅	✅
Multi-model routing	✅	✅	Limited (primary OpenAI)
Guardrails	Via LangGraph	Via tasks	✅ (built-in)
Observability	LangSmith	CrewAI Enterprise	OpenAI dashboard
Parallel agents	✅	✅	Via asyncio
Learning curve	High	Medium	Low
Vendor lock-in	Low	Low	High (OpenAI)

Observability and Debugging

Production agents require observability. Here's how each framework handles it:

LangSmith (LangChain)

# Set up LangSmith tracing with one env var
import os
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_API_KEY"] = "ls__..."

# Every chain/agent run is automatically traced
result = chain.invoke({"text": "..."})
# Full trace at smith.langchain.com: inputs, outputs, timing, token counts, errors

LangSmith provides the most comprehensive observability: full trace trees, token usage per step, latency breakdown, side-by-side run comparison, and dataset-based evaluation. It's a separate paid service ($0/month on free tier, $39/month for teams).

CrewAI Enterprise

crew = Crew(
    agents=[...],
    tasks=[...],
    verbose=2,  # Detailed logging to stdout
)

# CrewAI Enterprise provides dashboard observability
# Community version: stdout logging + callbacks
from crewai.utilities.events import AgentExecutionCompletedEvent

def on_agent_complete(event: AgentExecutionCompletedEvent):
    print(f"Agent {event.agent.role} completed: {event.output}")

CrewAI's community version has verbose logging but limited structured observability. The Enterprise plan includes a dashboard. Most production teams pair it with LangSmith or integrate custom logging.

OpenAI Tracing

# OpenAI Agents SDK tracing is built-in
result = await Runner.run(agent, input, trace=True)

# Traces appear in OpenAI's platform dashboard
# Shows: agent handoffs, tool calls, latency, token usage
# No separate service needed for basic tracing

# Custom trace processor
from agents.tracing import set_trace_processors, TracingProcessor

class MyProcessor(TracingProcessor):
    def on_trace_start(self, trace): ...
    def on_span_end(self, span): ...

set_trace_processors([MyProcessor()])

The built-in tracing is the most convenient for OpenAI-native stacks. It doesn't require a separate service. The limitation is that it only shows OpenAI-side details — external tool calls and non-OpenAI model usage are less visible.

Memory and State

State persistence across agent runs is one of the hardest problems in agent systems:

# LangGraph: rich persistent state
from langgraph.checkpoint.sqlite import SqliteSaver

# Checkpoints saved to SQLite (or Postgres, Redis)
memory = SqliteSaver.from_conn_string("checkpoints.db")
app = workflow.compile(checkpointer=memory)

# Resume from checkpoint
config = {"configurable": {"thread_id": "user-123"}}
result = await app.ainvoke({"messages": [...]}, config=config)

# User returns next day — conversation continues
result2 = await app.ainvoke(
    {"messages": [HumanMessage(content="Continue where we left off")]},
    config=config
)

# CrewAI: memory system
from crewai.memory import LongTermMemory, ShortTermMemory, EntityMemory

crew = Crew(
    agents=[...],
    tasks=[...],
    memory=True,  # Enables all memory types
    long_term_memory=LongTermMemory(),  # Persists across crew runs
    short_term_memory=ShortTermMemory(),  # Within-run context
    entity_memory=EntityMemory(),  # Tracks entities mentioned across runs
)

# OpenAI Agents SDK: manual history management
from agents import Runner

# No built-in persistence — you manage history
history = load_from_db(session_id)
result = await Runner.run(agent, user_input, input=history)
history.extend(result.to_input_messages())
save_to_db(session_id, history)

LangGraph's checkpointing is the most sophisticated built-in persistence. CrewAI's memory system covers common patterns. The OpenAI SDK gives you control with less magic.

When to Choose Each

Choose LangChain/LangGraph if:

• Building complex, stateful workflows that require precise control over execution paths
• Need conditional branching, loops, human-in-the-loop interruption, and resumption
• Working with multiple LLM providers and need to route based on cost/quality
• Require sophisticated memory patterns (cross-session persistence, entity tracking)
• Have a team comfortable with Python graph-based programming
• Using LangSmith for evaluation and observability

Choose CrewAI if:

• Multi-agent collaboration is the primary use case and you want to model it like a team
• Want role-based agents with natural language role definitions
• Building research, writing, analysis, or any workflow with clear specialization boundaries
• Prefer a higher-level API with less boilerplate than LangGraph
• Deploying internally where non-engineers need to understand what agents are doing
• Quick iteration matters more than maximum control

Choose OpenAI Agents SDK if:

• Already committed to OpenAI's model ecosystem (no multi-provider requirement)
• Want the smallest possible abstraction over the OpenAI API
• Building handoff-based workflows where agents route to specialists
• Want guardrails as a first-class primitive without third-party setup
• Prefer official support and documentation from the model provider
• Concerned about third-party framework dependencies in production

Framework Maturity and Ecosystem

Dimension	LangChain	CrewAI	OpenAI Agents SDK
GitHub stars	~100K	~46K	~25K
PyPI downloads/mo	~222M (langchain)	~2M	~10M
TypeScript SDK	✅ Mature	❌ Python only	✅ Full parity (mid-2025)
Open source	✅ MIT	✅ MIT	✅ MIT
Cloud product	LangSmith ($39/seat/mo)	CrewAI AMP ($99/mo)	OpenAI platform (included)
Stable version	✅ 1.x (LangGraph 1.0 GA Oct 2025)	✅ 1.x	⚠️ 0.x (v0.12.2, pre-1.0)
First release	2022	2024	March 2025

LangChain's 2022 head start gives it the largest ecosystem — 200+ LLM providers, vector stores, document loaders, and tools. CrewAI's simpler mental model has driven 3–4x growth in 2025. The OpenAI Agents SDK is the migration path for teams on the Assistants API (which is being deprecated mid-2026), giving it a built-in growth vector.

---

Track LangChain, CrewAI, and OpenAI SDK download trends and API compatibility on APIScout.

Related: Vercel AI SDK vs LangChain · LangSmith vs Langfuse vs Braintrust · LLM API Pricing 2026