Should you choose LangGraph or ConvOps?
Choose LangGraph when you are building an agent into your own product. Choose ConvOps when the agents you already use must follow a process with sign-off, memory and a record.
choose LangGraph if
- You are building an agent into your own product, with your own UI or API.
- Your team writes Python or TypeScript and wants full control of state, nodes and edges.
- You need to mix deterministic code and LLM calls inside one graph.
- You want LangSmith for tracing, evaluation and managed deployment.
choose ConvOps if
- The agents already exist: Claude Code, Codex, Cursor, ChatGPT. You need them to follow a process.
- The people who own the process should change it by asking, not by shipping code.
- You need approval gates, an audit trail and shared memory across a team.
- You want to run the same process attended today and unattended later.
How do LangGraph and ConvOps compare?
Side by side, as of October 2026. ConvOps is the operations layer for AI agents: an MCP server that holds the process your AI clients follow, with approval gates, a shared memory and an audit trail. Every LangGraph cell links to the official source it comes from; ConvOps cells describe the product as it ships today.
| Capability | LangGraph | ConvOps |
|---|---|---|
| What runs the steps | Your application. Nodes are functions you write, and the ones that reason call an LLM you choose. [1] | Your AI client runs each step. ConvOps hands it one step at a time and runs no AI models itself. |
| Where the process lives | In your codebase, as a graph you build and deploy with your app or on LangSmith Deployment. [1] | A workflow in your ConvOps workspace, reached over MCP and changed by asking your AI client. |
| Human approval gates | interrupt() pauses a node and waits indefinitely; you resume with Command(resume=...). Needs a checkpointer and a thread id. [2] | Approval gates on any step, evaluated by the engine. The run waits at the gate, for minutes or days, until approval is passed. |
| Memory | Short-term working state through persistence, plus long-term memory across sessions. [1] | A shared brain of memories and routes, recalled across sessions, AI clients and workspaces. |
| Audit trail | Checkpoints of graph state per thread, which you can inspect and resume from. Tracing and evaluation are LangSmith features. [3] | An audit row for every change to tasks and workflow runs, keeping the agent's self-declared label apart from the server-verified human. |
| Attended or unattended | Whatever your app does: a chat UI, a background job, an API. You build the surface. [1] | Attended in your AI session, or unattended through executors and RRULE schedules, including one pod per run on your own Kubernetes. |
| Self-hosting | The library is MIT-licensed and runs wherever your code runs. LangSmith offers self-hosted and hybrid deployment on Enterprise. [6] | Hosted at mcp.convops.app, or self-hosted on your Kubernetes with one Helm chart on Enterprise. |
| Pricing model | Library free. LangSmith Developer $0 for one seat, Plus $39 per seat per month with one free small serverless deployment, Enterprise custom. [4] | Free $0, Pro $79/mo ($66/mo billed annually), Business $299/mo ($249/mo annually), Enterprise from $2,500/mo. Every feature on every plan; you pay for scale. Your AI client is billed separately. |
| Client support | None needed: you ship the agent. LangChain's MCPAdapter lets agents call tools defined on MCP servers. [5] | Any MCP client. Verified: Claude Code, Claude (web, desktop and Cowork), OpenAI Codex, ChatGPT, Cursor and OpenCode. |
What is LangGraph?
LangGraph is "a low-level orchestration framework and runtime for building, managing, and deploying long-running, stateful agents", from LangChain, usable without LangChain itself.
You define a graph of nodes and edges in code. The runtime gives you durable execution, so an agent can resume after a failure, human-in-the-loop through interrupts, and memory for working state and the long term. Its docs stress that you can mix deterministic and agentic steps in one graph (LangGraph overview).
An interrupt is the approval primitive. Calling interrupt() inside a node saves the graph state through the persistence layer and "waits indefinitely until you resume execution"; you resume by invoking the graph with Command(resume=...) on the same thread id (interrupts). Production use needs a durable checkpointer.
Is ConvOps a LangGraph alternative?
Only for one job: making agents follow a governed process. LangGraph builds an agent; ConvOps governs agents that already exist.
With LangGraph, your code is the runtime. You own the state schema, the nodes, the deployment and the user interface. That power is the point when the agent is your product.
With ConvOps, the AI client is the runtime. Claude Code or ChatGPT asks for the current step, does it with its own tools, and asks to advance. The graph is data on a server: steps, gates, decisions that invoke sub-workflows, loops back to an earlier step, child tasks. Nobody deploys it; you change it by asking your AI client. That is the method we call graph engineering.
Where is LangGraph stronger?
Anywhere you need control in code. ConvOps deliberately gives some of it up.
Typed shared state
Nodes read and write one state object you define. ConvOps state is the task, its notes and memories.
Edges anywhere
Conditional edges can route to any node. ConvOps has no jump to an arbitrary step, by design: detours return, loops go back.
Code and LLM in one graph
Deterministic functions and model calls are both nodes. ConvOps steps are instructions; it runs no code.
Interrupt anywhere in a node
Pause mid-function for approval of a specific tool call, with the payload you choose.
Ecosystem
LangSmith tracing, evaluation and deployment, and a large community.
Where is ConvOps different?
No code, no deployment, and the process is shared by every AI client and person in the workspace.
Built by conversation
Describe the change to your AI client. It edits the one step that needs it.
Bring your own AI
The agents your team already pays for run the steps. ConvOps runs no models.
Governance by default
Engine-evaluated gates, an audit row per change and three roles, without writing them.
A brain across tools
What one session learns is recalled by the next, in any client.
Can LangGraph and ConvOps work together?
Yes, at different layers. One split: LangGraph is the agent you ship; ConvOps governs the engineering process your team uses to build and release it.
Your developers work in Claude Code or Cursor on the LangGraph code. ConvOps holds their workflow: design approval, build, evaluation, release sign-off. A LangGraph agent could also call ConvOps tools through LangChain's MCPAdapter, since ConvOps is a standard MCP server; we have not tested that end to end.
one ConvOps workflow, with LangGraph inside one step
How do you start with ConvOps if you know LangGraph?
Think of a workflow as a graph you describe instead of compile. Each LangGraph idea has a ConvOps counterpart, or a deliberate absence.
| LangGraph | ConvOps |
|---|---|
| Node | Step: instructions your AI client carries out |
| interrupt() for approval | Approval gate, evaluated by the engine on advance |
| Subgraph | Decision that invokes a sub-workflow; the parent waits, then continues |
| Cycle | Loop back to an earlier step after a fix sub-workflow |
| Checkpointer | Every step persisted; any session resumes the run |
| Conditional edge to any node | Not supported, by design |
| Parallel branches | Child tasks that share an order; the parent waits for all |
- 1
Connect your AI client
In Claude Code, one line; OAuth on first use.
claude mcp add --transport http convops https://mcp.convops.app/ - 2
Describe the graph
Tell your AI client the steps, where people decide and what happens on a failed review. It creates the workflow. Skills vs MCP vs workflows explains which layer each piece belongs in.
What else do people ask about LangGraph and ConvOps?
Short answers to the questions that come up most, with the same sources as the table above.
Is ConvOps a LangGraph alternative?
For governing how existing AI agents follow a process, yes. For building your own agent into a product, no: LangGraph is a code framework with typed state, arbitrary edges and its own runtime, and ConvOps does not try to be one.
Can LangGraph pause for human approval?
Yes. Calling interrupt() inside a node saves the graph state and waits indefinitely until you resume with Command(resume=...) on the same thread. It needs a checkpointer, and a durable one in production.
Do I need to write code to use ConvOps?
No. You describe the workflow to your AI client, which creates the steps, gates and decisions over MCP. Your AI client then runs those steps.
Does ConvOps support conditional edges?
Decisions can invoke a sub-workflow that runs and returns, and loops can go back to an earlier step. There is no jump to an arbitrary step, by design, so the graph stays readable.
Can steps run in parallel in ConvOps?
Not inside one workflow: steps run in order. Parallel work is child tasks. Children that share an order start together, and the parent waits for all of them.
How much does LangGraph cost compared to ConvOps?
The LangGraph library is free and MIT-licensed. LangSmith has a free Developer plan and a Plus plan at $39 per seat per month. ConvOps has a free plan, Pro at $79 a month ($66 billed annually) and Business at $299 a month ($249 annually), priced by scale, not seats.
Where do these facts come from?
From the official documentation, repository and pricing pages for LangGraph, checked in October 2026. Anything we could not verify there is left out.
- [1]LangGraph docs: Overview
- [2]LangGraph docs: Interrupts
- [3]LangGraph docs: Persistence
- [4]LangChain pricing
- [5]LangChain docs: Model Context Protocol (MCPAdapter)
- [6]LangGraph repository and MIT license on GitHub
Spotted something out of date? Tell us and we will correct the page and its date.