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.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.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.What happens when a worker dies mid-runA worker holds a 30 second lease and renews it every 10 seconds. If it dies, the lease expires, another worker claims the run, and the run resumes from the last checkpoint.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 one takes a different credential.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.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.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.The half frameworks do not shipFrameworks solve the loop. You still host it, retry it, store its memory, and keep its checkpoints. That second half is the product.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. It still has to run somewhere that cannot take down the host. Linea does not ship one yet, and this is why.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.
Toggle menu

The AI agent runtime and control plane

Build and operate
production agents.

You ship the agent. Linea executes the graph, holds the checkpoint, and gives you the loop to replay a failure and publish a fix.

Linea dashboard with workflows, signals, and recent executions

Under the hood

Real artifacts, not a black box.

Every run starts from a published graph. These are the actual payloads the host works with.

{
  "version": 1,
  "trigger": { "type": "webhook" },
  "entryNodeId": "fetch",
  "nodes": [
    {
      "id": "fetch",
      "type": "http",
      "config": { "method": "GET", "url": "https://billing.internal/invoices" }
    },
    {
      "id": "reason",
      "type": "ai",
      "config": { "prompt": "Explain the failed invoice in one paragraph." }
    }
  ],
  "edges": [{ "from": "fetch", "to": "reason" }]
}
  • Every version is a graph

    This is what the builder saves and the host runs: a trigger, an entry node, nodes, and edges. Each publish freezes it as a version you can replay and test against.

  • Replay starts with captured input

    This is the payload the response node received during the original execution. Linea restores this checkpoint when you replay the step.

  • A memory node

    Memory is a node in the graph, configured in the builder. This one stores a customer's plan for 30 days in the billing namespace.

The platform

Three things the host does for you.

Durable execution

Every step is checkpointed, failures retry, and an interrupted run resumes from the last successful node.

The fix loop

Replay the failing step against the exact input it saw, freeze it as a case, and publish the fix.

Memory on the host

Keyed facts live on the host, so the next execution reads what the last one learned.

Runtime

The host runs the graph.

You write the agent. Linea executes every step of it.

  • Checkpoint after every step
  • Automatic retries on failure
  • Resume where a crash left off
Explore the runtime

Replay

Replay the step that failed.

We ran it, so we kept the exact input every step saw.

  • Rerun one node, not the whole run
  • Swap the prompt or model and compare
  • Freeze the fix as a regression case
See how replay works
Linea monitoring view with open signals

Memory

Memory that survives the run.

The next run reads what the last one learned.

  • Keyed facts, scoped per end user
  • An expiry on every fact
  • Shared across every run of the agent
Explore memory

Built for the people
who operate the run.

Technical builders first. You write the agent. We execute the graph and keep the records that let you diagnose, replay, and ship a fix.

Technical founders

Would have assembled this stack

Durable execution, an agent framework, observability, evals, and a memory store are five products you would otherwise wire yourself. Linea is those on one data model.

AI engineers

Fix the step that failed

A flag fires on an execution. Replay that node against the input it originally saw. Freeze it as a regression case, publish, and check you did not break the rest.

Builders who operate the run

The framework is not the host

LangGraph writes the loop. You still host it. Linea executes the graph and keeps the control plane: checkpoints, signals, approvals, and the records around the run.

Linea builder with a document summarization graph

Questions

Everything you need to know.

What is Linea?

Linea is an agentic runtime and control plane. You ship an agent to your users. Linea executes the workflow graph behind it — model calls, tools, waits, approvals, and memory — and keeps the records around the run: checkpoints, signals, approvals, and regressions.

Is this a workflow-automation tool?

No. Workflow is the precise name for the executable graph, not the product category. An agent may use several workflows; some graphs are intentionally non-agentic. External positioning is build and operate production agents. Workflow terminology stays underneath where it is technically accurate.

How is this different from n8n or Zapier?

Those products execute automations and compete on visual simplicity. They get thin when a step needs real code or an agent loop, and they have no signal or regression layer. Linea executes the graph so it can hold the checkpoint, replay one step, and keep the control plane around the run.

How is this different from LangGraph?

A framework helps you write the loop. You still host the process, store checkpoints, keep memory, and operate the result. Linea is that host and control plane. Keep the prompts and tools you already have; we execute the graph.

What is step-level replay?

Because Linea executes the graph, it holds the checkpoint: the exact input a node received. Replay runs that one step again against that input. No deploy, no reproducing state, no re-running the steps before it. An observability vendor can show the failure; it never ran the graph, so it has no checkpoint to replay from.

Do I have to use the visual builder?

No. Every published version is a JSON graph the host runs exactly as published. You can author that graph in the visual builder, or create workflows and save drafts and versions through the TypeScript SDK with a workspace API key. Publishing a version and binding it to an environment need a signed-in admin in the dashboard. The SDK also starts executions, reads their results, and verifies webhooks.

Is Linea the same as Consensys Linea?

No. This Linea is from Linea Labs: an AI agent runtime and control plane at getlinea.app. It is not the Linea blockchain network from Consensys, and it is not the Linea sketching app.

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.