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 n8n and Zapier: when you need an agent runtime

n8n 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.

Linea Labs
  • Runtime
  • Comparison

This post is about Linea Labs, the open-source AI agent runtime at getlinea.app. It is not the Consensys Linea network or the Linea sketching app. If you landed here for either of those, the disambiguation note will point you the right way.

If you are building an AI agent that does real work, n8n and Zapier are often the first tools you try. That makes sense. They connect to a lot of apps, you can get something running in an afternoon, and both now have agent features built in. So the fair question is not "which one is better." It is "what job am I hiring this tool for, and what happens on the day the agent fails halfway through?"

What n8n and Zapier do well

Both are workflow automation tools first. A trigger fires, steps run, data moves between apps. They have since added agents on top of that model.

n8n has an AI Agent node that can call tools. Its docs describe human review for tools: you can require approval before the agent runs a tool, for all of its tools or only selected ones, through channels such as n8n Chat, Slack, Gmail or Microsoft Teams. Approve and the tool runs with the input the model proposed. Deny and it does not run. n8n can also be self-hosted, which matters to teams that want the data on their own machines.

Zapier folded its standalone agents product into AI by Zapier, a step you drop into any Zap. Per Zapier, that step carries the same pieces as before, a prompt, tools, a trigger and permission to act, and now gets Zapier's triggers, filters, paths and run history. The "Require approval before running" setting applies per tool.

If your agent reads an email, summarizes it and posts a message, either of these is probably the right call. You get a big catalog of integrations and a visual editor, and with Zapier you do not need to run anything yourself.

What changes when the agent takes real actions

The harder cases show up when an agent runs for a while, touches systems that matter, and something goes wrong partway through. We ask five questions of any tool before we would trust it there.

If the worker dies mid-run, where does the run pick up: from the start, from the failed step, or not at all? Can you rerun one step against the exact input it saw, rather than the whole run or today's data? If a write to Gmail or GitHub times out, does the tool retry it blindly? A retry on an ambiguous failure is how the same email goes out twice. Is an approval tied to one exact action, or does "approved" let through whatever the agent does next? And if you edit the workflow while runs are paused, which version do they resume on?

Workflow tools answer some of these, and the answers change between releases, so check their current docs against your own case. Linea was built around these questions from the start, which is the main difference in focus.

How the Linea Labs agent runtime handles them

Linea is a host for agents and workflows. You draw or define a graph, publish a version, and start an execution by hand, from a webhook, on a schedule, or from the TypeScript SDK. The host runs every step and keeps the record. Here is what that record buys you.

Checkpoint after every step. Each completed node writes a checkpoint: the ids of completed steps, their outputs, and any workflow variables. If a worker loses its lease mid-step, that step gets no successful checkpoint, and the run resumes from the last node that finished. More on this in what happens when a worker dies and on the runtime page.

A succeeded Linea execution for a refund workflow. The header shows Succeeded, triggered by API, the Dev environment and the duration. The trace lists the Startup, Transform, Memory and Approval steps, and the Approval step is expanded to show that it resumed after a decision.

Step replay. Because the host ran every step, it stored each step's input and output. You can rerun one node against the input it originally saw, change the prompt or model, and freeze the fix as a regression case. That only works if the host kept the checkpoint, which is the point of why replay needs the checkpoint. See the replay page. Replay refuses steps that could change the outside world, such as connector calls and approvals, so testing a fix cannot fire a real action.

Side effects go through one gateway. Every connector call that changes something becomes an Action Intent with an idempotency key and a canonical digest of the action. Reusing a key for a different action fails with idempotency_conflict. If a write fails in an ambiguous way, such as a network error after the request may have reached the provider, the outcome is recorded as outcome_unknown. Whether Linea retries depends on the operation. Gmail send, GitHub issue and pull request creation, and Calendar update are dispatched once. Only an operation the provider can deduplicate, such as Calendar create, is retried, and then at most once. Side effects from an agent run are never retried automatically.

Approvals bound to one action. When consent is required, the run pauses on an approval request. The consent covers the exact Action Intent, so approving one action does not release another. A paused run releases its lease and holds no worker while it waits (approvals pause the run, not a worker). When the run resumes, the worker checks its authority first. If the environment, end user, deployment or workflow definition it ran under has been revoked in the meantime, the run fails with authority_revoked instead of acting on stale permission.

The Linea approvals page listing four pending refund requests, each titled with the customer, order and amount, for example Refund $412.00 to Halden & Co for ORD-20931 (damaged on arrival). Each card has an optional comment box and Approve and Reject buttons.

Pinned versions. An execution records its workflow version once, when it starts, and keeps it across pauses, retries and resumes. Editing the graph tomorrow does not change what a paused run does today (why every execution is pinned to one version).

What a paused run does. It releases its worker while it waits, and when a decision arrives the host checks authority before the run continues on the version it started with.

Traces you can read. Every step is stored with its node id, attempt, input and output, error and usage, along with cost and token counters on the execution. An execution also records whether any step ran on a model with no known price, so unknown pricing is flagged rather than silently counted as free.

Bounds by default. 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.

Memory on the host. Keyed facts with an expiry, scoped to the environment and the end user, so the next run reads what the last one learned (memory).

How to choose

Here is a rough rule, without pretending there is a score. Use Zapier when the agent is one step in a business automation, the actions are low risk, and you want zero infrastructure. Use n8n when you want a visual workflow tool with a broad integration list, self-hosting and per-tool human review, and the runs are short. Use an agent runtime like Linea when the agent is part of your product, runs take real time, it writes to systems where a duplicate or a stale approval is a real problem, and you need to replay a failed step and ship a fix without guessing.

These are not exclusive. A team can keep n8n or Zapier for internal glue and run the customer-facing agent on a runtime.

What Linea does not do yet

To be fair about the trade-off: Linea's connector list is much shorter than n8n's or Zapier's. Today it ships a GitHub connector, a Google connector for Gmail and Calendar, and outbound HTTP. Arbitrary MCP tools, sandboxed code execution, and owned knowledge-base and RAG infrastructure are not shipped. Linea is also pre-1.0, so interfaces may change. If you need a hundred integrations this week, a workflow tool will get you there faster.

Try it

If the questions above sound like your week, start with the getting started guide: draw a graph, publish a version and run it. The code is on GitHub, and the architecture page explains how the host, workers and checkpoints fit together.

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.