LangGraph vs CrewAI vs a Custom Loop: Choose Control, Not Fashion

LangGraph vs CrewAI vs writing the agent loop yourself is not a beauty contest. For production, pick the abstraction that matches how much control, durability, and auditability you need — then prove the choice on the same golden set and cost band.

This spoke belongs to the Agentic Systems Operating Manual. It assumes you already know when an agent is the wrong tool (when not to build one) and that evaluators exist before you crown a framework.

The short answer

• LangGraph wins when control flow must be explicit: branches, cycles, checkpoints, and human interrupts you can evidence.
• CrewAI wins when the work maps cleanly to roles/tasks and you need a working multi-agent shape fast — including production crews when the metaphor fits.
• Custom loop wins when the job is a thin tool loop with your own policy, eval, and persistence — and you refuse framework tax you will not use.
• Never rank by GitHub vibes. Rank by pass rate, cost per pass, escalate rate, and time-to-debug on your golden set.
• MCP does not replace any of these. MCP is a tool protocol; these options are orchestration choices.

What problem each abstraction solves

Option	Core metaphor	You get	You pay
LangGraph	Explicit state graph	Nodes, edges, typed state, checkpointers, interrupt() HITL	Steeper learning curve; you design the graph
CrewAI	Roles, tasks, crews (+ Flows)	Fast multi-agent collaboration shape; optional deterministic Flows	Higher-level magic; harder mid-run introspection unless you add it
Custom loop	Your code owns the loop	Minimal deps; exact policy/eval/budget wiring	You build persistence, HITL, and resume yourself

As of mid-2026, neither LangGraph nor CrewAI is “dead” or demo-only. Both ship MIT-licensed OSS and are actively used in production. The failure mode is picking the wrong posture, not picking a corpse.

Control spectrum: how much do you need?

Ask four questions before you open a tutorial:

1. Must a regulator, auditor, or ops lead see the exact branch taken?
2. Must a run pause for a human and resume hours later without losing state?
3. Are there cycles (revise → evaluate → act) that are part of the product, not a hack?
4. Will you outgrow a role/task metaphor within one quarter?

Need	Lean toward
Yes to 1–3	LangGraph (or custom with equivalent checkpoint/HITL)
Mostly collaboration, deadline pressure, role mapping is natural	CrewAI (Crews for open work; Flows when order must be fixed)
No to all four; one agent, few tools, short runs	Custom loop

Bravery is not a framework. Control is a product requirement.

When framework tax exceeds benefit

Framework tax shows up as:

• Extra LLM calls for “manager” or delegation decisions you did not budget
• Opaque mid-run state when a CRM write went wrong
• Upgrade churn when the framework’s defaults change under you
• Engineers debugging the framework instead of the job

Use this checklist before adopting anything heavier than a thin harness:

• You can name the durability or HITL feature you need this month
• You can stub tools and run offline evals without the framework’s cloud
• You can emit run/tool/eval spans your ops screen understands
• You can pin versions and re-run a golden set after upgrades

If every box stays unchecked, write the loop. Framework fashion is expensive.

LangGraph in production terms

LangGraph (LangChain’s graph runtime) models the agent as a state machine you can draw. Production teams care about three primitives that are first-class as of current docs:

1. Checkpointers — snapshot state after steps; threads keyed by thread_id
2. interrupt() — pause inside a node, surface a payload, resume with Command(resume=…)
3. Conditional edges / cycles — revise loops and approval branches as code, not prompt hope

That combination is why LangGraph shows up when runs must survive crashes, human waits, or audit questions. It is also why a plain request/response agent often should not use LangGraph: you bought a graph runtime for a one-shot function.

Think in named states even if you stay custom: intake, act, evaluate, revise, terminal. The graph library is optional; the state names are not.

CrewAI in production terms

CrewAI’s posture is role-based collaboration: agents with roles/goals, tasks with expected outputs, crews that run sequentially or hierarchically. Independent of LangChain. For research → analyze → write → review shapes, the metaphor is productive and you get a working system quickly.

