LangGraph and FlowRunner

TL;DR

• LangGraph is how you build an agent that survives: a graph with persisted state, durable execution, and interrupt() to pause for a human and resume later. FlowRunner is what you put around that pause: it reaches the person in Slack, email, WhatsApp, phone, or a Form, waits days if it has to, reminds and escalates, and keeps a record of the decision.
• LangGraph holds the state and waits as long as you need. It doesn’t tell anyone a decision is waiting. That part, plus starting runs from business apps and turning a finished run into business steps, is where FlowRunner fits.
• Your graph stays in your code, in your process or on LangSmith Deployment. FlowRunner doesn’t run Python.
• If the person resuming the graph is the user already in your app, LangGraph on its own is enough.

What LangGraph is for

LangGraph is an open source framework and runtime, under the MIT license, for agents that have to be reliable over time. You model the agent as a graph of nodes, mix deterministic steps with model calls, and LangGraph persists the state as it goes. The docs put it as agents that “survive failures and resume long-running work.”

The pieces that matter here:

• Persistence and durable execution. A checkpointer saves thread state, which is what makes human-in-the-loop, time travel, and recovery work. You choose a durability mode per run: exit (save when the run ends or interrupts), async (save in the background), or sync (save before each next step).
• interrupt(). Called inside a node, it pauses the graph and returns a payload to the caller. With a checkpointer and a thread_id, the graph “waits indefinitely until you resume execution” with Command(resume=...), and the resume value becomes interrupt()’s return value. One detail to design for: on resume, the node runs again from its start, so code before interrupt() runs twice.
• Retries. A RetryPolicy per node, such as RetryPolicy(max_attempts=3).
• LangSmith Deployment. LangGraph Platform is now called LangSmith Deployment (and LangGraph Studio is LangSmith Studio). It runs graphs as Cloud, Hybrid, Self-hosted, or a Standalone Agent Server, with durable execution, streaming, cron jobs interpreted in UTC, and a webhook that fires when a run completes. Agent Server also exposes deployed agents as MCP tools at /mcp.
• Pricing. The framework is free. LangSmith’s Plus plan is $39 per seat per month and includes one free small serverless deployment. Usage is metered in LSUs, where one LSU is $1, and a deployment is charged on what it consumes, for example 0.0675 LSU per vCPU-hour of runtime compute.

If your agent needs to pause, hold state, and pick up exactly where it stopped, LangGraph is built for that. What it hands back to you is everything that happens while it’s paused.

What FlowRunner adds around it

An interrupt() is a pause with a payload. Someone has to see that payload, decide, and send the answer back, and LangGraph leaves all of that to you. Studio is a developer tool, not an inbox for the finance lead. So teams end up writing a notifier, a review page, reviewer sign-in, reminder jobs, and a table of who decided what.

FlowRunner is that layer:

• Reaching the person. A flow sends the interrupt’s payload to the reviewer on email, Slack, WhatsApp, phone, or a Form with a public link. The reviewer needs no account and never sees your graph.
• Waiting, with reminders. The flow waits for the answer: up to 30 days on Free, Starter, and Growth, and up to a year on Professional and above. While it waits, it can send a reminder after a few hours or move the request to a backup approver after a day. The waiting run is one execution.
• Bringing the answer back. When the person answers, the flow POSTs the decision to your resume endpoint with the thread_id, and your code calls Command(resume=...). The flow’s HTTP Request block retries on 5XX and network errors if your endpoint is briefly down.
• A record of the decision. Each run keeps every block’s input and output: what was asked, whom, when, and what came back. Log history runs from 24 hours on Free to unlimited on Enterprise, and from Professional the audit log records who changed the flow.
• Triggers into the graph. LangSmith Deployment’s webhook goes out when a run completes. Starting a run when an email lands, a Shopify order is updated, or a DocuSign envelope comes back is a FlowRunner trigger across 2,100+ integrations, with the account connected once.
• What happens after the run. A finished run usually means business steps: update the record, email the customer, tell the account owner. A flow can take those over from your graph’s output.

