I just wrote that most AI pipelines are map-reduce and don’t need an agent framework. That’s true. But some do.
LangGraph — the state machine library that now powers LangChain’s agents — is in production at BlackRock (inside Aladdin, managing $11 trillion), JPMorgan (the “Ask David” research system), and several hundred other companies. It’s not vapourware. But it’s also not the right tool for your cron job.
Here’s when it earns its keep.
The credit approval problem
A bank receives a credit application. Five assessors need to evaluate it:
- Credit scoring — pull bureau data, calculate risk
- Fraud detection — check transaction patterns, device fingerprints
- KYC/AML — verify identity, screen watchlists
- Collateral valuation — assess pledged assets
- Regulatory compliance — check concentration limits, sectoral caps
The naive approach: run them in parallel with asyncio.gather, collect the results, make a decision. That’s the map-reduce pattern. And it breaks immediately.
Because the agents need to see each other.
Fraud detection flags a suspicious pattern. Credit scoring needs to know — it should adjust its risk weighting mid-run, not wait for the final aggregation. KYC identifies the applicant as a politically exposed person. Compliance needs to know now, because it activates an entirely different workflow: enhanced due diligence, senior management approval, additional documentation requirements. The PEP finding doesn’t just add a data point — it changes the shape of the graph.
This is shared mutable state. Worker A’s output changes what Worker B should do next. asyncio.gather can’t do this — it launches independent tasks and waits for all to finish. It has no mechanism for one task to interrupt or redirect another.
The human in the loop
The credit officer reviews the combined assessment. She has three choices: approve, reject, or send back with questions. “Send back” is the hard one.
When she sends it back — “explain the collateral haircut on the industrial property” — the valuation agent needs to resume from where it stopped, with the new question as additional context. Not restart. Resume. The credit bureau data is still valid. The KYC screening doesn’t need to re-run. Only the valuation step re-executes, and then the synthesis re-runs with the updated input.
This requires checkpoint persistence — the ability to freeze the entire pipeline state, wait for human input (which might come in three hours or three days), and resume exactly where it paused. LangGraph’s checkpoint system (backed by SQLite, Postgres, or custom stores) does this out of the box. Building it yourself is a multi-week infrastructure project.
The audit trail
The regulator asks: what was the state of each assessor when the credit decision was made? What data did the fraud agent see? Did the compliance agent have the PEP flag before or after it issued its recommendation?
Every state transition in a LangGraph pipeline is checkpointed with the full state dict. You can replay the exact execution path — which node ran when, what it saw, what it produced. For model risk management and regulatory examination, this is not optional.
Building a comparable audit trail manually means instrumenting every function call, serialising state at every step, and managing a checkpoint store. LangGraph gives you this as a structural guarantee, not an afterthought.
The line
LangGraph earns its keep when your workflow has all three:
- Concurrent agents with shared mutable state — workers that need to see and react to each other’s intermediate output, not just aggregate final results
- Human-in-the-loop with resume — the pipeline pauses for human decisions and resumes from the checkpoint, not from scratch
- Auditability of state transitions — regulators or risk teams need to inspect the exact execution path
Missing any one of these? You probably don’t need it.
- Concurrent but no HITL or audit? →
asyncio.gatherwith a shared state object - HITL but no concurrency? → A simple approval queue
- Audit trail but linear? → Structured logging
It’s only when all three intersect that the framework tax — the learning curve, the langchain-core dependency, the graph mental model, the CVEs to track — pays for itself.
The consulting framing
LangGraph is the SAP of agent orchestration. Powerful, battle-proven at enterprise scale, worth the investment if you’re building a platform. Overkill if you’re building a workflow.
When a client asks “should we use LangGraph?”, the useful answer isn’t yes or no. It’s: “What does your workflow look like? Show me the state dependencies between your agents. Show me where humans intervene. Show me what the regulator needs to see.”
If the answers are “independent tasks,” “nowhere,” and “log files are fine” — you have a map-reduce. Build it in an afternoon. Move on to the problem that actually needs the framework.
If the answers are “agents react to each other,” “credit officers review mid-flight,” and “HKMA wants full state lineage” — now we’re talking. And LangGraph is genuinely the most production-tested option for that problem in 2026.
The skill isn’t knowing the framework. It’s knowing when the problem deserves it.