DBOS and Restate are the two lightest durable execution engines for an AI agent that has to survive crashes and make a human-in-the-loop wait for approval. DBOS is a library, so the only thing it adds to your stack is a few tables in your Postgres. Restate is one binary with its own storage, which your services register with. Both suspend an agent while it waits for a person, and both pin a run to the code it started on.

So pick DBOS when your data belongs in your own Postgres and you want an MIT license end to end. Pick Restate when you’d rather keep durable state out of your application database, or you want an SDK in Rust or Kotlin with a managed cloud that lists SOC 2 and HIPAA. And if you’d rather run neither, Cadenya is a hosted agent loop with durable execution and approvals built in. What it offers is at the end.

Every price and limit below comes from each vendor’s own pages, checked on September 28, 2026.

DBOS and Restate side by side

	DBOS	Restate
What you run yourself	Your app and Postgres	One binary with a persistent volume. A cluster adds an S3 bucket for snapshots
Where the state lives	Your Postgres	Restate’s replicated log and RocksDB
License	MIT for DBOS Transact. Conductor is proprietary	BSL 1.1, Apache 2.0 four years after each release
Managed option	Conductor (console and recovery): Pro $99 a month, Teams $499	Restate Cloud: a free tier, then from $75 a month
What you pay for	Checkpoints: 1 million a month on Pro, then $50 per million	Durable actions, one per started 64 KiB of payload
How long a run can wait for a person	As long as the timeout you pass to recv(), which defaults to 60 seconds	No stated limit. The run suspends after a minute
The waiting primitive	send() and recv(), or setEvent() and getEvent()	Awakeables resolved over HTTP
Code that changes while runs wait	Runs recover only on the code version they started on	Runs end on the deployment they started on
SDKs	Python 3.10+, TypeScript on Node 20+, Go 1.25+, Java 17+, Kotlin	TypeScript, Java and Kotlin, Python, Go, Rust
Latest release	Python 3.1.0 and TypeScript 5.1, both September 24, 2026	Server v1.7.12, September 22, 2026

Self-hosted or managed: what you run

DBOS is durable execution on Postgres, “entirely built on Postgres”, and works with any Postgres, from a local container to RDS, Aurora, Supabase, or Neon. There’s no server to add. Its own sizing rule: 1,000 steps or workflows a second “requires 4 Postgres vCPUs.” When Postgres is down, workflows pause, and they resume when it’s back.

Restate is “a single binary that implements all features required to run a single- or multi-node cluster.” It stores its state on disk (a replicated log, with RocksDB for fast reads), so a single node needs a persistent volume. A cluster adds S3 for snapshots, and scaling it is “an operator-driven procedure rather than something to put behind an autoscaler.”

The question is where you want the state. DBOS puts your agent’s checkpoints next to your data. Restate keeps them in a system of their own.

Human-in-the-loop approvals: how long a run can wait

DBOS waits on a message, with a timeout you should always pass:

import { DBOS } from '@dbos-inc/dbos-sdk';

async function refundApprovalFn(refundId: string): Promise<string> {
  // Without the second argument, recv() gives up after 60 seconds.
  const approved = await DBOS.recv<boolean>('decision', 7 * 24 * 60 * 60);
  if (approved === null) return 'expired';
  return approved ? `refund ${refundId} sent` : `refund ${refundId} denied`;
}

export const refundApproval = DBOS.registerWorkflow(refundApprovalFn);

Your approval endpoint calls DBOS.send(workflowID, true, 'decision'). DBOS documents no maximum timeout, and the timer is durable across restarts.

Restate waits on an awakeable, which your endpoint resolves over HTTP:

import * as restate from '@restatedev/restate-sdk';

// Your code: post the ID wherever the reviewer works.
declare function notifyReviewer(refundId: string, awakeableId: string): Promise<void>;

export const refundAgent = restate.service({
  name: 'refundAgent',
  handlers: {
    approve: async (ctx: restate.Context, refundId: string) => {
      const approval = ctx.awakeable<boolean>();
      await ctx.run('ask reviewer', () => notifyReviewer(refundId, approval.id));
      return (await approval.promise) ? `refund ${refundId} sent` : `refund ${refundId} denied`;
    },
  },
});

The reviewer’s click becomes one request:

curl localhost:8080/restate/awakeables/sign_1M28aqY6ZfuwBmRnmyP/resolve --json 'true'

