The Agentic AI Landscape in May 2024, LangGraph, AutoGen, CrewAI

TL;DR — LangGraph wins when you need explicit state and retries. AutoGen wins when you genuinely need multiple agents talking. CrewAI wins when you want a prototype in front of a stakeholder by Friday.

Every quarter the agent space pretends it has been reinvented. It hasn’t. What we have in May 2024 is three frameworks that survived the hype of late 2023 and a growing pile of production lessons that say “the framework is the easy part.” I’ve been shipping agents into customer workflows since GPT-4 became reliable enough to trust with anything outside a sandbox, and at this point my framework choice is almost always a function of how much state I need to manage and how loud the failure mode is.

This post is the field guide I wish I’d had six months ago. No benchmarks, no “X is dead” takes. Just what each framework feels like under load, where it fights you, and what to reach for when. We’ll write the same trivial agent in all three and then talk about what changes when you put it in front of real users.

The premise I keep returning to is this. An agent is a loop. The loop calls an LLM, the LLM picks a tool, the tool runs, the result goes back into the loop. Everything interesting in agent frameworks is about how that loop is represented, how state survives across iterations, and how you debug it when iteration 14 of 30 returns something nonsensical at 3am.

LangGraph, the state machine I actually wanted

LangGraph, sitting at 0.0.40 as of this week, is the framework I reach for when an agent has to do more than three things in sequence. It models the agent loop as a directed graph where nodes mutate a typed state dict and edges decide what runs next. That sounds boring, which is exactly why it works.

from typing import TypedDict, Annotated
from langgraph.graph import StateGraph, END
from langgraph.graph.message import add_messages
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, AIMessage

class AgentState(TypedDict):
    messages: Annotated[list, add_messages]
    iterations: int

llm = ChatOpenAI(model="gpt-4-turbo", temperature=0)

def call_model(state: AgentState) -> AgentState:
    response = llm.invoke(state["messages"])
    return {"messages": [response], "iterations": state["iterations"] + 1}

def should_continue(state: AgentState) -> str:
    if state["iterations"] >= 5:
        return END
    last = state["messages"][-1]
    return END if not getattr(last, "tool_calls", None) else "tools"

builder = StateGraph(AgentState)
builder.add_node("agent", call_model)
builder.set_entry_point("agent")
builder.add_conditional_edges("agent", should_continue)
graph = builder.compile()

The thing that sells LangGraph to me is checkpointing. You can hand it a SQLite or Postgres checkpointer and resume an agent run from any node, which means a process crash mid-loop is recoverable instead of catastrophic. For background workers behind a queue, that’s the difference between calling it production-ready and calling it a demo.

The cost is verbosity. You’ll write more code than you would in CrewAI for the same flow. That code is the documentation, though, which I’m fine with.

AutoGen, when agents need to argue

Microsoft’s AutoGen is in a strange place at 0.2.27. The team has announced an architectural rewrite for 0.3, so anything you build today on the conversation-based API may need a port. With that caveat, AutoGen remains the most natural way to express genuine multi-agent dialogue. Critic-and-coder pairs, planner-executor splits, group chats with a manager picking who speaks next.

import autogen

config_list = [{"model": "gpt-4-turbo", "api_key": "sk-..."}]

assistant = autogen.AssistantAgent(
    name="coder",
    llm_config={"config_list": config_list, "temperature": 0},
    system_message="You write Python. Reply TERMINATE when done.",
)

user_proxy = autogen.UserProxyAgent(
    name="runner",
    human_input_mode="NEVER",
    max_consecutive_auto_reply=8,
    code_execution_config={"work_dir": "scratch", "use_docker": False},
    is_termination_msg=lambda m: "TERMINATE" in m.get("content", ""),
)

user_proxy.initiate_chat(assistant, message="Compute the 30th Fibonacci number in Python.")