How they work together

The graph stays where it runs. FlowRunner handles the parts around it. The LangGraph guide has the code.

The interrupt goes to a person, the answer comes back. A node calls interrupt() with the refund details. Your app sees the interrupt in the result and posts the payload and the thread_id to a FlowRunner approval flow through the non-blocking Call Flow API. Sending the request from the app, after invoke returns, keeps it out of the node, so the node’s re-run on resume doesn’t message the reviewer twice. The flow asks on Slack, reminds, escalates, and POSTs the decision to your resume endpoint. Use a durable checkpointer: the answer might come Thursday, after two deploys.

A finished run continues as business steps. On LangSmith Deployment, pass a webhook URL when you create a run, pointed at a flow whose first block is an External Callback. Each completed run then starts a flow with the run’s status, thread_id, and values. The flow writes the result to the CRM, emails the customer, and posts a summary. Your deployment’s webhook settings can add a static header from an environment variable, so FlowRunner’s key travels in the FR-Access-Key header instead of the URL. A run paused at an interrupt is reported as success, so have the flow check the values before it acts.

A business event starts a graph run. A flow catches the event with that app’s trigger, keeps only the fields the graph needs, and calls your app’s endpoint or your deployment over HTTP. The integration’s auth lives in FlowRunner, and the run record shows what came in and what the graph sent back.

A FlowRunner agent calls your graph. A FlowRunner AI Agent block can use tools from any MCP server you register with a publicly reachable URL and a token or OAuth 2.0. If your deployment’s /mcp endpoint, or an MCP server you write around the graph, meets that, a FlowRunner agent can call your graph as one of its tools, alongside human-review flows it calls the same way.

When you don’t need FlowRunner

Some LangGraph projects have everything they need already:

• The user in your app is the reviewer. A chat app where the person who approves is the person typing can show the interrupt in your own UI and resume from there.
• Developers resolve the interrupts. If the only people answering are on the team that built the graph, Studio and a small script may be all it takes.
• Nothing outside the graph cares. A research agent or an internal prototype with no business apps on either side and nothing to approve doesn’t need a layer around it.
• You’ve built the review loop already. If your notifier, review page, and decision log work, keep them.

Add FlowRunner when the person who answers an interrupt isn’t a developer, when the answer can take days, or when business apps need to start runs and receive results.

Feature comparison

Dimension	LangGraph on its own	LangGraph with FlowRunner
Where the graph runs	Your process, or LangSmith Deployment	The same place, unchanged. FlowRunner doesn’t run Python
Pause for a human	interrupt() and Command(resume=...) with a checkpointer	The same, with a flow handling the reviewer’s side
Telling the reviewer	Yours to build	Email, Slack, WhatsApp, phone, or a Form with a public link
Decision screen	Yours to build; Studio is for developers	Slack buttons, an email reply, or a Form
Waiting for the answer	The thread waits indefinitely; reminders and escalation are yours	The flow waits up to 30 days (Free, Starter, Growth) or a year (Professional and above), with reminders and escalation as blocks
Record of the decision	Your own table, plus LangSmith traces	Each run’s inputs and outputs, readable by anyone on the team; audit log from Professional
Starting a run	Your code, or Deployment’s API and cron jobs	Also 2,100+ integration triggers and FlowRunner schedules
After a run completes	Deployment’s webhook to an endpoint you write	The webhook starts a flow at an External Callback
Retries	RetryPolicy per node	The same in the graph, plus Retry Policy on every HTTP call the flow makes
MCP	Client through LangChain’s adapter; Agent Server exposes /mcp	FlowRunner AI agents can use a registered MCP server’s tools
Cost	Framework free; LangSmith Plus $39 per seat plus LSU usage for Deployment	Plus FlowRunner: Free at 100 executions a month, Starter from $5; one flow run is one execution