Mature CrewAI usage (as described across 2026 practitioner writeups) adds Flows when you need deterministic outer orchestration and keep Crews where open collaboration actually helps. Teams that “hate CrewAI in production” often stayed in pure Crews when regulation required a fixed order — then blamed the library for a metaphor mismatch.

CrewAI is not “only for demos.” Treat it as a velocity-first abstraction with a control ceiling. Hit the ceiling → migrate the control plane, not your entire company identity.

Custom loop: when direct API + thin harness wins

A custom loop is usually:

intake → plan (optional) → tool calls → evaluate → revise or terminal

plus your policy gate, budgets, and traces. Direct provider tool use (OpenAI tools / Anthropic tool use / Gemini function calling — whatever your pinned model exposes) lives here.

Choose custom when:

Signal	Meaning
One agent, ≤8 tools	Framework graph is optional
Runs finish in one request window	Checkpoint tax may not pay
You already own durable jobs (queues, Durable Objects, Temporal)	Don’t buy a second runtime
Policy and eval are non-negotiable	Keep them in your code, not buried

Custom does not mean careless. It means you own the boring parts on purpose.

Compare them on the same golden set and cost band

Fashion rankings invent benchmarks. You should not. Run this bake-off:

Step	What you lock
1	Same job types and golden cases (pass/fail criteria frozen)
2	Same tool stubs or sandboxed tools
3	Same model pin and temperature policy
4	Same max turns / budget / kill switch
5	Report pass rate, cost per pass, escalate rate, p95 latency, debug minutes per failure

Decision rule we use on pilots:

1. If custom clears the bar, ship custom.
2. If LangGraph clears the bar and you need HITL/checkpointing you do not want to rebuild, ship LangGraph.
3. If CrewAI clears the bar faster and the job is collaboration-shaped, ship CrewAI — with Flows where order must be proven.
4. If two options tie on quality, pick the one with lower cost per pass and faster incident debug.

Intuition-only framework merges are how regressions ship.

Migration path: prototype crew → explicit graph

A common, honest path in 2026:

1. Week 0–1: Prove the job with CrewAI or a notebook custom loop — tools stubbed, evaluator on.
2. Week 2: Freeze golden cases from real failures; stop adding agents for sport.
3. Week 3: If control/HITL/durability requirements appear, re-express the same states as a LangGraph (or keep custom and add your checkpointer).
4. Week 4: Cut over behind the same eval gate. Do not “rewrite and hope.”

Migration checklist:

• Map each Crew task to a named state or node
• Move side-effect tools behind the same sandbox and idempotency keys
• Keep prompts versioned; do not rewrite copy and topology in one PR
• Re-run the golden set before enabling writes

Failure mode: framework-shaped wrongness

What breaks: A hierarchical Crew burns three manager LLM calls, then a worker writes a CRM note that fails a soft criterion nobody scores online. The demo looked great because a human watched the happy path.

What it costs: Token spend without a pass; a sales lead that trusts the agent less; a week of “is it the model?” debugging when the real bug is missing evaluate/revise states.

What you do instead: Put the evaluator in the loop before you add agents. Trace tool calls. Prefer one agent with a hard gate over a crew that improvises order.

Does MCP replace LangGraph?

No. MCP (Model Context Protocol) standardizes how hosts discover and call tools/resources across clients. LangGraph/CrewAI/custom decide when to call tools, how to branch, and how to stop. You can put MCP tools behind any of the three. Choosing MCP does not choose your orchestration layer.

Human-in-the-loop and checkpointing across options

Concern	LangGraph	CrewAI	Custom
Pause for approval	First-class interrupt() + checkpointer	Supported patterns; confirm your version’s HITL/Flow pause story	You implement queue + resume
Survive process death	Persistent checkpointer (SQLite/Postgres/etc.)	Depends on how you deploy and persist crew/flow state	Your job system owns it
Replay / time-travel	Checkpoint history is a design goal	Usually rebuild from logs	You build it or don’t
Evidence for auditors	Graph + state snapshots	Task outputs + your logs	Whatever you logged

