When I was picking a framework for Scentry, I did what I think most people do: I opened multiple tabs, read a bunch of different “LangChain vs LangGraph vs CrewAI” blog posts, and came out the other side more confused than when I started. Everyone had an opinion. Nobody seemed to agree. The examples all used different use cases. Some of the posts were clearly written six months ago and already felt stale.
Naturally, when something refuses to make sense, you end up building your own version of it anyway. So here’s the version I wish I had found. Not a benchmark or a feature matrix, just a slightly unconventional way to make sense of how these frameworks differ and when you’d use them.
Let’s go outside.
LangChain: The Ant Trail
Ants build cities, farm fungus, wage wars, and solve complex logistics problems with a brain the size of a grain of sand. But there’s one thing they’re really, really good at: a trail. One ant finds food. It leaves a pheromone trail. The next ant follows it, reinforces it, and passes the food along. The ant after that does the same. Segment by segment, the chain gets the job done.
LangChain is the ant trail of the AI framework ecosystem.
It has an abstraction for nearly everything: LLM providers, vector stores, retrievers, document loaders, output parsers, memory modules. It became the default starting point for LLM applications because it made formerly hard things easy and had a pre-built component for almost anything you wanted to build. You can get something working fast. Probably faster than with anything else on this list.
The trail metaphor holds up in the limitations too. A trail goes from A to B. If B moves, or if you need the trail to double back, or if partway through you discover you need to split into two trails based on what you found, things get awkward. You’re fighting the framework a little. LangChain has added more and more mechanisms for this over time (agents, routing, conditional logic), but it grew those features onto an architecture that was originally linear. You can feel that sometimes.
Use LangChain when your workflow is linear, composable, and predictable. RAG pipelines, document summarizers, chatbots with tool calling. The trail gets you there efficiently.
CrewAI: The Wolf Pack
A wolf pack doesn’t work because any individual wolf is exceptional. It works because each wolf has a role, every wolf knows their role, and the pack’s intelligence is the product of how those roles interact. The alpha doesn’t hunt and scout and flank simultaneously. It coordinates. The scouts range ahead. The flankers cut off exits. Specialized, collaborative, mission-oriented.
CrewAI is designed around exactly this instinct.
You build agents with defined roles, goals, and tools. You define tasks. Then you let the crew figure out how to complete them. The framework handles a lot of the coordination logic: who does what, in what order, how results pass between agents. You’ll know it fits when you describe the problem like this: “I need a researcher, a writer, and an editor.” If you’re already thinking in roles, you’re already thinking in CrewAI.
It clicks fast because of this. You’re essentially assembling a small team, and you already know how to think about that. Less graph theory, less state management, less architecture to figure out before you can write your first agent.
I actually built the first version of Scentry on CrewAI for exactly this reason. The problem mapped so cleanly onto roles: something to classify the error, something to gather context, something to search runbooks. A crew. It made sense. And getting to a working prototype was fast.
Where I started hitting friction was when the workflow needed to get more dynamic. Agents running concurrently within a phase, state accumulating across phases, Phase 3 triggering on-demand from a Slack button. The role abstraction started to feel like it was describing the team rather than the actual flow of information. That’s when I made the call to move to LangGraph for V2.
That’s not a knock on CrewAI. I outgrew the use case it’s optimized for. If your problem maps cleanly onto distinct roles working toward a shared goal and the flow is reasonably sequential, CrewAI is genuinely fun to build with. I mean that. It has good energy.
LangGraph: The Spider’s Web
This one’s a little less obvious at first.
A spider’s web isn’t a trail. It’s a structure. Every thread connects to other threads. Every node is reachable from every other node. When something lands anywhere on the web, the vibration travels the whole thing, and every part of the structure has access to what just happened. The spider doesn’t have to start from one end and work to the other. It can move in any direction based on where the signal comes from.
This is LangGraph. And it’s built by the same team as LangChain, which is the first thing that trips people up. It’s not a replacement. It’s a different model for thinking about the same problem.
In LangGraph, you define nodes (agents or functions) and edges (conditions for moving between them). State flows through the whole graph and every node can read from it and write to it. The big thing that changes is that you can loop. An agent can run, inspect what it found, and decide to go back and try something differently rather than just passing results forward and hoping for the best.
This is where Scentry landed. I needed agents to run concurrently within a phase, state to accumulate across phases, and Phase 3 to be triggerable from anywhere after Phase 2 completed. A linear chain would have made that genuinely messy. A graph made it natural.
The tradeoff is real: graphs are harder to reason about when something goes wrong. Debugging a chain is following a trail. Debugging a graph is something more like wandering the web looking for the thread that went sideways. If your problem is actually linear, LangGraph is overkill and its flexibility will just introduce complexity you didn’t need.
So which one?
Here’s the short version: the shape of your problem tells you which one to reach for.
Linear workflow, predictable steps, just want to ship something? LangChain. It has the biggest library of pre-built components and the most real-world examples to learn from.
Problem naturally breaks into roles? CrewAI. You’ll have a working prototype faster than with anything else on this list.
Workflow needs to loop, branch, run things in parallel, or share state across agents? LangGraph. More to set up upfront, but it handles the complexity the other two start to buckle under.
The tools will keep changing. That underlying shape — chain, crew, or graph — tends not to. Start there.
For Scentry I went through two of them. CrewAI got me to a working V1 fast. LangGraph gave me the architecture V2 needed. Both were the right call at the time.