Kitaru vs Inngest: durable execution and replay-based evals, composed

Inngest and Kitaru solve different problems at different layers. Inngest is a durable execution platform: one engine takes your TypeScript, Python, or Go function, wraps it in retries and step memoization, and gives you the flow-control surface (concurrency, throttling, rate limiting, debounce, batching, prioritization) that most workflow engines leave you to wire up yourself. Add managed Inngest Cloud with SOC 2 Type II, enterprise SAML, HIPAA BAA available, and a single-binary self-host path, and you can see why a lot of teams on Vercel or Lambda picked it. If your durability problem is shaped like an event-driven app, Inngest is the pragmatic answer.

Kitaru doesn’t run your workloads at all — it’s a replay-based eval layer. It records a production run as a session — every model call, tool call, decision — and a session re-executes: unchanged, it reproduces the original as a faithful baseline; forked, it re-runs with one thing changed. Agents running on Inngest are no exception. Wrap them with a first-class adapter (Pydantic AI, OpenAI Agents SDK, LangGraph, Mastra, Vercel AI SDK), or import the traces you already collect in Langfuse, LangSmith, Braintrust, or OTel, and every run becomes a session you can replay.

What makes Kitaru unique

How the two surfaces map

from pydantic_ai import Agent
from kitaru_pydantic_ai import KitaruAgent

agent = Agent("openai:gpt-5.4", name="support-agent",
            system_prompt="You resolve support tickets.")

support = KitaruAgent(agent, agent_id=AGENT_ID)

# Runs inside your Inngest step exactly as before —
# and lands as a session.
result = support.run_sync(ticket_text)

# 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("cheap-model", model="gpt-5-mini")

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

import inngest

inngest_client = inngest.Inngest(app_id="agent-app")

async def call_llm(prompt: str) -> str:
  ...

@inngest_client.create_function(
  fn_id="support-flow",
  trigger=inngest.TriggerEvent(event="ticket.created"),
)
async def support_flow(ctx: inngest.Context) -> str:
  ticket = ctx.event.data["ticket"]

  async def triage() -> str:
      return await call_llm(f"Triage: {ticket}")

  result = await ctx.step.run("triage", triage)
  return result

# Trigger:  await inngest_client.send(
#     inngest.Event(name="ticket.created", data={"ticket": "..."}))
# Functions register with the Inngest engine; events route through it.