LangGraph vs CrewAI vs AutoGen: Which Agent Framework Should You Use?

LangGraph and CrewAI solve the same problem from opposite ends. LangGraph makes you draw the agent's path as an explicit graph of nodes, edges and shared state, which gives you control, checkpoints and auditability. CrewAI lets you describe a team of agents by role, goal and task and let them collaborate, which gets a multi-agent prototype running fast, with Flows for the parts that need fixed control. AutoGen, the third name in most comparisons, is now archived by Microsoft; its successor is Microsoft Agent Framework.

Quick verdict

• Pick LangGraph for production workflows that need branching, retries, human approval mid-run and a clear record of what happened.
• Pick CrewAI when the problem is naturally a team of roles (researcher, analyst, writer) and speed to a working demo matters.
• Do not start on AutoGen. Use Microsoft Agent Framework instead if you want the AutoGen style, especially on Azure or .NET.
• Pick n8n if the job is mostly app-to-app automation with one agentic step and you prefer visual building.

The comparison table

Status checked on each project's GitHub repository on 18 October 2026.

LangGraph: explicit graphs and state

LangGraph calls itself a "low-level orchestration framework for building, managing, and deploying long-running, stateful agents." You define a state type, write each step as a node function that returns updates to that state, and wire nodes together with edges, including conditional edges that pick the next node. Its headline features are durable execution (agents that "persist through failures" and resume "from exactly where they left off"), human-in-the-loop by inspecting and modifying state at any point, and memory, with tracing in LangSmith.

LangChain itself now sits on top: its docs say "LangChain's agents are built on top of LangGraph," and recommend LangGraph "for advanced needs combining deterministic and agentic workflows."

Code shape: LangGraph

A support-triage graph. The classify node would call an LLM in real use; it is a stub here so the shape is clear. This runs on LangGraph 1.2.16:

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

class TicketState(TypedDict):
    text: str
    category: str
    reply: str

def classify(state: TicketState) -> dict:
    # Real version: ask an LLM for a category with structured output.
    return {"category": "refund" if "refund" in state["text"].lower() else "general"}

def route(state: TicketState) -> Literal["refund_desk", "answer"]:
    return "refund_desk" if state["category"] == "refund" else "answer"

def refund_desk(state: TicketState) -> dict:
    return {"reply": "Refund request logged for human review."}

def answer(state: TicketState) -> dict:
    return {"reply": "Here is the answer..."}  # Real version: an agent with tools

builder = StateGraph(TicketState)
builder.add_node("classify", classify)
builder.add_node("refund_desk", refund_desk)
builder.add_node("answer", answer)
builder.add_edge(START, "classify")
builder.add_conditional_edges("classify", route)
builder.add_edge("refund_desk", END)
builder.add_edge("answer", END)
graph = builder.compile()

print(graph.invoke({"text": "I want a refund for order 1042"}))

Notice what this buys you: the refund path is a fixed, testable branch, and only the answer node needs agentic freedom. That is the deterministic-first design most production agents should have.

Strengths: precise control, every step inspectable, natural fit for approvals and retries, strong persistence. Weaknesses: more code and concepts up front; you design the flow, the framework does not design it for you.

CrewAI: roles, tasks and Flows

CrewAI describes itself as a framework that gives developers "autonomous agent collaboration through Crews and precise, event-driven control through Flows." In a Crew, each agent has a role, goal and backstory; each task has a description, expected_output and an assigned agent; the crew runs tasks with a process such as sequential. Flows wrap crews with state, @start, @listen and @router steps. The current quickstart says "Flows are the recommended way to structure production apps: they own state and execution order," and scaffolds projects with crewai create flow, defining agents and crews in config files.

Code shape: CrewAI

Adapted from the example in CrewAI's README:

from crewai import Agent, Task, Crew, Process

researcher = Agent(
    role="Data Researcher",
    goal="Gather and validate supporting market data",
    backstory="You excel at finding and correlating multiple data sources",
)
analyst = Agent(
    role="Senior Market Analyst",
    goal="Conduct deep market analysis with expert insight",
    backstory="You're a veteran analyst known for identifying subtle market patterns",
)

research_task = Task(
    description="Find data on the {sector} sector for the past {timeframe}",
    expected_output="Key figures and sources",
    agent=researcher,
)
analysis_task = Task(
    description="Analyze the research and give a recommendation",
    expected_output="A one-page analysis with a confidence score",
    agent=analyst,
)

crew = Crew(
    agents=[researcher, analyst],
    tasks=[research_task, analysis_task],
    process=Process.sequential,
)
result = crew.kickoff(inputs={"sector": "tech", "timeframe": "1W"})

For production, CrewAI's own guidance is to put this crew inside a Flow, where a @router step decides what happens next based on typed state, instead of letting the crew decide everything.

Strengths: fastest route to a working multi-agent system; readable definitions; Flows add the control you need later. Weaknesses: role and backstory prompts add tokens to every call; autonomous crews are harder to make predictable and to debug than an explicit graph.

AutoGen: archived, use Microsoft Agent Framework

