Skip to main content
AIDiveForge AIDiveForge

Kitaru

FreemiumOpen SourceAPISelf-HostedAgentic

Running a model swap or testing a failure path means re-hitting production infrastructure, paying full API costs, and hoping the environment stays stable enough to mean something — Kitaru exists because that loop is broken.

$39/month · Free tier: Self-hosted, import and record without limits, cohorts, evaluators and experiment runs, replay on your own workers with your own keys, community support · Checked Oct 20, 2026

Similar tools

Get This Tool

License: Apache-2.0 Any use incl. commercial
Local-run terms: Self-host on own infrastructure; full source available under Apache 2.0 for commercial use.

Summary

Kitaru wraps your existing agent SDK — PydanticAI, OpenAI Agents, Claude Agent SDK, or raw Python — and turns every model call, tool call, and intermediate step into a durable checkpoint. When you want to ask what would have happened with a cheaper model or a failed retriever, you replay from a specific checkpoint with one override. Nothing re-executes in production. The vendor's own benchmark shows 200 replayed executions on a cheaper model matching outputs in 192 of 200 cases at 84% lower cost. The ceiling appears when your agent's behavior depends on state that Kitaru's adapter doesn't intercept — external side effects or SDK internals the wrapper never sees won't be faithfully replayed.

Bottom line: Pick Kitaru when you need to validate a model downgrade or simulate tool failures against real prior runs without burning production budget — but if your agent relies on side effects or SDK internals outside the adapter's interception surface, your replays will diverge and the what-if stops being trustworthy.

Hosted & API Pricing

The model is free to self-host. These are the creator's hosted/API options.

Cloud SaaS

via Kitaru SaaS
$39per month

Managed control plane on Kitaru SaaS infrastructure

  • Hosted dashboard and control plane
  • 3 agents
  • 2 seats
  • 90-day session retention

Pricing may have changed since last verified. Check the official site for current plans.

Pricing Plans

Flat RateLast verified 1 day ago
Price
$39/month
Free Tier
Self-hosted, import and record without limits, cohorts, evaluators and experiment runs, replay on your own workers with your own keys, community support

Open Source

Free

For individuals and small teams. Self-hosted on your infrastructure with your limits.

  • Import and record without limits
  • Cohorts, evaluators and experiment runs
  • Replay on your own workers, with your own keys
  • Community support
  • 14-day free trial with full access, no credit card required

Cloud SaaS

$39per month

For teams shipping agents to customers. $39/month with 3 agents, 2 seats, 90-day session retention.

  • Everything in Open Source, plus
  • Hosted dashboard and control plane
  • Replays and experiment runs included, no meters
  • 3 agents
  • 2 seats
  • 90-day session retention
  • Community support

Enterprise SaaS

Custom

For organizations at scale. Custom pricing with unlimited agents and custom seats and retention.

  • Everything in Cloud, plus
  • SSO (SAML / OIDC)
  • Audit logs
  • Remote worker pools
  • Custom limits and retention
  • Unlimited agents
  • Custom seats
  • Dedicated support + SLA

View full pricing on kitaru.ai →

Pricing may have changed since last verified. Check the official site for current plans.

Find your fit

Before you choose Kitaru

More options in Agent Frameworks. Compare pricing, platforms, and features side by side.

Browse Agent Frameworks

Pros

  • Replay from any named checkpoint with a single model or override argument, so testing a cheaper model against 200 real prior executions costs a fraction of re-running them live — the vendor reports 84% cost reduction in their own benchmark.
  • Adapter-based instrumentation wraps the runner objects you already call (OpenAI Agents, Claude Agent SDK, PydanticAI, raw Python), so you are not rewriting agent logic to get checkpointing — the diff between instrumented and uninstrumented code is a class swap.
  • Tool failure simulation via override parameters (`lookup_mode=timeout`, `overrides={checkpoint.lookup_order: stale_order}`) means you can reproduce edge cases that only appeared in one production run without manufacturing a synthetic fixture that may not match real call structure.
  • Durable checkpoints support human approval gates mid-execution, so a compliance or review step can pause the agent at a named checkpoint and wait for a sign-off before continuing — without rebuilding the agent's control flow.
  • Apache 2.0 open source with a self-hosted path, so the checkpoint store and replay engine stay inside your infrastructure boundary — no production trace data leaves your environment unless you opt into ZenML Pro.

