Kitaru and the Claude Agent SDK solve different problems. The Agent SDK builds agents that read files, run commands, and solve coding tasks in a session you kick off yourself. Kitaru is a replay-based eval layer: it records an agent’s runs as sessions, and a session re-executes — unchanged for a faithful baseline, or forked with one thing changed and compared.
There’s no shipped Claude Agent SDK adapter today. That’s an honest gap, not a missing checkbox — and it doesn’t block you. Import the traces you already collect, or wrap the SDK’s entrypoint yourself; either way the sessions replay and evaluate the same as a natively recorded one.
Use Kitaru if you are
- Already tracing Claude Agent SDK runs to Langfuse, LangSmith, Braintrust, or OTel — import them and they replay and evaluate like a recorded session
- Willing to wrap your own agent's entrypoint against Kitaru's recording API — the kitaru-adapter-builder skill builds the smallest adapter that works inside your project
- Running the agent inside a service you don't control, or in another language — register it as a function and let Kitaru call it
- Turning the sessions that caught a failure into a cohort that gates the next change
- Self-hosting eval infrastructure so traces and credentials stay in your own systems
Use the Claude Agent SDK if you are
- Building autonomous coding agents that edit files, run bash, and search codebases
- Running interactive sessions where you are at the keyboard to approve and guide
- Prototyping one-off tasks or short-lived workflows where you don't need a recorded session yet
- Wanting native, first-party recording without writing or importing anything — that needs a shipped adapter Kitaru doesn't have for this SDK yet
No adapter yet — import what you already have
There’s no kitaru-claude-agent-sdk package. If you already trace the SDK’s runs somewhere — Langfuse, LangSmith, Braintrust, or plain OTel — that’s the fastest path in: import the trace and it replays and evaluates exactly like a natively recorded session. You lose nothing by not having a first-class wrapper; you just start from the traces you already collect instead of a live one.
The Agent SDK’s own session history and file-edit rewinds (Write, Edit, NotebookEdit) are real and useful for interactive work. They’re not what Kitaru needs, though — importing doesn’t touch any of that. It reads whatever trace format you already export.
No agent code to change — build a project-local adapter, or don't
If wrapping the SDK’s entrypoint is on the table, a project-local adapter is ordinary code that calls Kitaru’s recording API — it’s not a privileged plugin, and there’s no requirement to contribute it upstream. The kitaru-adapter-builder agent skill builds the smallest one that works inside your project, in Python or TypeScript, and reports what it observed and what it couldn’t see.
If wrapping isn’t on the table — the agent runs behind a queue, inside a service you don’t own, or in another language — register the agent version as a function instead. Kitaru calls your function, your function runs the agent however it already runs, and it hands back the external id of the session it produced. Kitaru creates a placeholder session that adopts the real content once you import it.
What a session actually gets you
An imported or adapter-recorded session isn’t just a copy of a trace — it’s something you can replay. Fork it with a different model or prompt, and the replay reproduces the original when nothing changed, which is the faithful baseline that makes a diff trustworthy.
Freeze the sessions that matter into a cohort, and evaluators — deterministic checks first, a model-graded check for the residue — score both sides of an experiment. The Agent SDK’s OTel traces and per-session logs are real observability for interactive work; Kitaru is where those same runs, imported or wrapped, become something you can run again.
What makes Kitaru unique
| Feature | Kitaru | Claude Agent SDK | What that means |
|---|---|---|---|
| Interactive coding agent UX | Not supported | Yes | Claude's Read/Edit/Bash/WebSearch toolkit is best-in-class. Kitaru doesn't replace it. |
| Import traces from Langfuse / LangSmith / Braintrust / OTel | Yes | Not supported | An imported session replays and evaluates exactly like a recorded one — no adapter needed. |
| Project-local adapter via the recording API | Yes | Not supported | Ordinary code you own. The kitaru-adapter-builder skill builds the smallest one that fits your project. |
| Function agents (Kitaru calls your system) | Yes | Not supported | For agents behind a queue, another language, or a service you don't control. |
| Replay: fork a session, one thing changed | Yes | Not supported | Unchanged, a replay reproduces the original — the faithful baseline that makes a diff trustworthy. |
| Cohorts and experiments (same population, one variable moved) | Yes | Not supported | |
| Observability and log inspection | Yes | Yes | SDK: OTel traces + per-session logs. Kitaru: a replayable, diffable session built from those same traces. |
| Self-hosted, Apache 2.0 | Yes | Not supported |
Code comparison
# However the session got here — imported from your existing
# traces, or recorded by a project-local adapter — it replays
# and evaluates the same way.
import kitaru
client = kitaru.KitaruClient()
cohort = client.cohorts.create("hard-cases", sessions=session_ids)
experiment = client.experiments.create(
"cheap-model",
model="claude-sonnet-5",
)
before = experiment.run(cohort=cohort, version="v1")
after = experiment.run(cohort=cohort, version="pr-311")
client.compare(before, after)import asyncio
from claude_agent_sdk import query, ClaudeAgentOptions, ResultMessage
async def review(topic: str) -> str:
result_text = ""
async for msg in query(
prompt=f"Draft a short blog post on: {topic}",
options=ClaudeAgentOptions(allowed_tools=["Read"]),
):
if isinstance(msg, ResultMessage):
result_text = msg.result or ""
return result_text
asyncio.run(review("Durable agents"))
# One session history on disk. Useful for this run —
# not something you can replay with the model swapped.Put replay-based evals beside your Agent SDK
If you are running agents locally or in short interactive sessions, stick with what you have. If you are taking an Agent SDK build to production and want its runs turned into something you can test against, import the traces you already have or wrap the entrypoint yourself — either way, Kitaru is where those runs become replayable evals.
uv add "kitaru[cli,worker]" kitaru-pydantic-ai