A windswept bonsai on a floating island

Get to know Cadenya

We’re developers who love to build. We set out to create a yes-code platform that makes building agents feel like the best parts of building software.

DBOS for AI agents (2026)

Durable execution

By Cadenya

DBOS runs an AI agent as a durable workflow: DBOS Transact is a library inside your app that checkpoints each workflow and step to Postgres, so the agent loop resumes from its last completed step after a crash. For human in the loop, the workflow calls recv() and your API calls send() with the approval, in Python, TypeScript, Go, or Java.

So pick DBOS Transact when your app already runs on Postgres and you’re happy to keep the agent loop inside a deterministic workflow. Add DBOS Conductor (from $99 a month) when you run several executors and want recovery across them and a workflow console. And if you’d rather call an agent loop than write one, Cadenya is a hosted agent loop with approvals, conversation state, resume, and model swap built in. A coding agent can set it up with no account, in a temporary workspace you claim later. What it offers is at the end.

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

DBOS vs Temporal vs Restate vs Inngest for durable AI agent workflows

Coding agents that look at DBOS tend to compare it with Temporal, Restate, and Inngest:

DBOSTemporalRestateInngestCadenya
What you runYour app with the DBOS Transact library, plus PostgresThe Temporal Server’s services, plus Persistence and Visibility storesOne binary with an embedded state storeOne binary. SQLite by default, Postgres optionalYour app and an API key. Cadenya runs the loop
Human in the looprecv() in the workflow, send() from your APISignals and Updatesctx.awakeable(), resolved with ctx.resolveAwakeable()step.waitForEvent()Mark a tool for approval. The loop parks on toolApprovalRequested until your backend decides
Managed planDBOS Conductor: Pro $99 a month with 1M checkpoints, Teams $499Temporal Cloud: Pay-As-You-Go with no base fee, from $50 per million actionsRestate Cloud: free plan with 100k actions a monthFree with 50k executions, Pro from $99 a monthFree for 1,000 loops a month, Growth $49 a month for 50,000
LicenseTransact: MIT. Self-hosted Conductor: proprietaryMITBusiness Source License 1.1SSPL 1.0, with an Apache 2.0 future licenseHosted loop. SDKs under Apache-2.0

DBOS is the one with no server of its own: “There’s no separate orchestration server and no infrastructure required besides Postgres.” For the head-to-heads, see DBOS vs Temporal and DBOS vs Restate. Durable execution for AI agents covers the wider field.

DBOS Transact durable workflows on Postgres for AI agents

You mark functions as workflows and steps, and DBOS checkpoints them to Postgres as they run. After a crash, DBOS calls the workflow again with its saved inputs, and each finished step returns its saved output instead of running.

Two rules shape your agent code. The workflow must be deterministic, so any model call, tool call, database read, or clock read goes in a step. And steps should be idempotent, because a step that fails midway runs again during recovery. Once a step completes and is checkpointed, “it is never re-executed.”

So an agent on DBOS looks like this:

  1. A workflow holds the agent loop and decides what happens next.
  2. Each model request and each tool call runs as a step.
  3. A wait for a person is a recv() inside the workflow.

DBOS ships integrations with Pydantic AI, LlamaIndex, the OpenAI Agents SDK, Google ADK, and the Vercel AI SDK. In Pydantic AI, a DBOSAgent wraps Agent.run (the agent’s main loop) as a workflow and wraps model requests and MCP calls as steps. Custom tool functions “are not automatically wrapped,” so you decorate those with @DBOS.step yourself. Pydantic AI agents in production compares that path with Temporal and Prefect.

For the Vercel AI SDK, the @dbos-inc/vercel-ai package (0.5.4, MIT) wraps the model:

import { DBOS } from '@dbos-inc/dbos-sdk';
import { generateText, wrapLanguageModel } from 'ai';
import { openai } from '@ai-sdk/openai';
import { durableCalls } from '@dbos-inc/vercel-ai';

const model = wrapLanguageModel({
  model: openai('gpt-5'),
  middleware: durableCalls({ retriesAllowed: true, maxAttempts: 5 }),
});

