smolagents, CrewAI, or LangGraph — Which Agent Framework Should You Use?

Every team moving beyond one-off ChatGPT prompts into actual deployed systems hits the same wall: which agent framework? smolagents, CrewAI, LangGraph — they all build agents, they all work, and they're all meaningfully different. The positioning language doesn't help. This post cuts through it.

The decision matrix

If you want the answer fast, here it is:

The rest of this post explains why.

smolagents: minimum code, maximum flexibility

HuggingFace released smolagents in late 2024 with a clear philosophy: an agent should be as close to plain Python as possible. The framework is genuinely small — the core is under 1,000 lines.

The key differentiator is how the agent acts. Where most frameworks define a set of tools and have the agent emit JSON tool calls, smolagents agents write and execute Python code as their primary action. The agent decides what to do by writing a small Python snippet, which then runs.

from smolagents import CodeAgent, HfApiModel, DuckDuckGoSearchTool

agent = CodeAgent(
    tools=[DuckDuckGoSearchTool()],
    model=HfApiModel()
)

agent.run("Research the latest benchmarks for LLM reasoning and summarize the top 3 findings.")

That's a complete, runnable agent. Three lines of setup.

What code actions mean in practice: the agent can compose tools together in a single step, write loops, handle conditionals, and manipulate data — all within one action. A JSON-tool-calling agent would need multiple steps to do the same thing. This makes smolagents excellent for research and data analysis tasks where the action space is complex.

Best use cases: research tasks, data analysis, one-shot complex tasks, prototyping, teams that want to ship something working fast. If your agent needs to "figure out how to solve this problem" rather than "follow this workflow," smolagents is a good fit.

The tradeoffs: code execution is less predictable than predefined tool calls. You need a sandboxed environment for anything production-facing — letting an LLM write and run arbitrary Python in production without constraints is a security concern. The ecosystem is newer, community resources are thinner, and enterprise adoption is limited compared to LangGraph. If you need fine-grained control over execution flow, smolagents works against you rather than with you.

Use it when: you want a capable, flexible agent fast, with minimal infrastructure investment, for tasks where the agent needs to think creatively about how to accomplish the goal.

CrewAI: role-based teams with structure

CrewAI's mental model is a professional team. You define Agents with roles, goals, and backstories. You define Tasks. You assemble them into a Crew and kick it off.

from crewai import Agent, Task, Crew

researcher = Agent(
    role="Senior Research Analyst",
    goal="Find accurate, relevant information on any topic",
    backstory="Expert at synthesizing information from multiple sources",
    tools=[search_tool]
)

writer = Agent(
    role="Content Writer",
    goal="Write clear, engaging articles based on research",
    backstory="Experienced writer who turns research into readable content",
    tools=[]
)

research_task = Task(
    description="Research the current state of AI agent frameworks",
    agent=researcher,
    expected_output="Comprehensive research notes with key findings"
)

writing_task = Task(
    description="Write a 500-word summary based on the research",
    agent=writer,
    expected_output="A clear, well-structured article",
    context=[research_task]
)

crew = Crew(agents=[researcher, writer], tasks=[research_task, writing_task])
result = crew.kickoff()

The role/goal/backstory pattern influences how the LLM behaves for each agent — it's essentially structured system prompting baked into the framework.

Best use cases: content creation pipelines, research-then-write workflows, structured analysis tasks, any problem that maps naturally to "a team of specialists with different areas of responsibility."

The team metaphor is both the strength and the limitation: it maps well to human-analogous workflows. Content operations, research pipelines, customer support routing — these have natural specialist decompositions. When the problem doesn't map to a team shape, CrewAI becomes awkward. Trying to fit a complex data processing workflow into researcher/writer/editor framing is forcing a square peg into a round hole.

Sequential by default: CrewAI's default execution is sequential (task 2 waits for task 1, task 3 waits for task 2). This is predictable but can be slow for tasks that could run in parallel. You can configure hierarchical or parallel execution, but sequential is the default path.

Use it when: your workflow naturally maps to "a team of specialists with defined roles," and you want a structured, readable way to define that team in code.

LangGraph: stateful graphs for production

