Kitaru vs Restate: different layers, not competing runtimes

Restate is a serious durable runtime. Polyglot SDKs across TypeScript, Java, Kotlin, Go, Rust, and Python. 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 a strong, honest answer.

Kitaru isn’t a durable runtime at all. It answers a different question: once an agent run happened — durable or not — can you re-run it, and know whether a change made it better or worse? Kitaru records runs as sessions, through a framework adapter or by importing the traces you already collect, and replays them against your real code.

The two layers don’t compete. A Restate-run agent can still be wrapped by a Kitaru adapter, or have its traces imported — Restate keeps it alive in production, Kitaru tells you whether the next change to it is safe to ship.

What makes Kitaru unique

How the two surfaces map

from pydantic_ai import Agent
from kitaru_pydantic_ai import KitaruAgent

reviewer = KitaruAgent(
  Agent("openai:gpt-5.4", system_prompt="You're a compliance reviewer."),
  agent_id=AGENT_ID,
)

# Restate keeps this durable in production.
# Every run also lands as a Kitaru session.
result = reviewer.run_sync(case)

# Later: freeze the sessions that matter, test a change.
import kitaru

client = kitaru.KitaruClient()
cohort = client.cohorts.create("hard-cases", sessions=session_ids)
experiment = client.experiments.create(
  "cheaper-model",
  model="gpt-5-mini",
  tool_policy=History(scope="cohort", on_miss="fail"),
)

before = experiment.run(cohort=cohort, version="v1")
after = experiment.run(cohort=cohort, version="pr-311")
client.compare(before, after)

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.