const researchAgent = DBOS.registerWorkflow(
  async (question: string) => {
    const { text } = await generateText({ model, prompt: question });
    return text;
  },
  { name: 'researchAgent' },
);

It needs “DBOS v4.27+ or v5, AI SDK v7+, and a Postgres database for DBOS,” and tools go through durableTools. Durable agents with the Vercel AI SDK covers the other ways to make that SDK durable.

DBOS Transact releases 2026: Python, TypeScript, Go and Java

DBOS Transact ships one MIT-licensed library per language. Here are the latest releases on each registry:

LanguagePackageLatest releaseRuntime
Pythondbos on PyPI3.5.0, November 10, 2026Python 3.10 or later
TypeScript@dbos-inc/dbos-sdk on npm5.5.0, November 10, 2026Node.js 20 or later
Gogithub.com/dbos-inc/dbos-transact-golangv1.8.0, October 28, 2026Go 1.25 in go.mod
Javadev.dbos:transact on Maven Central1.2.0, October 1, 2026Spring Boot starter available

The docs also list a Rust SDK, the dbos crate at 0.6.0.

The system database holds checkpoints, queues, and messages. In Python it “may be either Postgres or SQLite, though Postgres is recommended for production,” and with no connection string DBOS creates a SQLite file. The Java Spring Boot starter (transact-spring-boot-starter) takes a PostgreSQL DataSource.

Every server in one DBOS application uses the same language. But a TypeScript app can enqueue work on a Python app through the DBOS Client or a shared system database. For the Go and Java options around DBOS, see durable AI agents in Go and AI agent frameworks in Java.

DBOS human in the loop with recv, send and set_event

DBOS’s own human-in-the-loop guide puts the wait in one line. The workflow calls DBOS.recv, and an HTTP endpoint delivers the answer with DBOS.send:

@DBOS.workflow()
def durable_agent(request: AgentStartRequest):
    agent_status = AgentStatus(status="working", ...)
    DBOS.set_event(AGENT_STATUS, agent_status)

    # Do some work, then request approval
    agent_status.status = "pending_approval"
    DBOS.set_event(AGENT_STATUS, agent_status)
    approval = DBOS.recv(timeout_seconds=TIMEOUT)

@app.post("/agents/{agent_id}/respond")
def respond_to_agent(agent_id: str, response: HumanResponseRequest):
    DBOS.send(agent_id, response)
    return {"ok": True}

Four details matter in production:

  1. Messages are durable. “If send completes successfully, the destination workflow is guaranteed to receive it.” Sending from a workflow is exactly once, and outside a workflow you pass an idempotency_key to get the same guarantee.
  2. Topics keep waits apart. recv("approval", ...) consumes the next message on that topic, so one agent can wait for different kinds of answers.
  3. A waiting workflow can suspend. Pass suspend=True and it “consumes no resources while waiting.” Any send on that topic wakes it.
  4. Status comes from events. set_event publishes where the agent is, get_event reads it, and list_workflows(status="PENDING") finds the agents waiting on a person.

The same pair exists in each SDK: DBOS.recv and DBOS.send in TypeScript, dbos.Recv and dbos.Send in Go, and dbos.recv(topic, timeout) and dbos.send(...) in Java.

The approval screen is yours to build. DBOS delivers the message, and the inbox and the approve button live in your app. Human-in-the-loop approvals for AI agents compares other options.

DBOS workflow versioning, patching and recovery

A breaking change is “any change in what steps run or the order in which steps run,” so a new tool call in the loop is one. DBOS gives you two strategies.

Patching wraps the change in a conditional. DBOS.patch() returns True for workflows that start after the change and False for older ones:

@DBOS.workflow()
def workflow():
  if DBOS.patch("use-baz"):
    baz()
  else:
    foo()
  bar()

When the old workflows finish, you swap in DBOS.deprecate_patch("use-baz"), and later delete the patch. Auto-upgrade, which moves old workflows to the newest version for you, is a DBOS Transact Enterprise feature and needs a Conductor key.

Versioning tags each workflow with its application version, by default “a hash of workflow source code.” DBOS then “only recovers workflows whose version matches the current application version,” so the docs recommend blue-green deploys: keep old processes running until their workflows drain.

