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.

Diagram showing execution in a process sending spans and events through a one-way arrow to an observability backend marked read-only.Open full source frame
Execution state and read-only observability traces live in separate systems.

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.

0:000:10
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

0:00 · section reference included

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:

  1. Select a cohort of production runs—for example, runs that cost too much or took too long.
  2. Replay a specific change from saved state.
  3. Diff the new executions against their original baselines.
  4. 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.

2:032:26
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

2:03 · section reference included

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.

DoorDash slide with three columns: 302 sims in 5 minutes, 2 pts within target, and −90% hallucinations.Open full source frame
Tahir’s DoorDash slide reports 302 simulations in five minutes, two points within target, and 90% fewer hallucinations.
4:084:32
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

4:08 · section reference included

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.

5:035:17
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

5:03 · section reference included

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.

6:426:48
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

6:42 · section reference included

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:

ExecutionAccount chargeReview statusNext action
BaselineRestrictedneeds_reviewescalate_to_human
Model forkRestrictedneeds_reviewescalate_to_human
Policy forkRestrictedsafe_to_answeranswer_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.

Kitaru comparison page displaying three support_decision JSON artifacts; the first two show needs_review and escalate_to_human, while the third shows safe_to_answer and answer_directly.Open full source frame
Side-by-side support decisions show two needs_review results and one safe_to_answer result.

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.

8:579:18
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

8:57 · section reference included

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.

10:5411:11
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

10:54 · section reference included

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.

13:2113:37
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

13:21 · section reference included

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.

Slide headed “Wrap your agent. Start replaying.” with open-source and self-hosted text, github.com/zenml-io/kitaru, uv add kitaru, and a repository QR code.Open full source frame
Kitaru’s closing slide presents its repository and installation command.
15:1015:23
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

15:10 · section reference included

Resources

From the talk

  • The original introduction to flows, checkpoints, persisted artifacts and replay with cached earlier results.

Updates since the talk

Transcript download
Full transcript

Loading transcript…