compare · langgraph

ConvOps vs LangGraph: a graph you code, or a process your AI walks

LangGraph is a framework for building your own agent: you code the graph in Python or JavaScript and get durable execution, interrupts and memory. ConvOps is not a framework. It holds the process your AI clients follow, with gates, a shared memory and an audit trail, built by conversation. Building an agent product: LangGraph. Governing agent work: ConvOps.

as of October 2026·updated ·published

LangGraphyour code is the runtime
AgentLLM call
{ }Toolsyour functions
interruptCommand(resume)
Respondyour app

You write, deploy and operate the graph.

ConvOpsyour AI client or an isolated runClaude Code
Specany client
BuildClaude Code
Approveyou decide
Shiprecorded

Built by conversation. Nothing to deploy.

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.
  • Example: a support team that records reopen rate on every triage run and reads the trend after each workflow change, with no code to ship.

How do LangGraph and ConvOps compare?

Side by side, as of October 2026. ConvOps is the operations layer for AI agents. It holds your team's process as workflows with gates, a shared memory, scheduled and unattended runs, programs, a plan board, metrics and a full audit trail. It does not sell or host models. Every LangGraph cell links to the official source it comes from; ConvOps cells describe the product as it ships today.

CapabilityLangGraph ConvOps
What runs the stepsYour application. Nodes are functions you write, and the ones that reason call an LLM you choose. [1]Your AI client runs each step, or an isolated run ConvOps starts. ConvOps hands it one step at a time and sells no models.
Where the process livesIn 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.
Approval gatesinterrupt() pauses a node and waits indefinitely; you resume with Command(resume=...). Needs a checkpointer and a thread id. [2]Gates on any step, evaluated by the engine: an approval, a required metric or a required report. An approval gate holds the step until an explicit approval is given, recorded with the account that gave it, for minutes or days.
MemoryShort-term working state through persistence, plus long-term memory across sessions. [1]A shared memory of facts and decisions, recalled across sessions, AI clients and workspaces.
Audit trailCheckpoints 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 unattendedWhatever 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 schedules (a cadence or a custom repeat rule, each in its own time zone), including one pod per run on your own Kubernetes.
Self-hostingThe 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, delivered with Enterprise.
Pricing modelLibrary 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 process feature on every plan; you pay for scale. Your AI client is billed separately.
Client supportNone 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 agent runtime is one you already use: Claude Code or ChatGPT in your own session, or Claude Code or OpenCode in an isolated run ConvOps starts. It 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; the agent writes and runs the 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 sells no models.

  • Governance by default

    Engine-evaluated gates, an audit row per change and three roles, without writing them.

  • Shared memory 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

SpecClaude Code
Approve designapproval
Build graphLangGraph code
EvaluateLangSmith
Releaseapproval
Shippedrecorded

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 idea → ConvOps counterpart
LangGraphConvOps
NodeStep: instructions your AI client carries out
interrupt() for approvalApproval gate, evaluated by the engine on advance
SubgraphDecision that invokes a sub-workflow; the parent waits, then continues
CycleLoop back to an earlier step after a fix sub-workflow
CheckpointerEvery step persisted; any session resumes the run
Conditional edge to any nodeNot supported, by design
Parallel branchesChild tasks that share an order; the parent waits for all
  1. 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. 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. In ConvOps an approval gate does the same without code: the step holds until an explicit approval is given, recorded with the account that gave it.

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 in ConvOps. Your AI client then runs those steps, or an executor runs them unattended on a schedule. Changing the process later is another conversation, not a code release.

Does ConvOps support conditional edges?

ConvOps decisions can invoke a sub-workflow that runs and returns, and loops can go back to an earlier step, such as a review that sends the work back to the fix step. There is no jump to an arbitrary step, by design, so the graph stays readable and every run follows a path you can audit.

Can steps run in parallel in ConvOps?

Not inside one ConvOps workflow: steps run in order. Parallel work is child tasks, each with its own workflow. Children that share an order start together, and the parent waits for all of them before it moves on. A gate can also hold the parent step until its child tasks are finished.

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. [1]LangGraph docs: Overview
  2. [2]LangGraph docs: Interrupts
  3. [3]LangGraph docs: Persistence
  4. [4]LangChain pricing
  5. [5]LangChain docs: Model Context Protocol (MCPAdapter)
  6. [6]LangGraph repository and MIT license on GitHub

Spotted something out of date? Tell us and we will correct the page and its date.