LangChain & LangGraph Development
Multi-step LLM workflows built on LangGraph, with durable state, checkpointing and human-in-the-loop interrupts that survive a restart.
When a chain is not enough and you need a graph
LangChain made it easy to compose a call to a model with a retrieval step and a parser. That is genuinely useful, and it is also where most teams stop, right up until the workflow needs to loop, branch on a result, pause for approval or resume after a crash. A linear chain cannot do those things.
LangGraph exists for exactly that. State is explicit, transitions are declared, and execution is checkpointed, so a graph can be interrupted for a human decision on Tuesday and resumed on Wednesday without losing context. That is the difference between a script and a system.
We build these as ordinary production software: typed state, tested transitions, tracing on every node. The same discipline covered in our guide to production agents.
Teams that start here often pair it with AI agent development, AI automation and ML model deployment.
The moment your workflow needs to ask a human and carry on afterwards, you have left the world of chains and entered the world of state machines.
Where prototype graphs break
Four things that are fine in a notebook and fatal in production.
State lives in the process, so a deploy or a crash loses every in-flight run and there is no way to resume.
A cyclic graph with no step scope spins on an ambiguous input until someone notices the bill.
Approval is bolted on as a blocking sleep rather than a checkpointed interrupt, so the workflow cannot survive a restart.
No per-node tracing, so a bad final answer means re-running by hand and guessing which step went wrong.
What a LangGraph engagement covers
The graph, the durability layer around it, and the tooling to debug it at 2am.
An explicit, typed state schema, versioned like a database migration, so graph changes do not corrupt runs already in flight.
Every transition persisted to Postgres, so a run survives deploys, crashes and week-long waits for a human.
First-class interrupt nodes that pause the graph, notify the right person in Slack or email, and resume cleanly on their decision.
Step limits, token scopes and timeouts per node, so a pathological input degrades instead of running forever.
Every node execution, prompt version and tool call recorded, so any run can be replayed and inspected after the fact.
Deterministic fixtures for graph transitions plus adversarial inputs in CI, so refactors do not silently change behaviour.
From workflow review to a checkpointed graph through controlled rollout
State and transitions designed before any prompt is written.
We draw the real process as a state machine, including every branch and every point a human must decide.
The typed state, its versioning strategy and the persistence layer are agreed before feature work begins.
Nodes implemented and tested individually, then wired, with tracing on from the first run.
We deliberately kill the process mid-run to prove checkpointing and resumption work under real failure.
Live on a slice of volume with interrupts set wide, tightened as the traces show the graph behaving.
The stack behind our graphs
LangGraph for orchestration, ordinary infrastructure for everything else.
Explicit state machines with cycles, conditional edges and interrupts as first-class concepts.
Checkpointing to a real database so runs outlive the process that started them.
Provider-agnostic nodes so a model swap is configuration rather than a rewrite.
Per-node traces with inputs, outputs and scope, so debugging is reading rather than guessing.
What this looks like in production
A workflow that waits four days for a human and resumes cleanly
A financial services client had a client-onboarding workflow that collected documents, ran checks, and needed a compliance officer to approve before proceeding. Their first implementation held state in memory, so every deploy killed in-flight onboardings and the team had restarted dozens by hand.
We rebuilt it as a LangGraph with Postgres checkpointing and an explicit interrupt node at the approval step. The graph now pauses, posts to the compliance channel with the gathered evidence, and resumes on the decision, whether that comes in ten minutes or four days.
Deploys stopped being an event. Runs in flight simply continue on the new version, because state is data rather than a process.
LangChain vs LangGraph: choosing the right one
Anything that pauses for a human and resumes days later is a distributed system. We build it that way from the first commit.
State schema and checkpointing are designed before the first node, because retrofitting durability into a running graph is genuinely painful.
A working demo and a written note every Friday covering what shipped, what slipped and what it means for the date. No status theatre.
Nothing goes live in one jump. We run in parallel or behind a flag until the numbers say it is safe to switch over.
