Kitaru vs Restate: Durable execution, shaped for Python agents

Restate is a serious durable runtime. Polyglot SDKs across TypeScript, Java, Kotlin, Go, Rust, and Python. BSL 1.1 runtime license, with Apache 2.0 as the change license after the change date. Three handler shapes (services, Virtual Objects with keyed per-entity state and strongly-consistent access, and workflows), journaled execution, awakeables for human-in-the-loop, OpenTelemetry tracing, self-hostable on every major cloud. If your durability problem is polyglot and backend-services-shaped, Restate is the pragmatic answer. That’s the honest thing to say up front.

Kitaru is narrower on purpose. We built it for Python agents, because that’s the workload most teams we talk to are trying to ship right now. Today, it’s increasingly obvious that every company running agents in production needs the same capabilities: a durable llm() call, wait/resume, typed versioned memory, artifact lineage across runs, human/agent approval gates, and a runtime that understands the cloud underneath it. Those don’t come in the box with any general-purpose durable runtime. So we put them there.

What makes Kitaru unique

How the two surfaces map

import kitaru
from kitaru import checkpoint, flow

@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="fast",
  )

@flow
def review_flow(topic: str) -> str:
  brief = research(topic)
  text = draft(brief)
  approved = kitaru.wait(
      name="approve_draft",
      question="Approve draft?",
      schema=bool,
  )
  return text if approved else "Rejected"

review_flow.run("Durable agents")

import restate

review = restate.Workflow("ReviewWorkflow")

@review.main()
async def run(ctx: restate.WorkflowContext, topic: str) -> str:
  # Journaled step. Non-deterministic work lives inside ctx.run().
  brief = await ctx.run(
      "research",
      lambda: call_llm(f"Research: {topic}"),
  )
  text = await ctx.run(
      "draft",
      lambda: call_llm(f"Draft: {brief}"),
  )

  # Awakeable: durable promise resolved by an external caller.
  approval_id, approval = ctx.awakeable()
  send_approval_link(approval_id, text)
  approved = await approval
  return text if approved else "Rejected"

app = restate.app([review])

# Register the workflow with restate-server, deploy the handler,
# and resolve the awakeable from wherever approvals come in.