Linea Labs vs n8n and Zapier: when you need an agent runtimen8n and Zapier are great at connecting apps. Here is when an AI agent needs a runtime instead: checkpoints, step replay, and approvals tied to one exact action.Which Linea client to use, and which key goes whereThe TypeScript SDK has a server client, an environment client for production starts, an end-user client for browsers, and a webhook verifier. Each takes a different credential. Here is how to pick.Memory has a subject, a namespace, and an expiryEvery memory fact lives under a key, a subject and a namespace, and it always expires: 90 days by default, one year at most. Here is how writes, reads and sharing work, and why we made those choices.An approval pauses the run, not a workerA paused run releases its lease and holds no worker. It waits until someone decides, then the approval node returns the decision and the run continues from that step. Here is how we built it.Linea Labs vs LangGraph: choosing an agent runtimeA fair comparison of Linea Labs and LangGraph as an AI agent runtime: what the framework covers, what the host does, and how to choose.Why every execution is pinned to one versionAn execution records its workflow version once, when it starts, and never follows a live pointer. That is why resume and replay still mean something weeks after a graph has changed.How a run survives a dead workerWorkers die mid-run all the time. Here is how we lease runs, checkpoint every node, and refuse stale writes so that a second worker can finish the job without doing the work twice.Linea Labs is not Consensys LineaLinea Labs builds Linea, an open-source AI agent runtime at getlinea.app. It is not the Consensys Linea blockchain, and not the Linea Sketch iPad app.What is an AI agent runtime?A framework gives you the agent loop. A runtime runs it in production: durable steps, checkpoints, approvals, crash recovery, and replaying one failed step. Here is what we mean by the word.Why replay needs the checkpointYou cannot re-run step four without the exact input it saw. That input only exists if the host executed the run and kept the checkpoint, which is why we built replay on top of one.One graph, not two productsThe canvas, the workflow JSON, and the node registry describe one thing. A second editor is fine. A second graph is a second product, and this is the rule we hold ourselves to.The half frameworks do not shipFrameworks solve the loop. You still host it, retry it, store its memory, and keep its checkpoints. We think that second half is the product, and here is how we split the two.Memory is not a side questFacts have to survive the run. If you stand up the store yourself, you are still doing the ops half. We think the graph should ask for memory and the host should keep it.Sandbox the code nodeA code node is an escape hatch, and it still has to run somewhere that cannot take down the host. Linea does not ship one yet. This is what we require before we do.Triggers are not the productStarting a graph is a solved problem. The product is what has to stay up after it starts: the worker, the checkpoint, the wait, and the memory. Here is where we spend our time.
Toggle menu

Linea Labs vs LangGraph: choosing an agent runtime

A fair comparison of Linea Labs and LangGraph as an AI agent runtime: what the framework covers, what the host does, and how to choose.

Linea Labs
  • Runtime
  • Comparison

This post is about Linea Labs, the open-source agent runtime at getlinea.app. It is not the Consensys Linea blockchain, and it is not the iPad sketching app called Linea. If you were searching for either of those, start with the disambiguation note instead.

If you are choosing how to run agents in production, you will usually meet LangGraph first. Its docs describe it as both an orchestration framework and a runtime. Linea Labs is also an AI agent runtime. Calling LangGraph "just a framework" and Linea "the runtime" would not be fair. Both talk about graphs, checkpoints, pauses and memory, and they are not interchangeable.

The difference is the unit of work you are buying. With LangGraph it is a library, and if you want it, a hosting product for that library. With Linea it is a host that already runs its own graph and treats the step record as a product surface.

Two shapes of the same job. LangGraph is a library you compile, wire to a checkpointer and host, with Agent Server as one optional host. Linea is the host: it runs the published graph and keeps the step record.

What LangGraph is

LangGraph's overview calls it a "low-level orchestration framework and runtime for long-running, stateful agents." You define a graph of shared state, nodes and edges, and you can mix deterministic steps with model-driven ones. It does not prescribe prompts or a fixed agent architecture.

In the LangChain stack, LangChain is the higher-level agent framework: models, tools and agent loops. LangGraph is the orchestration layer underneath it, with durable execution, streaming, human-in-the-loop and persistence. It does not require LangChain, though many examples use it. LangSmith sits next to that stack for tracing, evaluation and deployment.

You write the graph in Python or JavaScript, typically as a StateGraph: add nodes, add edges, compile, then invoke or stream. Persistence is not implicit. The docs have you compile with a checkpointer, which saves a snapshot of graph state at each super-step under a thread_id. That is what powers human-in-the-loop, fault tolerance and time travel. For production the docs point to PostgresSaver. The in-memory saver is for experiments, and its checkpoints are lost when the process restarts.

LangGraph also splits memory in two. Checkpointers hold short-term, thread-scoped state, which is the run or conversation you can resume. Stores hold long-term facts that span threads. Most production apps are expected to use both.

Three more capabilities matter for this comparison. Interrupts let a run halt so a person can review or edit state, then continue. Fault tolerance means that if a node fails in a super-step, you can restart from the last successful step, and writes from nodes that succeeded are not re-run. Time travel lets you replay an earlier execution, or fork state from a checkpoint to try another path.

Runs also have durability modes. In order from least to most durable, exit saves only when the run ends, async saves while the next step runs, and sync saves before the next step starts.

You can run a compiled graph in your own process. You still choose how to host it, wire the checkpointer and operate the result.

