Choose an Adapter

Pick the Kitaru integration path for your existing agent harness

An adapter wraps an existing agent harness so each model call and tool call lands as a Kitaru checkpoint, with no rewrite of your agent. The boundary you pick decides how fine-grained your checkpoints are, which in turn sets how precisely you can replay: per-call checkpoints let you reproduce a run and replay it from the exact call you changed, while a single coarse checkpoint only lets you replay the whole turn. Pick the boundary that matches the code you already have, then go as granular as your replay needs require.

Decision table

The replay boundary column is the unit you can replay from: a finer boundary means flow.replay(exec_id, at="<checkpoint>", ...) can re-execute from a single model or tool call instead of re-running the entire turn.

You have...	Use this	Replay boundary (finest available)	First page
Plain Python functions	@flow + @checkpoint	Your function boundaries — you choose them	Quickstart
PydanticAI agent	KitaruAgent	Per model/tool/MCP call by default, or one turn checkpoint	PydanticAI Adapter
OpenAI Agents SDK agent	KitaruRunner	Per call, or one runner-call checkpoint	OpenAI Agents Adapter
Claude Agent SDK invocation	KitaruClaudeRunner	One completed Claude invocation	Claude Agent SDK Adapter
LangGraph graph	KitaruGraphRunner	One graph call, or middleware-wrapped model/tool calls	LangGraph Adapter

Per-call checkpointing is fullest in the PydanticAI (KitaruAgent) and OpenAI Agents SDK (KitaruRunner) adapters. Both can record every model and tool call as its own checkpoint, so replay can target an individual call. The Claude Agent SDK adapter currently checkpoints at the invocation boundary, and LangGraph's per-call granularity depends on middleware wrapping the model/tool calls. If call-level replay fidelity is your priority, prefer PydanticAI or OpenAI calls mode.

Pick by goal

I want the simplest durable boundary

Wrap phases of work in @checkpoint and keep your existing Python control flow

I want granular agent observability

Use PydanticAI or OpenAI calls mode so model and tool calls become visible replay units

I want a clean return value from flow.wait()

Use a coarse runner-call or turn checkpoint around the whole agent turn

I need human approval

Keep wait/approval bridges at flow scope so the execution can suspend safely

Strategy notes

Strategy	Best for	Trade-off
Coarse checkpoint	Fast migration, clean .wait() return value, low adapter complexity	Replay can only re-run the whole turn — you cannot replay from a single call
Granular (per-call) checkpoints	Expensive LLM/tool chains where you want to replay from one call with one input changed	More checkpoint rows and stricter rules around waits/nesting
Explicit raw checkpoints	Maximum control and framework independence	You decide every durable boundary yourself

Human-in-the-loop rule

kitaru.wait() belongs at flow scope, not inside a normal checkpoint body. If your harness adapter creates granular tool checkpoints, configure wait-bearing tools so the adapter keeps that wait outside the synthetic checkpoint wrapper.

Start with:

• Wait, Input, and Resume
• PydanticAI human-in-the-loop tools
• OpenAI approval interruptions
• LangGraph interrupt and resume

Next

Run a small adapter example from Examples before porting a production agent. The fastest useful proof is one completed execution where you can see the expected checkpoint shape.