Cons

  • Replay fidelity breaks when agent behavior depends on state the adapter never intercepted — external database reads that changed between the original run and the replay, webhook side effects, or SDK internals the wrapper sits outside of will produce divergent results, and the what-if conclusion becomes unreliable. Teams working around this add manual checkpointing at additional call sites, which means maintaining instrumentation that grows with the agent's surface area.
  • Adapter coverage is scoped to PydanticAI, OpenAI Agents SDK, Claude Agent SDK, and raw Python — teams running other frameworks or heavily customized SDK forks have no adapter and must write their own wrapper against Kitaru's primitives, which the docs describe as 'agent runtime primitives and APIs' without a pre-built path. Teams on LangChain or LlamaIndex agent stacks have no drop-in adapter and will evaluate alternatives that instrument at the framework level.
  • The replay model assumes the original run was fully checkpointed — if an agent crashed before a checkpoint was written, there is nothing to replay from. Recovery from mid-run crashes depends on checkpoint granularity configured at instrumentation time, not retroactively. Teams that instrument coarsely discover this the first time they need to replay a run that ended partway through a tool chain.

About

Platforms
Python, self-hosted cloud
API Available
Yes
Self-Hosted
Yes
Last Updated
July 7, 2026

Best For

Who it's for

  • Teams running production AI agents who need replay-based experimentation
  • Developers using PydanticAI, OpenAI Agents, or Claude SDKs
  • Users requiring self-hosted durable execution for agents

What it does well

  • Test cheaper models on real agent executions without production impact
  • Simulate tool failures or degraded retriever results via overrides
  • Compare model swaps or input changes across a cohort of prior runs
  • Recover from crashes or insert human approval via durable checkpoints

Integrations

PydanticAIOpenAI Agents SDKClaude Agent SDKZenML

Frequently Asked Questions

Is Kitaru free?
Kitaru offers a free option alongside paid upgrades. Pricing: $39/month. Check the current allowances and terms before choosing a plan.
Is Kitaru open source?
Yes. Kitaru is open source.
Does Kitaru have an API?
Yes. Kitaru exposes a developer API. See the official documentation at https://kitaru.ai for details.
Can I self-host Kitaru?
Yes. Kitaru supports self-hosting on your own infrastructure.
What platforms does Kitaru support?
Kitaru is available on: Python, self-hosted cloud.

Most teams testing a cheaper model or a degraded retriever have two bad options: re-run in production and pay the cost and the risk, or write synthetic test cases that never quite match reality. Kitaru takes a third path — it wraps the calls and steps your agent SDK already exposes and stores them as replayable checkpoints, so a replay is reading back a faithful record of what actually happened, not reconstructing it from scratch. The core workflow is three lines: instrument your agent with a Kitaru adapter, run it in production, then call `client.executions.replay()` with an execution ID and a single override — a different model, a mocked tool return, a degraded retriever result, or a dropped reranker.

The differentiating mechanic is durable execution scoped to agent runs. Kitaru’s adapters for OpenAI Agents SDK and Claude Agent SDK are thin wrappers around the runner objects you already use — `KitaruRunner` replaces `Runner`, `KitaruClaudeRunner` replaces the direct `query` call. The checkpointing strategy is configurable at the call level. Replay reads those checkpoints back, so the what-if reflects the actual model and tool call sequence from the original run, not a re-execution under different conditions.

Kitaru fits teams running agents in production who need an experimentation layer without a separate staging environment or synthetic fixtures. It is open source under Apache 2.0 and self-hosted, with ZenML Pro available separately as a managed control plane. Where it breaks: if your agent’s correctness depends on state that the adapter never intercepts — database writes, external webhook calls, or SDK internals the wrapper sits outside of — replay diverges from reality and the experiment loses its value. Teams hitting that boundary either instrument more aggressively at the SDK level or accept that some failure modes require production reruns regardless.

Share This Tool

Compare This Tool
Contribute