Preparing workspace…
Preparing workspace…
Durable execution for agentic workflows
Every completed step commits a checkpoint that survives a crash. When a tool call fails at step 7 of 12, the run resumes at step 7 — it does not replay the six steps that already worked, or the side effects they caused.
Bring your own model keys. Runs execute on our workers or inside your VPC. No training on your data, ever.Checkpoint ribbon
Run accepted
Event log
The problem
These are not edge cases. They are what happens on an ordinary Tuesday when a provider rate-limits you.
The process dies at step 9 and the work from steps 1–8 dies with it. There is no record of what completed, so the only safe move is to start again.
Re-running the whole workflow re-sends the emails, re-charges the cards and re-writes the rows. Without idempotency keys and commit boundaries, a retry is a second incident.
Anything that needs a human decision has to be split into two workflows with a queue between them, or it runs unsupervised. Neither is what you wanted.
You get a stack trace and a bill. Not which node failed, not what it had already committed, not which of the 83 failures share one root cause.
A 12-node renewals workflow. Six nodes committed, then stripe.getInvoice fails on a refused connection. Here is what the recovery costs.
| Naive re-run | Checkpoint resume | |
|---|---|---|
| Nodes executed | 12 | 1 |
| Tool calls issued | 9 | 1 |
| Tokens spent | 14,820 | 1,204 |
| Cost of the retry | $0.0474 | $0.0031 |
| Duplicate Slack messages | 2 | 0 |
| Duplicate Stripe writes | 1 | 0 |
| Time to recover | 1m 48s | 9.4s |
The mechanism
Runs are event-sourced. The log is the source of truth and the current state is derived from it, which is what makes resume exact rather than best-effort.
Every node ends at a boundary. The output, the inputs that produced it and the side effects it caused are written together, or not at all.
The boundary that survives a crash. A checkpoint is the durable claim that this node will never need to run again.
A worker does not own a job, it leases it. If the worker dies mid-node, the lease expires and another worker picks the run up from the last checkpoint.
The run suspends and its state is persisted. Nothing is held in memory waiting for a person; the run can wait four hours or four days at no cost.
Execution restarts at the first node after the last checkpoint. Committed nodes are not replayed, so their side effects are not repeated.
The same run, after recovery
Two nodes failed once and committed on retry — the ember notch. One branch was not taken. Everything else committed first time. The shape of the run is the record.The surface
The screens are built for the person who gets paged, not for the screenshot. Everything below is the real interface.
Build the graph, or import one. Branches, fan-out, loops, waits and gates are first-class nodes rather than code you maintain.
Every number links to its cause. A 41% success rate opens the three incidents behind it; a failing connection tells you the seven tools it blocks.
Per-workflow spend caps, token ceilings, risk tiers that require approval, and forecasting that says when you hit the cap at the current rate.
Your Anthropic, OpenAI, Gemini or Mistral keys, encrypted with AES-256-GCM and decrypted only inside the runner that needs them.
Runs
163 runs · 83 failed| Run | Workflow | Shape | Cost |
|---|---|---|---|
| usage-rollup | $0.0699 | ||
| renewals-daily | $0.0031 | ||
| renewals-daily | $0.0031 | ||
| renewals-daily | $0.0031 | ||
| renewals-daily | $0.0031 |
Recovery engine
Connection Postgres Answers is refusing connections.
41 runs share this signature · 3 workflows and 7 tools blockedHumans in the loop
A gate suspends the run and persists its state. The reviewer sees the resolved values the agent actually computed — not the template that produced them — alongside where each one came from.
Approve, reject with a required reason, or request changes. The decision is written to the audit trail with the context it was made on, so it can be defended six months later.
Awaiting approval
SLA 26m remainingInteroperability
Vectorbea is the execution layer, not another agent framework. Whatever wrote your agent keeps writing it; we make the run survive.
Call a chain as a node. Inputs and outputs map through the standard schema.
Run a crew as a single durable step, with its own checkpoint boundary.
Wrap a conversation; the transcript is captured in the run's event log.
If it answers a POST, it is a tool. Auth, retries and timeouts are ours.
Honestly
Two rows at the bottom go against us. If mature scheduling or connector breadth is the thing you are buying, Airflow and Zapier are still the better answer.
| Capability | Script + cron | Agent frameworks | Workflow tools | Vectorbea |
|---|---|---|---|---|
Resumes from the last committed step Workflow tools resume the task graph, not the agent's own mid-step state. | No | No | Partial | Yes |
Per-step idempotency keys | No | No | Partial | Yes |
Suspends for human approval, at no cost while waiting | No | Partial | Partial | Yes |
Per-node token and cost accounting | No | No | No | Yes |
Failure clustering by signature | No | No | Partial | Yes |
Runs agents you already wrote | Yes | Yes | No | Yes |
Mature scheduling and backfill Airflow has a decade of scheduling behaviour we do not match yet. | Partial | No | Yes | Partial |
Huge connector library Zapier's directory is far larger. We cover the integrations agentic workflows actually reach for. | No | No | Yes | Partial |
Runs entirely on your own machine, free | Yes | Yes | Partial | Partial |
Security and trust
Provider credentials are sealed with AES-256-GCM under a per-workspace data key. They are decrypted in the runner process that needs them and never written to logs.
TLS 1.3 on every hop. Run payloads, node inputs and outputs are encrypted at rest; secrets are stored separately from run data.
Actor, action, target and a diff for every change — workflow edits, approvals, key rotations, member changes. Retained independently of run history.
Run workers inside your VPC so payloads never leave your network. The control plane sees run metadata; it does not need to see the data.
Kill the process halfway through. Watch it come back at the step it left, with nothing duplicated. That is the whole pitch, and it takes about four minutes.
No card required. Bring your own model keys.