The honest take is that AutoGen shines on problems that are genuinely multi-actor. If your “multi-agent system” is really a sequence of LLM calls with different prompts, you don’t need AutoGen. You need LangGraph or a plain function. The places AutoGen earns its keep are code generation with a separate reviewer, simulated debates for research synthesis, and any flow where you want emergent turn-taking instead of a hardcoded order.

The thing I’d flag is that AutoGen’s default loops can blow your budget fast if you don’t cap max_consecutive_auto_reply. Two agents will happily talk to each other forever. I learned that the expensive way.

CrewAI, the framework for the demo on Friday

CrewAI hit a real product-market fit with non-engineering stakeholders. Roles, tasks, and goals as first-class concepts read like a project plan, which is exactly what a PM wants to see. Under the hood it’s a thinner wrapper over LangChain than LangGraph is, with strong opinions about hierarchy.

from crewai import Agent, Task, Crew
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4-turbo", temperature=0)

researcher = Agent(
    role="Market Researcher",
    goal="Find three relevant competitors to a given product",
    backstory="You read tech news for a living.",
    llm=llm,
    verbose=False,
)

writer = Agent(
    role="Analyst",
    goal="Summarize findings into a one-paragraph brief",
    backstory="You write executive memos.",
    llm=llm,
)

research_task = Task(
    description="Identify three competitors to a self-hosted feature flag service.",
    expected_output="Bulleted list with one-line descriptions.",
    agent=researcher,
)
write_task = Task(
    description="Write a 3-sentence brief based on the research.",
    expected_output="Paragraph, no bullets.",
    agent=writer,
    context=[research_task],
)

crew = Crew(agents=[researcher, writer], tasks=[research_task, write_task])
print(crew.kickoff())

CrewAI’s strength is also its weakness. The role-and-goal abstraction is great for getting started, less great when you discover that “the researcher keeps inventing companies.” You’ll eventually fight the framework to add validation, retry policies, and structured outputs. At that point you’re better served by LangGraph, but for an internal tool used by ten people, the framework gets you there in an afternoon.

How I pick

Three questions decide it for me. First, does this agent need to recover from a crash mid-run? If yes, LangGraph. Second, is there genuine multi-actor reasoning, where you’d describe what’s happening as a conversation rather than a pipeline? If yes, AutoGen. Third, does anyone non-technical need to read or modify the agent definition? If yes, CrewAI.

There’s a fourth answer worth saying out loud. For a lot of “agent” workloads, you don’t need a framework at all. A while loop, a structured output schema via the OpenAI function calling docs, and a careful prompt will outperform any framework on tasks under five steps. I’ll cover when that minimalism breaks down in /blog/production-agents-langgraph-state-machines/.

Common Pitfalls

The mistakes I see most across teams adopting these frameworks in 2024.

• Choosing the framework before defining the loop. Sketch the state transitions on paper. If you can’t, no framework will save you.
• Ignoring token costs in multi-agent setups. AutoGen and CrewAI both inflate token usage 3x to 5x over a single-call equivalent. Budget accordingly.
• Skipping checkpointing. Every production agent eventually crashes mid-run. LangGraph’s checkpointers exist for a reason; use them from day one.
• Hiding tool failures from the LLM. When a tool errors, return the error to the model. Don’t swallow it and pretend. The model is often capable of retrying with corrected input.
• Pinning to the wrong LangChain version. LangChain 0.1.x APIs are mostly stable now, but the integration packages move fast. Pin everything, including transitive deps.

Wrapping Up

The agent framework you pick in May 2024 matters less than the discipline you apply to state, retries, and observability. LangGraph gives you structure, AutoGen gives you multi-actor dialogue, CrewAI gives you speed. The mistake is treating any of them as the whole solution. The framework is the loop runner. The hard parts are the prompts, the tools, the evals, and knowing when to fall back to a human.

If you’re starting today and you don’t know which to pick, start with LangGraph. The verbosity is a feature when you’re three weeks in and trying to debug why iteration 7 fell off a cliff. Everything else is easier to migrate to than away from.