Restate states no limit on the wait, suspends the run after a minute, and adds a timeout only when you call orTimeout.

Versioning: deploying while runs wait

What happens when you deploy while an agent waits? Both engines refuse to run a waiting agent on code it didn’t start with, and both make you keep the old code around.

DBOS hashes your source into an application version. “When DBOS tries to recover workflows, it only recovers workflows whose version matches the current application version.” A run waiting on version A needs an executor on version A, or you move it with ForkWorkflow, which restarts it from a chosen step on a chosen version.

Restate registers each deployment as an immutable endpoint: “Restate then makes sure that requests start and end on the same version.” The same page gives the cost. It says to “Avoid long-running handlers (days or months)”, because “you need to keep old deployments around until all invocations complete.”

So a week-long approval is a week of running last week’s code, on either engine.

Pricing

DBOS Transact costs nothing but your Postgres. Conductor, which adds a console, recovery across servers, and version management, is $99 a month on Pro (1 million checkpoints, then $50 per million) or $499 on Teams (10 million, then $40 per million). Self-hosting Conductor is an Enterprise option.

Restate Cloud has a free tier. Its Cloud page says 50,000 durable actions a month and its pricing FAQ says 100,000, so check at sign-up. Paid plans start at $75 a month. Self-hosting is free under BSL 1.1, which only forbids offering Restate itself as a public platform service.

What you still write for an AI agent

Neither is the agent. The model loop, the tool calls, the stream to your UI, context compaction, and the approval screen stay in your code. DBOS integrates with Pydantic AI, LlamaIndex, the OpenAI Agents SDK, Google ADK, and the Vercel AI SDK. Restate’s AI patterns cover the Vercel AI SDK, the OpenAI Agents SDK, Google ADK, Pydantic AI, and LangChain.

Cadenya runs all of those for you.

What does Cadenya offer that DBOS and Restate don’t?

DBOS and Restate are the lightest ways to make your code durable. Cadenya gives an AI agent durable execution and human-in-the-loop approval waits with nothing to host: the loop and its state run on Cadenya, and your app keeps only its API. Here’s what that covers:

1. Nothing else to host. No library in your process, no binary, no persistent volume, and no S3 bucket for snapshots. The loop runs on Cadenya and your app stays a stateless web tier, so your deploys never touch a running objective.
2. The agent loop, already written. Cadenya calls the model, runs the tools, streams each reply, and compacts the context window when a conversation gets long. On DBOS or Restate, that’s your code.
3. No old code to keep running. DBOS and Restate both need last week’s code alive for last week’s waits. An objective keeps its variation’s configuration snapshot even when you edit the variation, and there’s no handler code to pin.
4. Tools generated from your OpenAPI spec. A tool set turns every operation in an OpenAPI 3 document into a tool, with no OpenAPI-to-MCP generator to run and no hand-written tool list to keep in sync. Cadenya re-checks the document each hour and loads tools on demand, so a big API doesn’t fill the context window. MCP servers and plain HTTP endpoints work too.
5. Human-in-the-loop approvals, screen included. A tool marked for approval pauses the objective on toolApprovalRequested until your backend, a webhook handler that posts to Slack, or a person in the React chat widget approves or denies it. There’s no awakeable ID to route or recv() timeout to set, and a denial can carry a memo that steers the agent.
6. Any model, on your own keys. The model is a setting on a variation, so switching providers needs no deploy: any model on OpenRouter, or your own endpoint that speaks the OpenAI chat format, billed by your provider. Weighted variations route more traffic to whichever model or prompt users rate higher.
7. Resumable streaming. The event stream honors Last-Event-ID, and the TypeScript SDK reconnects on its own.
8. Acting on behalf of the signed-in user. A widget session can carry the user’s short-lived token as a secret that overrides the shared API credential, and pinned parameters fix the IDs the model can’t change.
9. SDKs for the versions you run today. TypeScript on Node 18, Python 3.9, Ruby 3.1, and Go 1.22, all at 1.7.0 and Apache-2.0, plus a CLI and a plain HTTP API for Java or anything else. DBOS needs Python 3.10, Node 20, or Go 1.25.
10. A price in one line. Free for 1,000 loops a month, $49 a month for 50,000, then $0.0015 a loop, where a loop is one LLM request. Waiting costs nothing, there are no seats, and there’s no server license like Restate’s BSL to check, since you host no server.

The tool sets guide shows how your API becomes an agent’s tools, and the free plan needs no card.