vs. CrewAI / LangChain / LangGraph

If you’ve already built an agent with CrewAI, LangChain, or LangGraph and you’re trying to work out where Flux fits, the short version is: those three optimize for fast iteration on agent logic; Flux optimizes for durability and operability. That sentence is a tradeoff, not a verdict. This page is the honest version — what each of the three does well, where Flux makes different bets, and when each is the right pick.

What CrewAI does well

CrewAI is the framework people reach for when they want a multi-agent workflow up and running in an afternoon. The mental model is small and memorable: you have agents (each with a role, a goal, and a backstory), you give them tasks, and you assemble them into a crew that runs sequentially or hierarchically. The abstractions map cleanly onto patterns teams actually want — research crew, content team, support triage — and the framework ships sensible defaults so the first prototype doesn’t need much tuning.

The crewai package is mature for its age, the community is active, and there is a healthy stock of templates and recipes. Role-based prompting is baked into the agent definition, so you don’t have to assemble a system prompt by hand to get a serviceable persona. Tool integrations are first-class, and CrewAI Flows give you a lightweight way to express branching logic between crew steps.

For prototyping multi-agent patterns, especially ones that fit the role-and-task model, CrewAI is genuinely good. The framework chose simplicity over generality and that choice pays off.

What LangChain does well

LangChain is the broadest ecosystem in the space. Whatever LLM provider, vector store, document loader, output parser, or retriever you need, there is almost certainly a LangChain integration for it, and usually one or two third-party alternatives on top. If your bottleneck is “I need to talk to this specific embedding model and this specific vector DB and this specific PDF source,” LangChain shortens that work to imports.

The primitives are solid: chains compose well, retrievers have a clean interface, output parsers handle the boring shape-checking work, and the LCEL (LangChain Expression Language) gives you a reasonably typed way to wire components together. LangSmith — paid, but useful — gives you tracing, evals, and prompt management; LangServe wraps a chain as an HTTP service.

The community is enormous. There are more tutorials, blog posts, and Stack Overflow answers for LangChain than for any of its competitors, which matters when you’re stuck at 2am. The API has gone through several major iterations, and parts of the surface still show the seams of that history, but the depth and breadth of integrations is unmatched.

What LangGraph does well

LangGraph is the LangChain team’s answer to the “agents are graphs, not chains” realization. You define a StateGraph, declare nodes (functions that read and update typed state) and edges (transitions, conditional or unconditional), and run the graph. That model handles cycles, branches, and explicit control flow cleanly — things that became awkward to express as chains.

What makes LangGraph the closest peer to Flux in this group is its checkpointer. Each step of the graph is persisted, so you can pause execution, resume across a process restart, time-travel back to a previous state, and run human-in-the-loop interrupts naturally. The Postgres and SQLite checkpoint backends are stable, streaming is first-class, and LangGraph Platform (formerly LangGraph Cloud) provides a managed runtime with deployment, persistence, and observability bundled.

If you want explicit state machines for your agents and you want pause/resume without writing it yourself, LangGraph is the strongest of the three on the durability axis.

Where Flux differs

The four systems all run agent-shaped workloads. The differences are mostly about what happens between LLM calls — and what happens when the process dies.

Durability and replay. CrewAI has minimal built-in persistence; if the process dies mid-crew, you generally start over. LangChain caches LLM responses but doesn’t replay execution; a crashed chain is gone. LangGraph checkpoints state at each node and can resume from the last checkpoint, which is close to what Flux does. Flux’s model is event-sourced: every task invocation — every LLM call, every tool call, every memory write — is appended to a per-execution event log, and on resume the workflow re-runs deterministically against that log, skipping the work that already completed. LangGraph’s checkpoints are step-level snapshots; Flux’s log is the full sequence of decisions. Both can survive a crash; the Flux log additionally gives you a full audit trail of what happened, not just the final state of each step.

Operational story. CrewAI and LangChain are libraries — you import them, you run them in whatever runtime you’ve already got (a script, a FastAPI service, a notebook). LangGraph adds an optional runtime via LangGraph Platform. Flux is a server, a worker pool, a relational store, and a CLI, designed from the start to be operated as a service. That’s heavier upfront and lighter once you have more than one agent in production: shared scheduling, shared catalog, shared event log, one place to look when something breaks.

Worker model. Flux workers register with the server and hold open an SSE connection (flux/worker.py, /connect); the server pushes scheduled executions down it. The worker dials out — no inbound ports, no NAT traversal, no long-poll loops to tune. The other three run in whatever process you started them in; scaling out is your problem.

Agent model. CrewAI: roles, tasks, crew. LangChain: agent executors with tool-calling loops. LangGraph: state graph with typed nodes. Flux: a workflow with an agent() task as the LLM orchestrator and other @tasks as tools (flux/tasks/ai/agent.py, providers in the same directory for Anthropic, OpenAI, Gemini, Ollama). The agent loop is a workflow; the tool calls are tasks; both are durable. There’s no separate “agent runtime” layered onto a chain runtime — it’s all one execution model.

Memory. All four have memory. CrewAI has short-term, long-term, and entity memory backed by ChromaDB and SQLite. LangChain has a long catalogue of memory classes. LangGraph has thread-scoped and cross-thread memory via its store interface. Flux ships WorkingMemory and LongTermMemory (flux/tasks/ai/memory/). Working-memory writes go through the workflow’s event log (each wm.memorize() is a wm_memorize_N task). Long-term memory writes hit a configured provider directly; they’re recorded as task events only when the LLM calls them through the tool surface (store_memory, recall_memory).

MCP. Flux ships an MCP server (flux start mcp, flux/mcp_server.py) that exposes registered workflows as MCP tools — an external agent (Claude Desktop, your own client) can call your Flux workflows as named tools without bespoke glue. CrewAI, LangChain, and LangGraph have community MCP adapters at varying maturity levels, but it’s not part of the core deployment story.

Maturity. LangChain has the largest community and the most existing code in the wild. CrewAI is broadly adopted for the multi-agent pattern. LangGraph is newer than either but well-funded and well-supported. Flux is 0.56.0 in July 2026 — much younger, with a smaller production footprint than any of the three.

When to use which

Use CrewAI when you’re prototyping multi-agent workflows that fit the role-and-task pattern, you want the smallest possible API surface to learn, and crash recovery is not a hard requirement. Research crews, content teams, summarization pipelines — CrewAI gets you there fast.

Use LangChain when ecosystem breadth is the bottleneck: many LLM providers, many retrievers, exotic output parsers, niche document loaders. You want LangSmith for tracing and evals. You want the largest available stack of tutorials and answered questions.

Use LangGraph when you need explicit state machines for your agents, you want pause-and-resume and human-in-the-loop without writing the persistence layer yourself, and you’re comfortable on the LangChain side of the ecosystem. If you’d also like a managed runtime, LangGraph Platform exists.

Use Flux when durability is a hard requirement and you want it for the whole workflow, not just the agent step. When you need one platform for AI agents and regular workflows on the same engine. When you want first-class MCP exposure of your workflows. When you’d rather operate one server-plus-workers deployment than glue agent code into your own service runtime.

Decision dimensions

Where to read more

• Agents as durable workflows — how Flux models the agent loop on top of its workflow engine.
• Why durable execution — the pattern Flux is built around.

Compared against CrewAI 0.x, LangChain 0.3+, and LangGraph 0.2+, as of July 2026. Flux 0.56.0.