Kitaru vs DBOS: Durable execution, shaped around Python agents

DBOS and Kitaru solve the same first-order problem. Code crashes, and you shouldn’t start over. Both are durable-runtime libraries, both are Apache-2.0, both are self-hostable, both do checkpoint, replay, and resume. The honest differences start further down the stack.

DBOS is a polyglot durable workflow library on Postgres. It was shaped for the workloads every backend team ships: order processing, payment sagas, document approval, transactional side effects. Workflow state sits alongside your OLTP data in the same database, and Conductor gives ops a UI for scheduled workflows and durable queues.

We built Kitaru around a different shape of work. An agent loop has expensive LLM calls, tool runs measured in minutes, humans approving drafts hours later, and artifact outputs you want to inspect after the fact. So we put those in the box: kitaru.llm() with alias-resolved secrets and per-checkpoint cost, wait() as a typed primitive, versioned artifact lineage across runs, and stack-based deploy to Kubernetes, SageMaker, Vertex AI, or AzureML without a rewrite.

What makes Kitaru unique

How the two surfaces map

from kitaru import flow, checkpoint, wait
import kitaru

@checkpoint
def research(topic: str) -> str:
  return kitaru.llm(
      prompt=f"Research: {topic}. Return a brief.",
      model="fast",
  )

@checkpoint
def draft(brief: str) -> str:
  return kitaru.llm(
      prompt=f"Write a draft from this brief:\n{brief}",
      model="claude-sonnet-4-6",
  )

@flow
def review_flow(topic: str) -> str:
  brief = research(topic)
  text = draft(brief)

  approved = wait(
      name="approve",
      schema=bool,
      question=f"Approve this draft?\n\n{text[:500]}",
  )
  return text if approved else "Rejected"

review_flow.run("Durable agents")

from dbos import DBOS
import openai

client = openai.OpenAI()

@DBOS.step()
def research(topic: str) -> str:
  resp = client.chat.completions.create(
      model="gpt-4o-mini",
      messages=[{"role": "user",
                 "content": f"Research: {topic}"}],
  )
  return resp.choices[0].message.content

@DBOS.step()
def draft(brief: str) -> str:
  resp = client.chat.completions.create(
      model="gpt-4o",
      messages=[{"role": "user",
                 "content": f"Write a draft:\n{brief}"}],
  )
  return resp.choices[0].message.content

@DBOS.workflow()
def review_flow(topic: str) -> str:
  brief = research(topic)
  text = draft(brief)

  # Human approval via DBOS.send / recv messaging.
  approved = DBOS.recv(timeout_seconds=86400)
  return text if approved else "Rejected"

# Plus: start the DBOS runtime, send approval
# from another process via DBOS.send.