AI Engineer World's Fair 2026
Your Agents Need a Save Button
Loading slides…
Read the talk
Your Agents Need a Save Button
Checkpointed execution lets you change a model or tool response, replay from that point, and compare outcomes before deciding whether a cheaper agent is worth shipping.
From a talk by Hamza Tahir
Before you start: Familiarity with tool-calling agents, execution traces, and basic Python will help you follow the replay examples.
Why did the agent do that?
Why did an agent make that decision? Would another model have reached the same result more cheaply? Would a different tool response have changed what happened next? These questions require more than an explanation of the completed run: they require a way to resume it under changed conditions. Hamza Tahir’s starting analogy is the familiar save button. Documents retain state as we work; an agent needs an equivalent checkpoint if we want to revisit a decision.
A trace records emitted telemetry: tool calls, inputs, outputs, and spans. But the trace alone does not necessarily retain the variables, files, executable code, and environment that produced those events. In Tahir’s framing, the missing connection is between observability spans and executable state. A read-only record in an observability backend can show what happened without providing what is needed to run the computation again.
Once that state is available, replay supports several distinct experiments:
- Model substitution: try a cheaper model and inspect its subsequent decisions.
- Tool substitution: override a tool’s return value to test a different policy or external response.
- Failure injection: deliberately degrade a tool response and observe how the agent handles bad information.
Each experiment needs a retained starting point so the changed execution can be compared with what originally happened.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Turn production checkpoints into evaluations
The architectural move is to put a durable runtime beneath the agent harness and connect its saved execution state to the traces. The harness still coordinates the agent; the runtime retains the material needed to resume its work. With automatic checkpoints during production execution, the system accumulates both the original behavior and starting points for later experiments.
Consider a support agent handling a chargeback dispute and a possible refund. A replay can test whether an order-status response in another language changes the outcome, whether the request should have escalated, or whether a smaller model could have handled it. Successive checkpoints act like autosave: the experiment can begin near the relevant decision instead of reconstructing the whole interaction.
That leads to an evaluation loop:
- Select a cohort of production runs—for example, runs that cost too much or took too long.
- Replay a specific change from saved state.
- Diff the new executions against their original baselines.
- Use the differences to decide what to route or ship.
The distinction matters: these are evaluations using production checkpoints, not merely a collection of production traces. The baseline tells you what happened; the checkpoint lets you test what could happen under an intervention.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Ground simulations in production behavior
Tahir introduces DoorDash as an example of using simulated customer conversations to test changes against production behavior. Its order-status validation compared 302 simulated conversations in five minutes with 175 production conversations collected over seven hours. Escalation rates were 46% in simulation and 44% in production—a two-percentage-point difference in escalation, not a measure of overall accuracy.
DoorDash separately reported 90% fewer hallucinations in simulations. These results concern its particular simulation system and validation exercise. Production-derived scenarios, simulated customers, and mocked dependencies can make experiments useful without establishing that the system restores runtime checkpoints or uses Kitaru. The relevant connection is grounding what-if experiments in interactions that have already occurred.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Inspect what a checkpoint retains
The live demonstration uses Kitaru, developed by ZenML, where Tahir identifies himself as a co-founder. In the demonstrated architecture, Kitaru supplies the runtime beneath the harness, connects execution to traces, and supports checkpoint-based replay. This is the earlier runtime workflow; the later product reorganized execution around sessions and Workers, so current commands should not be substituted for the recording’s interface.
The example application is a support agent that processes customer requests and escalates to a human when necessary. Its execution view shows tool calls and a timeline. Selecting a checkpoint exposes the configuration, code, and input/output artifacts associated with that step. Tahir also describes the execution environment, such as a Docker image or sandbox, as part of the saved context. That description should not be read as a guarantee of automatic capture of arbitrary process memory or every filesystem dependency; the concrete replay mechanism here depends on retained checkpoint results and executable context.
The timeline also exposes how long steps took, including the tool calls surrounding model requests. That gives the first experiment a precise target: pick a point in the support execution and ask whether a cheaper model would make the same subsequent decisions.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Change one part of the execution
For the first replay, Tahir selects an execution point, copies the replay invocation into his terminal, and changes the model to GPT-5 nano after a particular tool call. A new execution launches. The demonstrated fork skips its first three checkpoints because Kitaru already has their saved state, then resumes execution at the changed checkpoint. The unchanged prefix is reused; the suffix runs under the new model choice.
The result initially looks similar, so the next experiment changes a different variable. Tahir replaces the lookup-policy tool with another function in the codebase that returns a different policy, while holding the model constant. This separates the policy intervention from the model intervention: if downstream behavior changes, the comparison is no longer confounded by changing both at once.
A Python tool replacement can be a small function with the same calling contract as the original. For example, this policy override returns a modified copy while preserving fields outside the intervention:
python
from typing import Any
def lookup_policy_override(
original_policy: dict[str, Any],
) -> dict[str, Any]:
return {
**original_policy,
"requires_human_review": False,
}
The field here illustrates the substitution pattern rather than Kitaru’s CLI syntax or the demo’s exact policy schema. The replacement supplies a different tool result; the replay must still execute the agent’s downstream decision. Access to the code makes that intervention practical. In the demonstration, the second fork produces different logs and an altered artifact, leaving three executions to compare: the baseline, the model fork, and the policy fork.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Compare decisions, not just trace shapes
Kitaru’s diff command takes the original execution ID and the replay IDs, then produces a URL for a side-by-side comparison. The command emits some artifact warnings before the comparison page opens. In the execution view, the saved prefix remains identical across branches. The policy fork diverges at the changed tool call, with differences in subsequent execution and timing.
Opening the final support_decision artifacts makes the behavioral difference explicit:
| Execution | Account charge | Review status | Next action |
|---|---|---|---|
| Baseline | Restricted | needs_review | escalate_to_human |
| Model fork | Restricted | needs_review | escalate_to_human |
| Policy fork | Restricted | safe_to_answer | answer_directly |
All three retain the restriction, but the policy fork changes whether the agent should answer directly. That is a substantive decision difference even when the executions look broadly similar. Whether it is acceptable depends on the intended policy.
Tahir describes both replay forks as cheaper in input/output token cost, without giving exact savings. The comparison view supplies more detail for analysis, but a lower cost does not establish that a changed review decision is correct. Nor does this single support case establish that the model substitution is safe across other requests.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Apply the intervention across a cohort
The next step is to select a collection of runs, such as the most expensive support requests, and apply the same intervention across matching configurations. The demonstrated replay-many operation resumes each execution from a selected point and changes either the relevant tool behavior or the model. The output is a distribution of outcomes rather than one promising example.
Tahir does not execute the cohort replay live because it would take time. Instead, he opens an already emitted JSON report. At this scale, manually comparing every branch in the UI becomes cumbersome, so he asks an agent to analyze the report using the Kitaru MCP server and recommend what to do across the cohort.
The useful capability is not just summarizing a large JSON file. A queryable runtime lets the analysis agent inspect executions and retrieve artifacts when it needs evidence about a decision. Skills and MCP access become more valuable as the workload grows from a handful of comparisons to thousands. The analysis begins looking for problematic decisions and continues in the background while Tahir returns to the presentation.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
A cheaper request can still be a worse service
A model swap can make an individual execution much cheaper, but Tahir says naive substitutions often fail in his experience with customers. A support bot that spends less while leaving requests unresolved may miss the product’s actual objective. Cost is one dimension; the value of the completed work is another.
The Braintrust cost-efficiency study provides a useful framing for this trade-off: assess support policies under explicit tool, safety, and response-quality requirements. The false economy is accepting inadequate resolution quality because a policy looks fast and cheap. It does not require claiming that cheaper models always have a higher dollar cost per resolved request; the matching study’s cheap-only policies still report a lower cost on that measure. The release decision needs a quality threshold as well as a cost comparison.
Repeated reliability adds another dimension. In the original τ-bench paper, GPT-4o with function calling achieved 61.2% single-trial success on retail tasks, while retail success across all eight trials was below 25%. This is pass^8 reliability: success on every trial for a task, judged by the final database state. It is not textual self-consistency or a universal rule converting a roughly 60% pass rate into a quarter.
One replay is an anecdote. Cohort evaluation exposes variation across requests, while repeated trials expose instability on the same task. Both matter when deciding whether a change is dependable. Replaying large workloads can itself become expensive, so selection needs to be deliberate: spend evaluation effort on the populations and decisions that matter to the service.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
The cohort changes the release decision
An operational replay process starts with real production runs and checkpointed state. Build cohorts around expense, latency, or risk, rather than shipping after one or two favorable examples. The evidence should lead to a concrete decision: ship the change, route suitable requests to it, or hold it back. Automate as much of the loop as is useful, including agent-assisted analysis, while retaining a human at the final decision.
When Tahir returns to the completed cohort analysis, its recommendation is do not ship. The single model replay had appeared cheaper and reached a similar result, but the analysis across the demonstrated support cases recommends against using the cheaper model. That verdict applies to this cohort; another dataset could support a different decision. The demonstration does not provide a numerical failure breakdown, so the result is a cohort-specific recommendation rather than a general judgment about GPT-5 nano.
The architectural requirement is what makes that reversal discoverable: an agent harness backed by a runtime that can checkpoint state and replay it from code under changed scenarios. It lets the team test both alternate design choices and interventions in the agent’s behavior before deciding what belongs in production. Tahir closes by pointing to Kitaru’s repository and describing the tool as open source and free to use.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
Open-source agent replay and evaluation software, with setup instructions, examples and MCP integration.
A support-agent experiment comparing model selection, retries and escalation through resolution quality and cost per resolved request.
The original retail and airline benchmark, including repeated-trial reliability measured with pass^k.
Further reading
- Kitaru’s original launchArticle
The original introduction to flows, checkpoints, persisted artifacts and replay with cached earlier results.
Updates since the talk
Hamza Tahir’s August 2026 account of imported sessions, reviewed cohorts, evaluators and the new worker execution layer.
Full transcript
Loading transcript…