If HITL is a compliance requirement, treat checkpoint + resume as a day-one acceptance test — not a slide.

A sane SMB default in 2026

For most Spurlock Studios SMB pilots:

Starting point	When
Custom loop + pinned model + evaluator	Single job, few tools, writes gated
LangGraph	Long waits, multi-step approvals, must resume cleanly
CrewAI	Role collaboration is the product and you accept the metaphor

Default bias: smallest control surface that clears the golden set. Multi-agent fashion is a separate decision — split only when trust, audience, or timing conflicts force it.

How Spurlock chooses on a pilot

On a $1,500 · 5-day agentic pilot we do not start with a framework bake-off for sport. We:

1. Lock the job, tools, and evaluator criteria
2. Ship the thinnest loop that can fail safely
3. Introduce LangGraph only when durability/HITL shows up in the real job
4. Use CrewAI when the customer’s process is already a crew of humans and the mapping is honest
5. Keep the golden set and cost band as the referee

Framework choice is a control decision, not a brand affiliation. Continue with the operating manual and evaluators before agents.

Decision table you can paste into a design doc

If you need…	Prefer…	Reject…
Explicit revise/eval cycles you can test	LangGraph or custom state machine	Prompt-only “try again”
Fast role-based prototype with real tools	CrewAI	Premature microservices of agents
One write path, one policy gate	Custom	Three frameworks “just in case”
Multi-client shared tools	MCP servers + any orchestrator	Rewriting tools per host
Fashion ranking from a blog table	Nothing	Shipping on vibes

Worked example: lead enrichment agent

Job: Enrich a CRM lead, draft a note, stop for human if confidence is low.

Approach	Shape	Likely outcome
Custom	States: fetch → enrich → draft → evaluate → write or escalate	Fastest path for most SMBs
LangGraph	Same states as nodes; interrupt before write; Postgres checkpointer	Right when humans approve asynchronously
CrewAI	Researcher + Writer + Reviewer crew	Attractive demo; watch manager-token overhead and write authority

Failure we have seen in spirit across builds: three roles argue in prompts while none owns the write sandbox. Fix the authority boundary first.

Anti-patterns

Framework tourism. Rebuilding the same agent in three stacks without a frozen golden set.

Crew for a single tool call. Role theater around crm.update.

LangGraph without a checkpointer when you claim HITL — interrupts need persistence.

“We’ll add evals after the graph looks cool.” The graph is not the product; the pass criteria are.

FAQ

Is CrewAI only for demos?

No. CrewAI ships real production systems when the role/task metaphor matches the work and you use Flows (or equivalent rails) where order must be proven. It becomes “demo-shaped” when teams skip evaluators, budgets, and write sandboxes — that failure is available in every framework.

When is direct API + thin harness best?

When you have one agent, a small tool set, short-lived runs, and you already own policy, eval, and durability elsewhere. If you are not using graph interrupts or role collaboration, a custom loop is often clearer and cheaper to operate.

Does MCP replace LangGraph?

No. MCP is a protocol for exposing tools, resources, and prompts to AI hosts. LangGraph is an orchestration runtime for stateful agent graphs. Use MCP for portable tool boundaries; use LangGraph (or CrewAI/custom) for control flow.

How do human-in-the-loop and checkpointing differ across options?

LangGraph treats checkpointers and interrupt() as first-class. CrewAI supports human review patterns and Flows, but you must verify pause/resume durability for your deploy model. Custom means you implement the queue, snapshot, and resume contract yourself — which is fine if you already have a job system.

What’s a sane SMB default in 2026?

Start with a custom loop or a single LangGraph only if you need resumable HITL. Reach for CrewAI when collaboration-shaped work is real. Prove any choice on one golden set and a cost band before scaling writes.

How does Spurlock choose on a pilot?

We lock the job and evaluator first, ship the thinnest safe loop, and only adopt LangGraph or CrewAI when a concrete control or collaboration requirement appears. The $1,500 pilot on /agentic is built to make that call with evidence, not fashion.

CTA

Pick the control surface that clears your golden set — then harden it.

/agentic · /contact?intent=agentic-pilot