AutoGen popularized multi-agent conversations, and it still appears in most comparisons. But its repository now opens with a caution: "This project has been archived and is no longer actively maintained by Microsoft," with no "bug fixes, security fixes, new features, or support," and Microsoft "continue[s] to advise against production use." New users are told to start with Microsoft Agent Framework, and Microsoft publishes a migration guide.

Code shape: AutoGen (legacy)

For recognition only, AutoGen's AgentChat hello world from its README:

import asyncio
from autogen_agentchat.agents import AssistantAgent
from autogen_ext.models.openai import OpenAIChatCompletionClient

async def main() -> None:
    model_client = OpenAIChatCompletionClient(model="gpt-4.1")
    agent = AssistantAgent("assistant", model_client=model_client)
    print(await agent.run(task="Say 'Hello World!'"))
    await model_client.close()

asyncio.run(main())

Code shape: Microsoft Agent Framework (the successor)

Agent Framework "combines AutoGen's simple agent abstractions with Semantic Kernel's enterprise features" and adds graph-based workflows. Its 1.0 release for Python and .NET came on 2 April 2026. An agent with a tool, from Microsoft's docs (simplified):

import asyncio
from typing import Annotated
from pydantic import Field
from agent_framework import Agent, tool
from agent_framework.openai import OpenAIChatClient

@tool(approval_mode="never_require")
def get_weather(
    location: Annotated[str, Field(description="The location to get the weather for.")],
) -> str:
    """Get the weather for a given location."""
    return f"The weather in {location} is cloudy with a high of 15°C."

async def main() -> None:
    agent = Agent(
        client=OpenAIChatClient(),
        name="WeatherAgent",
        instructions="You are a helpful weather assistant.",
        tools=[get_weather],
    )
    response = await agent.run("What is the weather like in Amsterdam?")
    print(response.text)

asyncio.run(main())

Note the approval_mode on the tool: approvals are a first-class setting, which is what you want for any tool that changes data.

When to pick which

That last row matters. Many tasks in these comparisons do not need multiple agents at all. One agent with three precise tools, a turn limit and an approval step is easier to build and cheaper to run. For a wider look including the OpenAI Agents SDK, Claude Agent SDK, Google ADK, Pydantic AI and LlamaIndex, see AI agent frameworks compared, and for a worked single-agent example, how to build an AI agent.

Head to head on the things that bite in production

Debugging

In LangGraph, every run is a sequence of node executions with a state snapshot at each step, so when something goes wrong you can see which node produced the bad state. LangGraph's README points to LangSmith for tracing execution paths and state transitions. In a CrewAI crew, the interesting decisions happen inside agent conversations, so you read the reasoning of each agent to find the failure; Flows give you clearer checkpoints because each @listen or @router step is your code.

Cost

Both frameworks call the model on every agent step. CrewAI's role, goal and backstory text is part of each agent's prompt, so crews with many agents carry more fixed prompt text per call. LangGraph only calls the model in the nodes where you put a model call; deterministic nodes are free. In either framework, the cheapest design is the one that keeps model calls to the steps that need judgment.

Human approval

LangGraph's human-in-the-loop works by pausing a run so a person can inspect and modify state before it continues, which fits approval steps in the middle of a long process. CrewAI documents human-in-the-loop workflows and human input on task execution. Microsoft Agent Framework puts an approval_mode on each tool. Whichever you choose, put the approval on the tool that changes data, not on the final answer.

Migrating from AutoGen

If you have AutoGen code, the practical path is Microsoft's migration guide to Agent Framework, which keeps the agent-centric style. Move to LangGraph instead only if you also want explicit graphs; that is a redesign, not a port.

What about n8n?

The related searches show people weighing n8n against these frameworks. They are different tools. n8n is a workflow automation platform whose AI Agent node lets you "connect a chat model and one or more tools, and the agent decides which tools to call." It shines when the hard part is connecting apps (CRM, email, sheets, databases) and only one step needs judgment. LangGraph and CrewAI shine when the agent logic is the product and belongs in tested Python code. A common pattern is to use both: n8n handles triggers and integrations, and calls a LangGraph or CrewAI service over HTTP for the agentic step.

Practical advice from building with these

• Start deterministic. Draw the process first. Every branch you can write as an edge or a Flow router is one the model cannot get wrong. See what is agentic AI for the full argument.
• Watch token use. Multi-agent designs multiply model calls, and verbose role prompts are sent on every call. Keep instructions short and load detail only when needed (context engineering).
• Put approvals on write tools in whichever framework you choose.
• Trace everything. LangGraph pairs with LangSmith; Agent Framework has telemetry; whatever you use, log every tool call.
• Do not choose on stars. AutoGen has more GitHub stars than LangGraph and is archived.

The bottom line

LangGraph is the control-first choice: more design work, fewer surprises. CrewAI is the speed-first choice: describe the team, get results, then add Flows as you need control. AutoGen's ideas live on in Microsoft Agent Framework, which is where AutoGen users should go. For most real business processes the winning pattern is the same in any of them: a fixed outer flow you can test, with agentic freedom only at the steps that need judgment.