For a hosted path, LangChain documents LangSmith Agent Server, formerly LangSmith Deployment. It is a workflow orchestration runtime for LangGraph graphs: an API for assistants, threads, runs and cron jobs, with built-in persistence and a task queue. PostgreSQL is the default store for resources and checkpoints. Redis handles signaling and streaming and holds only ephemeral data, while run data is read from and written to PostgreSQL. You can run it on LangSmith Cloud, in a hybrid setup, self-hosted, or as a standalone server. That is a complete production path if you want to write LangGraph graphs and deploy them.

What the Linea Labs agent runtime is

Linea is an open-source runtime and control plane for production agents, written in TypeScript and licensed under Apache 2.0. The project is pre-1.0, so interfaces may still change. You write the agent, and Linea executes each published version of the graph. The visual builder and the TypeScript definition are two views of the same workflow.

The architecture docs split the system in two. The control plane, the Platform API, accepts and observes work. The execution plane, the workers, performs it. The execution flow page is explicit about authority: PostgreSQL is the source of truth, and Redis with BullMQ only delivers jobs. A queued message alone does not decide whether work exists or has finished. A transactional outbox closes the gap between committing state and publishing the job.

An execution is one instance of an immutable workflow version, pinned when the run starts, so a later publish cannot rewrite a run that is already in flight. Why every execution is pinned to one version covers that rule.

The worker claims a lease on the execution (30 seconds, with a 10-second heartbeat), loads the pinned version and walks the graph. After every node it persists a step record and a checkpoint. The checkpoint holds the ids of completed steps, their outputs keyed by node id, and any workflow variables. If the worker disappears, another claims the run and resumes from the latest durable checkpoint. If the lease is lost mid-step, the in-flight handler is cancelled and the checkpoint does not advance. Queue delivery is at least once, and duplicate work is handled with lease claims and idempotency keys. What happens when a worker dies walks through the failure case.

Resume and replay are different operations. Resume continues the same execution from its checkpoint. Replay is narrower: it runs one step again against the exact input that step originally received. Why replay needs the checkpoint covers that point, so this post will not retell it.

The step history is a product surface, not disposable worker logs. Each attempt records the node, its sequence and attempt number, status, input and output, error, timing, a trace and span id, token usage and cost, and the model and provider for AI steps. In the dashboard a failed step shows its error and the exact input it received, with Replay and "Add to regression suite" next to it.

A failed Linea execution. The banner reads that the run failed after completing some work, with the memory node error "no value found at subjectPath output.customer.id". The failed Memory step is expanded and shows its input, with Replay and Add to regression suite buttons.

The same records are what evals and regression cases are built from. You can freeze a known input as a case and rerun it when you publish a new version.

Approvals and waits are durable pauses, not in-memory holds. The run stays paused until a person makes an immutable decision or a timer fires, then it continues. Agent memory lives on the host, scoped to the workspace, the environment and the end user, so a later run can read facts an earlier one learned.

Google and GitHub connector families are implemented, with consent for side effects. Two things the README is clear about: arbitrary MCP tools and sandboxed code execution are not shipped. The TypeScript SDKs are still workspace-internal and are not published to npm.

One caveat belongs next to replay. Diagnostic replay and regression runs refuse some node types today. Connector, agent, approval and wait nodes are refused, and HTTP, AI and memory nodes run only when they do not write: non-GET HTTP calls, non-GET AI tools and memory writes are refused. A replay exists to test a step without changing the world, so it will not fire a real side effect.

How to choose

If you already think in LangGraph's graph API, and you want fine-grained control over shared state and control flow in Python or JavaScript, LangGraph is the straightforward choice. You can start in your own process with a persistent checkpointer, and later deploy the same graphs to Agent Server if you want a managed or self-hosted runtime for that library. You also stay in an ecosystem that already has tracing and evaluation through LangSmith.

If you want the host and the control plane in one open-source system, Linea Labs is aimed at that job. You author a versioned workflow visually or as TypeScript, then run it on Linea's workers. The checkpoint, the step record, the approval and the memory sit on the same data model as the run. The loop Linea is built for is this: inspect the failed step, replay it against the input it saw, change the workflow, publish a new version, and keep the case as a regression.

Those are different products, not two names for the same library. Linea does not execute a LangGraph graph.

A practical way to decide is to list what you are willing to operate. If you want to own the graph code and plug it into a LangGraph-shaped runtime, start with LangGraph and the Agent Server docs. If you want a host that already executes the graph, keeps the exact step input, and gives you a builder and a run history on the same definition, start with Linea and the architecture guide.

Limits, and a next step

This post does not invent latency, cost or reliability numbers, and it does not assign a winner. LangGraph and Agent Server facts come from their official docs. Linea facts come from the site, the public docs, the linea-org/linea README and the source.

Linea is pre-1.0, so treat current APIs and limits as in motion. A graph run stops after 30 minutes, a node attempt after 60 seconds, and an execution after 1,000,000 tokens. Agent loops are capped at 25 iterations and a 30 minute work budget.

If the category is still fuzzy, read What is an AI agent runtime? first. If you want the mechanics of a Linea run, the execution flow page is the precise version. The source is on GitHub under Apache 2.0. Star the repo if this is useful, or start building.

The Linea newsletter

What we learn from every run.

New releases and field notes on running agents in production.

One email when something ships. Unsubscribe anytime.