--- title: "LangChain and FlowRunner: use them together" description: "Build the agent in LangChain. FlowRunner gives it tools that run whole business processes, gets a person's approval in Slack or email, and can call your agent as a tool." url: https://flowrunner.ai/alternatives/langchain date_published: 2026-11-02 date_modified: 2026-11-03T09:28:56-08:00 --- [Alternatives](https://flowrunner.ai/alternatives) / LangChain ![LangChain logo](https://flowrunner.ai/assets/alternatives/langchain.svg) # LangChain and FlowRunner Build the agent in LangChain. FlowRunner gives it tools that run whole business processes, gets a person's approval in Slack or email, and can call your agent as a tool. 2026-11-02 Updated November 3, 2026 8 min ## Add FlowRunner when - Your agent's tools touch business apps, and you'd rather not hold a token and write retries for each one - A tool call needs sign-off from someone who isn't in your app, on Slack, email, WhatsApp, phone, or a Form - The agent should start when a ticket, a chat, or an email arrives in a business app - The ops team needs a record of what the agent changed in their systems ## LangChain on its own is enough when - You're prototyping, or the agent lives in a notebook - Every tool is a read, so nothing needs approval or an audit trail - The person who approves is the user already in your chat window - You've already built the integrations and the review screen you need **TL;DR** - LangChain is how you write the agent: `create_agent`, any model provider, a large library of integrations, and middleware, including human-in-the-loop. FlowRunner is what the agent calls on and what calls the agent: flows that run whole business processes as one tool, triggers from 2,100+ integrations, and FlowRunner AI agents that can use your LangChain agent as a tool. - `HumanInTheLoopMiddleware` pauses before a tool call and takes approve, edit, reject, or respond. FlowRunner adds the reviewer’s side: getting the request to a person on email, Slack, WhatsApp, phone, or a Form, waiting for them, and bringing the decision back to your code. - Your agent stays in your code and your runtime. FlowRunner doesn’t run Python. - For a prototype, or an agent whose tools only read, LangChain on its own is enough. ## What LangChain is for LangChain is an open source framework, in Python and JavaScript under the MIT license, for building agents and LLM apps on any model provider. Since version 1, the main entry point is `create_agent`, which the docs describe as “a minimal, highly configurable agent harness.” You give it a model, tools, and a system prompt, and you shape its behavior with middleware. A few things it brings that matter for the rest of this page: - **It’s built on LangGraph.** “LangChain’s agents are built on top of LangGraph,” so an agent gets LangGraph’s checkpointers and durability without you writing a graph. - **A large integration library.** Model providers, vector stores, document loaders, and tools, so swapping a model or a retriever is a line of code. - **Human-in-the-loop middleware.** `HumanInTheLoopMiddleware` pauses the agent before any tool call you list in `interrupt_on`. A reviewer can approve, edit the arguments, reject with feedback, or respond in place of the tool. You need a checkpointer and a `thread_id`, and you resume with `Command(resume=...)` on the same thread. - **MCP as a client.** `MCPAdapter` (beta, `langchain[mcp]>=1.4.0`) connects an agent to MCP servers over Streamable HTTP or stdio. - **LangSmith.** LangChain’s commercial platform for tracing, evaluation, and deployment, with a free Developer plan and a Plus plan at $39 per seat per month. If you’re writing an agent in code, LangChain is a natural place to write it. The question this page answers is what sits around that agent once it has to work inside a business. ## What FlowRunner adds around it An agent is only as useful as its tools, and in a business the tools are where the work piles up. Each one needs credentials for an app, retries for when that app is slow, a record of what it changed, and, for the ones that spend money or email a customer, someone’s sign-off. The middleware gives you the pause. The docs describe no channel for the reviewer, so how the request reaches a person, and how their answer gets back, is yours to build. FlowRunner covers that ground: - **Tools that are whole processes.** A flow becomes one tool for your agent. “Send this customer a quote” can mean: create the estimate in QuickBooks, send it, post the link to the account owner on Slack, and log it in a sheet. Your agent makes one call. The flow does every step, with retries, and the whole run counts as one execution. - **Auth that stays out of your agent.** The flow uses accounts connected once in the FlowRunner workspace, across 2,100+ integrations and 56,000+ callable actions (as of September 2026). Your agent’s process never holds a CRM or accounting token. - **The reviewer’s side of the pause.** When the middleware interrupts, a flow sends the request on email, Slack, WhatsApp, phone, or a [Form](https://docs.flowrunner.ai/platform/forms.html) anyone can open without an account. It can remind and escalate, and it waits up to 30 days on Free, Starter, and Growth, and up to a year on Professional and above. Then it sends the decision back to your code. - **Triggers from business apps.** A flow can start your agent when an Intercom conversation opens, a Zendesk ticket changes, or an email lands in Gmail, and pass it a clean payload. - **A run record for the people who own the systems.** LangSmith traces show you what the agent reasoned. A FlowRunner run shows each block’s input and output, so the ops lead can see what changed in their systems without reading a trace. Every plan has unlimited users. - **FlowRunner’s own agents.** If part of the job fits better on the canvas, a FlowRunner AI Agent block, on your own model keys, can call your LangChain agent as a tool, and call a [human-review flow](https://flowrunner.ai/concepts/human-in-the-loop) as a tool in the same run. ## How they work together Your LangChain code stays in your service. These are the four connections that come up most, and the [LangChain guide](https://flowrunner.ai/alternatives/langchain/with-flowrunner) has the code for each. **A flow is a tool your agent calls.** Write a LangChain tool that calls the [Call Flow API](https://docs.flowrunner.ai/api/call-flow-nonblocking.html). For a lookup that answers fast, the blocking call returns the flow’s result, up to 300 seconds. For anything that takes longer, the non-blocking call returns an `executionId` at once, the tool tells the agent the work has started, and the flow reports back to your endpoint when it’s done. The tool’s docstring is a sentence about the business result, and the flow keeps the details. **The middleware pauses, a flow gets the decision.** Mark `issue_refund` in `interrupt_on`. When the agent tries to call it, your app reads the pending call from the interrupt and posts it to a FlowRunner approval flow along with the thread id. The flow asks the support lead on Slack with the customer, the amount, and the agent’s reason. When they click, the flow POSTs the decision to your endpoint, and your app resumes the agent with an `approve` or `reject` decision. The agent picks up where it stopped, and the run record shows who was asked, when, and what came back. **FlowRunner starts your agent.** A flow catches the business event, a new Intercom conversation, say, and calls your agent’s HTTP endpoint with the fields it needs. The flow can take the agent’s answer into the next steps: reply in Intercom, tag the conversation, or route it to a person when the agent isn’t confident. **A FlowRunner agent calls your agent.** Expose your agent as an MCP server with the [MCP Python SDK](https://github.com/modelcontextprotocol/python-sdk), or use the `/mcp` endpoint LangSmith Deployment gives deployed agents, and [register it in FlowRunner](https://docs.flowrunner.ai/platform/mcp-servers.html) with a token or OAuth 2.0. A FlowRunner AI Agent block can then call your specialist agent, your contract reviewer or your pricing agent, when it decides it needs one. A plain HTTP endpoint called with the HTTP Request block works too, when no agent needs to decide. ## When you don’t need FlowRunner Plenty of LangChain projects don’t need anything around them yet: - **Prototypes and notebooks.** You’re testing prompts and tools, and nothing runs unattended. - **Read-only agents.** A research or Q&A agent whose tools only search and read has nothing to approve and little to record. - **The approver is the chat user.** If the person who says yes is the one typing into your app, your own UI and the middleware already cover it. - **The plumbing already exists.** If your team has built the integrations, the reviewer notifications, and the review screen, and they hold up, keep them. Add FlowRunner when the agent’s tools start changing business systems, when someone outside your app has to approve, or when people who don’t read traces need to know what happened. ## Feature comparison | Dimension | LangChain on its own | LangChain with FlowRunner | | --- | --- | --- | | Where the agent runs | Your process, or LangSmith Deployment | The same place, unchanged. FlowRunner doesn’t run Python | | Tools that touch business apps | One tool per API, with tokens, retries, and error handling you write | One tool per business process, backed by a flow; 2,100+ integrations with accounts connected once | | Human-in-the-loop | `HumanInTheLoopMiddleware`: pause, then approve, edit, reject, or respond | The same middleware, with a flow that reaches the reviewer and returns the decision | | Reaching the reviewer | Yours to build | Email, Slack, WhatsApp, phone, or a Form with a public link | | Waiting for the answer | A checkpointer holds the thread; you build the reminder and the resume | The flow waits up to 30 days (Free, Starter, Growth) or a year (Professional and above), then POSTs back | | What starts the agent | Your app, or a call to your endpoint | Also app triggers: Gmail, Intercom, Zendesk, Shopify, and more | | Record of what happened | LangSmith traces, for developers | Plus a FlowRunner run per flow, every block’s input and output, readable by anyone on the team | | MCP | Client through `MCPAdapter`; deployed agents expose `/mcp` | FlowRunner AI agents can call your agent’s MCP server as a tool | | Who can see and change the process | Whoever can read the code | Unlimited users on every plan, on a canvas | | Cost | The framework is free; LangSmith from $0 | Plus FlowRunner: Free at 100 executions a month, Starter from $5; one flow run is one execution | ## Frequently asked questions ### Is FlowRunner a LangChain alternative? Not in the sense of swapping one for the other. LangChain is a framework for writing agents in code, and that code keeps running in your service. FlowRunner sits around it: it gives your agent tools that run whole business processes, gets approvals from people in their own channel, starts the agent from events in business apps, and records each run for the rest of the team. Many teams use both. ### Can a LangChain agent call a FlowRunner flow as a tool? Yes. Wrap the Call Flow API in a LangChain tool. For a quick answer, such as a lookup, the [blocking call](https://docs.flowrunner.ai/api/call-flow-blocking.html) waits for the flow's result, up to 300 seconds. For work that takes longer or waits for a person, the [non-blocking call](https://docs.flowrunner.ai/api/call-flow-nonblocking.html) returns an executionId at once and the flow POSTs its result to your endpoint when it's done. The [LangChain guide](https://flowrunner.ai/alternatives/langchain/with-flowrunner) has the code. ### How does HumanInTheLoopMiddleware work with FlowRunner? The middleware pauses the agent before a tool call you've marked and waits for a decision: approve, edit, reject, or respond. When it pauses, your app sends the pending call to a FlowRunner flow. The flow asks the reviewer on email, Slack, WhatsApp, phone, or a Form, waits for the answer, and POSTs the decision back. Your app resumes the agent with Command(resume=...) on the same thread. Use a persistent checkpointer, since the answer can take days. ### Can FlowRunner run my LangChain code? No. FlowRunner runs JavaScript in its Custom Cloud Code block and in custom extensions, not Python. Your LangChain agent stays in your own service. FlowRunner calls it over HTTP or MCP, and the agent calls FlowRunner through the Call Flow API. ### Can FlowRunner's own AI agents use my LangChain agent? Yes. Expose the agent as an MCP server, for example with the MCP Python SDK, or through the /mcp endpoint that LangSmith Deployment gives deployed agents, at a publicly reachable URL. Register it in FlowRunner under MCP Servers with a token or OAuth 2.0, and attach it to an AI Agent block as a tool. A plain HTTP endpoint works too, called with the HTTP Request block. ### Do I still need LangSmith if I use FlowRunner? They do different jobs. LangSmith is LangChain's platform for tracing, evaluation, and deployment, and its traces show you what the agent reasoned and which tools it called. A FlowRunner run shows what happened in the business systems a flow touched, step by step, to anyone on the team. Keep LangSmith for the agent and let FlowRunner record the business side. ### What does it cost to add FlowRunner? The Free plan is $0 with 100 executions a month and no card, and every new account starts with 14 days of Professional. Starter is $5 a month for 300 executions or $15 for 3,000. One execution is one complete flow run, however many steps and however long it waits. Every plan has every integration, AI agents on your own model keys, human-in-the-loop, and unlimited users. ## Keep reading - [Use LangChain with FlowRunner](https://flowrunner.ai/alternatives/langchain/with-flowrunner) - [LangGraph and FlowRunner](https://flowrunner.ai/alternatives/langgraph) - [CrewAI and FlowRunner](https://flowrunner.ai/alternatives/crewai) - [Python and FlowRunner](https://flowrunner.ai/alternatives/python) [All alternatives](https://flowrunner.ai/alternatives) By [Mark Piller](https://flowrunner.ai/about#mark-piller), Founder of FlowRunner [Editorial policy](https://flowrunner.ai/editorial-policy) --- Markdown version of https://flowrunner.ai/alternatives/langchain. Site index: https://flowrunner.ai/llms.txt