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

An approval pauses the run, not a worker

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

Linea Labs
  • Runtime

Human approval is the easiest place for an agent system to waste resources. The run reaches a step that needs a person, and then it waits for minutes, hours, or until Monday. If a worker waits with it, you are paying for a process to do nothing.

Linea's approval node does not wait that way. It pauses the run, gives the worker back, and picks the run up again when a decision arrives. This post covers what the node creates, what a paused run holds, and what comes back out.

What the node creates

The first time the run reaches an approval node, the node creates an approval request. You configure what the request says:

  • a title, up to 200 characters, which defaults to "Approval requested"
  • an optional description and a set of text details to show the approver
  • an optional list of approver emails
  • an optional timeout in minutes

Then it notifies people. Every approver gets an in-app notification titled with the workflow name and the request text. If you listed approver emails, those members also get an email. Notification is best effort: if sending fails, the failure is logged and the request still exists.

Finally the node throws a pause. That is not an error. It is the signal that the step is neither complete nor failed, and that the run should wait.

The approval node creates a request and pauses. A decision resumes the run, and the node returns the decision as its output.

What a paused run holds

When the node pauses, the host marks the execution as paused, clears its worker, and clears its lease. The row stays resumable. Paused is deliberately not one of the terminal statuses, so nothing treats the run as finished.

The consequence is simple. A run waiting on an approval has no worker and no lease. It does not heartbeat, it does not expire, and nothing needs to stay alive for it. It is a row in the database with a request attached.

What comes back when someone decides

A designated approver responds with an approval or a rejection, and can add a comment. The API refuses a decision from anyone who is not a designated approver. A decision that resumes the run is protected by a live membership check, not just a retained session.

When the run resumes, the approval node runs again. This time the request is already decided, so the node does not create another one. It reads the decision and returns it as its output:

TypeScript

{
  approved: true,
  comment: "Refund is within policy",
  respondedBy: "user_123",
  respondedAt: "2026-08-20T14:02:11.000Z",
  timedOut: false,
}

A rejection is not a failure. The node returns approved: false and the run continues, so the next node, usually a branch, decides what a no means for this graph. The one case that does fail the step is a request that was cancelled while it was pending.

Timeouts decide for you

If you set a timeout, the request has an expiry, and you choose what happens when it passes. The timeout action is either auto approve or auto reject, and auto reject is the default. When a timeout makes the decision, the output says so with timedOut: true, so a later node can treat a no reply differently from a person saying no.

Without a timeout, the run waits as long as it takes. That is cheap, because the waiting costs nothing but a row.

Why this shape

Putting the wait on the host and not in a worker has three effects you can rely on.

  • Waiting is free. A paused run uses no worker capacity, so a hundred runs waiting on approvals cost the same as none.
  • A restart does not lose the wait. The request and the paused status live in the database, so a deploy while someone is deciding changes nothing.
  • The run continues, it does not restart. The steps before the approval are already checkpointed. When the decision lands, the run resumes at the approval step and moves on.

Design the node after the approval to read approved and timedOut, and the rest of the graph can stay simple.

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.