LangGraph is different in kind, not just degree. Where smolagents and CrewAI hide orchestration complexity from you, LangGraph makes you explicit about it. You define a state schema, define nodes (functions), define edges (transitions), and build a graph. The state persists and mutates as the graph executes.

from langgraph.graph import StateGraph, END
from typing import TypedDict

class AgentState(TypedDict):
    messages: list
    research_output: str
    draft: str
    approved: bool

def research_node(state: AgentState) -> AgentState:
    # Run research, update state
    return {**state, "research_output": run_research(state["messages"])}

def write_node(state: AgentState) -> AgentState:
    # Write content based on research
    return {**state, "draft": write_content(state["research_output"])}

def review_node(state: AgentState) -> AgentState:
    # Human or automated review
    approved = review_draft(state["draft"])
    return {**state, "approved": approved}

def route_after_review(state: AgentState) -> str:
    return END if state["approved"] else "write"  # Loop back if rejected

graph = StateGraph(AgentState)
graph.add_node("research", research_node)
graph.add_node("write", write_node)
graph.add_node("review", review_node)
graph.add_edge("research", "write")
graph.add_edge("write", "review")
graph.add_conditional_edges("review", route_after_review)
graph.set_entry_point("research")

app = graph.compile()

The explicit state schema is the key. You always know exactly what state the agent is in. Debugging is straightforward. Conditional branching (route after review) is first-class. Human-in-the-loop patterns (pause the graph, wait for input, resume) work cleanly.

Best use cases: complex multi-step workflows with branching logic, anything requiring persistent state across turns, human-in-the-loop approval flows, production deployments where observability matters, long-running agents that might fail mid-execution and need to resume.

For deeper coverage of LangGraph's stateful patterns, see LangGraph: building stateful agents.

The tradeoffs: steeper learning curve. You need to think in graphs, define state schemas explicitly, and understand how edges and conditions work. First-working-agent time is slower than smolagents or CrewAI. More boilerplate.

Use it when: you need production-grade control, stateful memory across turns, complex branching, or high observability requirements.

The dimensions that actually matter

Cutting across all three frameworks:

Complexity to get started: smolagents (low) < CrewAI (medium) < LangGraph (high)

Observability: LangGraph with LangSmith is the clear winner. CrewAI has reasonable logging. smolagents requires more manual instrumentation.

Flexibility: LangGraph (full control) > smolagents (code as action gives flexibility) > CrewAI (role metaphor constrains you)

Time to first working agent: smolagents (~15 min) < CrewAI (~30 min) < LangGraph (~2 hrs including learning curve)

Production maturity: LangGraph (battle-tested, extensive enterprise adoption) > CrewAI (mature, significant production use) > smolagents (newer, less production track record)

Community and ecosystem: LangGraph/LangChain (largest) > CrewAI (active, growing) > smolagents (smaller but HuggingFace-backed)

What about n8n, OpenAI Swarm, and AutoGen?

A few other options that come up:

n8n: The right choice if your team isn't primarily Python developers. Visual workflow builder with first-class AI Agent nodes. You can build a working agent in 15 minutes without writing code. Tradeoff: less precise control over agent behavior.

OpenAI Swarm: Experimental framework for OpenAI model handoffs between agents. Good for learning the concepts, not for production. Explicitly labeled experimental by OpenAI.

AutoGen (Microsoft): Strong for code generation and software engineering tasks specifically. Multi-agent conversation framework where agents talk to each other. Good option if code generation is your primary use case.

The practical recommendation

Most teams should follow this path:

1. Validate the use case first with smolagents or n8n. Can this task actually be automated? Does the quality meet the bar? Get answers fast with the lowest-friction tool.

2. Move to LangGraph when you need production control: stateful memory, complex branching, observability, or the reliability requirements of a production system.

3. Choose CrewAI when the workflow genuinely looks like a team: content pipelines, structured research, multi-step analysis where specialist decomposition is natural.

The common mistake is starting with LangGraph because it's "the right way" — then spending three weeks on infrastructure before validating the use case. Start simple. Upgrade when the complexity is earned.

If you're looking for a broader overview of how agents are architected before picking a framework, AI agent design patterns is a good primer.