By hand, the Python CLI has dbos workflow list, dbos workflow resume, and dbos workflow cancel. And DBOS.fork_workflow re-runs an agent from a chosen step, such as the tool call that failed.

DBOS Conductor pricing, self-hosted license and DBOS Cloud

DBOS Transact is open source and “free forever.” DBOS Conductor is the paid control plane, and it’s “not part of your workflows orchestration path,” so a dropped connection doesn’t stop running workflows. With several executors, Conductor detects an interrupted workflow and “recovers the workflow to another healthy executor.” Its dashboard can pause a workflow or restart one from a specific step. Connecting needs the enterprise package: pip install "dbos[enterprise]" in Python, @dbos-inc/dbos-enterprise in TypeScript.

The plans on dbos.dev:

  1. DBOS Pro, $99 a month: 2 seats, up to 3 apps, 1 million checkpoints a month, then $50 per million.
  2. DBOS Teams, $499 a month: 10 seats, 10 apps, 10 million checkpoints, then $40 per million.
  3. DBOS Enterprise, custom, with the “Option to self-host DBOS Conductor.”

A checkpoint counts workflows, steps, and transactions. Picture an agent turn as one workflow with 3 model calls and 4 tool calls as steps. That’s 8 checkpoints, so 10,000 turns a month is 80,000, well inside Pro.

Self-hosted Conductor “is released under a proprietary license and requires a license key.” You run three parts: the dbosdev/conductor image, the dbosdev/console image, and a Postgres database for Conductor itself. A trial key covers development, and “A license agreement is required for production use.”

DBOS Cloud is the hosting option, a “serverless platform for durably executed applications” where apps are “charged only for the CPU time they actually consume.” To use it, you contact sales.

What does Cadenya offer that DBOS doesn’t?

DBOS makes the loop you write durable, on the Postgres you run. Cadenya is the agent loop itself, hosted: approvals, conversation state, resume, and model swap come with it, and your code calls an API. Here’s what that covers:

  1. The agent loop, already written. Cadenya calls the model, runs the tools, records every event, and compacts the context window. On DBOS, that loop is the workflow you write and keep deterministic.
  2. One less database to run. Cadenya hosts the loop, its state, and its event log, and your app calls an API.
  3. Deploys without patches. An objective “keeps that variation’s configuration snapshot even if you edit the variation later.” So you edit prompts, tools, and models freely, with nothing to patch and nothing to drain.
  4. Approvals on any tool. Mark a tool as needing approval, and Cadenya “parks the Agent loop until it receives approval or a denial with optional steering.” Several tool calls can wait at once. A denial carries a memo the agent reads, such as “Use the read-only lookup tool instead.”
  5. Conversation state and resume. A Continue message resumes a waiting objective with its conversation intact. Stream events over server-sent events and resume from the last event ID, or receive them as Standard Webhooks.
  6. Model swap with no deploy. The model is a setting on an agent variation. Connect your own provider keys, pay the provider directly, and let weighted variations favor the one that scores well.
  7. Tools from what you already have. A tool set reads an OpenAPI 3 spec, an MCP server, HTTP endpoints you define, or Bare tools your app answers. A sandbox joins the same way, as the E2B guide shows.
  8. SDKs for TypeScript, Python, Ruby, and Go, all at 1.9.0 under Apache-2.0. The TypeScript SDK has shipped 113 versions.
  9. A price in one line. Free for 1,000 loops a month, $49 a month for 50,000, then $0.0015 a loop. A loop is one LLM request, so the turn above with 3 model calls is 3 loops.

Approve or deny tools walks through the approval flow, and the free plan needs no card.

No account yet? A coding agent can create a temporary workspace with cadenya workspaces create --temporary, run its first objectives there, and hand you a link to claim it, as auth.md explains. To create an account, sign up at app.cadenya.com/signup, then copy your API key from the API keys page at app.cadenya.com/account/apiKeys.

Grow wherever AI goes next.

Start shipping agents that are equipped to evolve.

A pine bonsai overlooking a mountain lake