Linchpin / Compare / vs LangGraph

Linchpin vs LangGraph

LangGraph is a Python library for orchestrating LLM workflows as a graph. Linchpin is a runtime that runs agents as persistent sessions on a single VM. Library vs platform. You would use LangGraph inside an application; you would deploy Linchpin as one.

What each one is

§ 01

Linchpin is an open-source managed-agent runtime. You define agents and environments through an HTTP API; Linchpin owns the orchestrator loop, the sandbox containers, the append-only event log, the model-provider calls, and the streaming protocol. It is a small platform you can self-host on a single VM. License: Apache-2.0. Stack: FastAPI, React, Postgres 16, Docker. Models: OpenRouter and Ollama.

LangGraph is a Python library from the LangChain team for building stateful, multi-actor LLM workflows as directed graphs. You define nodes (functions) and edges (transitions), and LangGraph drives the graph. It is excellent at expressing complex agent control flow in Python, with checkpointing and human-in-the-loop primitives. License: MIT. Stack: Python library.

LangGraph is what you write your agent's brain in. Linchpin is what runs that brain in production, exposes it over HTTP, persists its event log, isolates its tool calls in a sandbox, and streams its output to clients.

Side by side

§ 02

Dimension	Linchpin	LangGraph
Shape	Runtime / platform — runs as services	Library — imported into your code
License	Apache-2.0	MIT
Self-host	Yes — `docker compose up`	You write the service; LangGraph has no server of its own (LangGraph Platform is hosted/closed)
API surface	HTTP `/v1` for agents, environments, sessions, events	Python API — graph, state, checkpoint
Sessions	First-class — persistent, resumable, event-sourced	Threads via checkpointer
Sandbox / isolation	Per-session Docker container, dedicated network	Whatever your code does
Tools	Built-in eight + MCP via stdio	You wire them as graph nodes
Streaming	SSE on every session	Async streaming primitives — you serve them
Persistence	Postgres-backed event log, cursor-paginated	Pluggable checkpointer (SQLite, Postgres, Redis)
Language	API is language-agnostic (HTTP)	Python only
Models	OpenRouter + Ollama only	Anything LangChain supports

When to pick Linchpin

§ 03

You want a platform, not a library. Sessions, sandboxes, event log, streaming, model providers — pre-wired. You will not build a FastAPI service around a LangGraph graph yourself.
Your callers are not Python. Linchpin's surface is HTTP. Any client can drive it — Go, TypeScript, Rust, curl.
You want sandboxed tool execution. Linchpin runs the agent's tool calls inside a per-session Docker container on a locked-down network. With LangGraph you would build this layer yourself.
You want an event log other systems can subscribe to. Linchpin's append-only log with cursor replay is a primitive other services can build on. LangGraph's checkpointer is a serialization mechanism, not an event bus.
You want to self-host on commodity infrastructure. Linchpin is one VM and Postgres. There is no LangGraph-equivalent that you self-host as a platform without writing the platform yourself.

When to pick LangGraph

§ 04

Your agent logic is complex and you want to express it as a graph in Python. LangGraph is unmatched for this — branching, loops, conditional edges, parallel nodes, human-in-the-loop checkpoints.
You are already inside a Python application (a FastAPI service, a notebook, a Celery worker) and you just want a library to drive the agent. Linchpin is overkill if you already have the platform.
You need exotic model providers. LangGraph (via LangChain) supports nearly every provider in existence. Linchpin is deliberately limited to OpenRouter and Ollama.
You want the LangSmith ecosystem. LangGraph integrates tightly with LangSmith for tracing and evaluation. Linchpin has no equivalent built-in observability product.
You are doing research or prototyping. The shorter feedback loop of a Python library beats spinning up a runtime.

Using them together

§ 05

The two are complementary in principle. Linchpin's orchestrator loop is intentionally simple; if your agent logic is graph-shaped, the natural extension is to drive the model calls and tool decisions from a LangGraph graph living inside Linchpin's agent definition. We do not ship this integration today, but nothing in the runtime prevents it — Linchpin treats the agent's "next step" as opaque, so you can plug a graph engine in.

If you are choosing only one and your need is "give me the platform on which I will run agents," pick Linchpin. If your need is "give me a great way to structure agent logic in Python," pick LangGraph. See the Linchpin quickstart.

§ 06