Everyone and their GitHub readme is talking about AI agents now. The good news: frameworks exist that don’t suck. The bad news: half the “agent” projects on Product Hunt are just a single API call to Claude with tools=true wrapped in a React component.
Let’s talk about the three frameworks that are actually solving real problems: LangGraph, CrewAI, and AutoGen. They take different philosophies about how agents should work, and your choice matters more than the hype cycle suggests.
What Even Is an AI Agent?
An agent is an LLM running in a loop. The loop looks like:
- LLM observes state (context, memory, previous results)
- LLM decides what to do next (call a tool, stop, ask for clarification)
- Tool runs, returns result
- Back to step 1
That’s it. Everything else is logistics: how do you structure that loop, where does memory live, how many agents are talking to each other, what happens when one agent calls another.
The frameworks differ on how rigid that loop is and how much scaffolding they provide.
LangGraph: You Build the State Machine
LangGraph is LangChain’s answer to “what if we made agents first-class in the library?” It treats your agent as a directed graph where nodes are functions and edges are transitions. You define the graph; LangGraph runs it.
Philosophy: Low-level, explicit control. You own the state machine.
from langgraph.graph import StateGraphfrom typing import TypedDict
class ResearchState(TypedDict): question: str research: str final_answer: str
def research_node(state: ResearchState): # Call your search tool, research API, whatever research_result = search_web(state["question"]) return {"research": research_result}
def synthesize_node(state: ResearchState): # LLM synthesizes findings answer = llm.invoke(f"Based on this research: {state['research']}, answer: {state['question']}") return {"final_answer": answer}
graph = StateGraph(ResearchState)graph.add_node("research", research_node)graph.add_node("synthesize", synthesize_node)graph.add_edge("research", "synthesize")graph.set_entry_point("research")
agent = graph.compile()result = agent.invoke({"question": "How does LangGraph work?"})Real talk: This feels like writing a Kubernetes manifest for your agent. You’re explicit about every transition, every state shape, every node. If you love control and don’t mind the boilerplate, LangGraph is your friend. For complex stateful pipelines — like a research agent that branches into multiple analyses, then aggregates — this is the right tool.
CrewAI: Your Agents Have Job Titles
CrewAI takes a very different angle: agents are crew members with roles, and you give them tasks. It’s closer to how human teams work. Your agent is a “Research Analyst” or “Content Writer,” not a generic LLM loop.
Philosophy: Role-based orchestration. Agents have personalities and responsibilities.
from crewai import Agent, Task, Crew
researcher = Agent( role="Research Analyst", goal="Find accurate, detailed information", backstory="You are a thorough researcher with access to search tools.", tools=[search_tool])
writer = Agent( role="Content Writer", goal="Write engaging, clear content", backstory="You are a technical writer known for clarity.", tools=[writing_tool])
research_task = Task( description="Research {topic} and provide detailed findings", agent=researcher)
write_task = Task( description="Write an article based on research findings", agent=writer)
crew = Crew(agents=[researcher, writer], tasks=[research_task, write_task])result = crew.kickoff(inputs={"topic": "AI agents"})This is dramatically simpler than LangGraph for multi-agent orchestration. You define agents once, give them tools, and describe tasks. CrewAI handles the loop, the state passing, the handoffs. It Just Works™ for role-based workflows.
Trade-off: Less explicit control. You’re trusting CrewAI’s orchestration logic, which works great for linear or semi-linear task pipelines. If your agents need to make complex decisions about who talks next, LangGraph’s explicit graph approach wins.
AutoGen: Agents Having a Conversation
AutoGen (Microsoft) flips the script: instead of you orchestrating the agents, the agents talk to each other. It’s agent-to-agent communication with an optional human in the loop to referee.
Philosophy: Conversation-based multi-agent. Who gets to speak is emergent.
from autogen import AssistantAgent, UserProxyAgent
researcher = AssistantAgent( name="Researcher", system_prompt="You are a researcher. Use your tools to find information.")
analyst = AssistantAgent( name="Analyst", system_prompt="You analyze research findings and draw conclusions.")
human = UserProxyAgent( name="Human", human_input_mode="SOMETIMES", # Jump in if needed)
# Agents discuss until someone says "TERMINATE"human.initiate_chat( researcher, message="Research LangGraph vs CrewAI, then analyze the tradeoffs.")Agents negotiate with each other through natural language. The human can jump in. This is really powerful for scenarios where you want agents to debate, refine ideas, or discover solutions through conversation rather than following a predetermined task list.
Real talk: This is awesome for interactive systems and for scenarios where you don’t know the exact conversation path ahead of time. It’s terrible if you need deterministic behavior or hard guarantees about execution order.
All Three Work with Local LLMs
Here’s the honest part: you don’t need OpenAI for any of these.
All three integrate with Ollama. Pick your favorite model (Mistral, Llama 2, neural-chat) and point the framework at it:
# LangGraph with Ollamafrom langchain_community.llms import Ollamallm = Ollama(model="mistral")
# CrewAI with Ollamaos.environ["OPENAI_API_BASE"] = "http://localhost:11434/v1"os.environ["OPENAI_MODEL_NAME"] = "mistral"
# AutoGen with Ollamaconfig_list = [{"model": "mistral", "base_url": "http://localhost:11434/v1"}]Yes, there’s friction. Yes, local inference is slower. But all three frameworks treat the LLM as pluggable, so you’re never locked into the cloud.
Which One Wins?
LangGraph: Use it when you need a complex state machine, conditional branching, or explicit control over agent behavior. Build a research agent that branches into multiple parallel analyses, then synthesizes results. You’ll love the explicitness.
CrewAI: Use it when you have 2–5 agents with clear roles and sequential or semi-sequential tasks. It’s the highest signal-to-noise ratio. Spinning up a “research + write + review” crew takes 30 minutes, not a day.
AutoGen: Use it when you want agents to negotiate with each other, or when you need human-in-the-loop oversight. It’s the most flexible for emergent behavior, which is sometimes what you want and sometimes what sinks you.
The Honest Take
Most “AI agent” use cases don’t need any of these frameworks. A single LLM call with tool use (tools=true in Claude or function calling in GPT) solves 80% of problems. I’ve seen people build elaborate multi-agent orchestrations when a simple chain would’ve worked fine.
Use these frameworks when:
- You have multiple LLMs that need to coordinate
- Your task requires persistent state across multiple steps
- You want agents to make decisions about what to do next based on intermediate results
Otherwise, keep it simple. Your 2 AM self will appreciate not debugging agent communication loops at scale.
