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
The AI agent runtime and control plane
You ship the agent. Linea executes the graph, holds the checkpoint, and gives you the loop to replay a failure and publish a fix.


Under the hood
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
Every step is checkpointed, failures retry, and an interrupted run resumes from the last successful node.
Replay the failing step against the exact input it saw, freeze it as a case, and publish the fix.
Keyed facts live on the host, so the next execution reads what the last one learned.
Runtime
You write the agent. Linea executes every step of it.
Replay
We ran it, so we kept the exact input every step saw.

Memory
The next run reads what the last one learned.
Technical builders first. You write the agent. We execute the graph and keep the records that let you diagnose, replay, and ship a fix.

Notes on the host, the checkpoint, and the loop after a failure.
Questions
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.
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.
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.
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.
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.
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.
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.