Checkpoints for Long-Running AI Agents: Resume From Verified State
A how-to for checkpointing multi-day AI agent work in a harness, so a stronger successor resumes from verified state instead of restarting from zero.

To checkpoint a long-running AI agent, have the harness write a structured record outside the model: the goal and its acceptance test, the completed steps with evidence, the open items, and every external action already taken. A successor should resume from that record only after checking its verified entries against the live systems. Done this way, a more capable model continues at the last verified step instead of repeating days of work or trusting the previous agent's own summary.
Key takeaways
- A checkpoint is a record a successor can verify, not a summary the agent wrote about its own progress.
- Store the goal, completed steps, evidence, open items and side effects in a store the harness owns, outside the model's context.
- Record outcomes read from tools and systems of record, and mark anything the agent only asserted as unverified.
- Give every external action a key or a recorded intent so a retry cannot repeat a payment, message or deletion.
- Let a successor resume only after it checks the checkpoint against live systems and approval boundaries still hold.
What a checkpoint has to contain
A multi-day task produces far more state than a chat transcript can hold reliably. A useful checkpoint answers five questions: what the goal is and how success will be tested, which steps are complete, what evidence shows each one is complete, what remains open, and which external actions have already happened. If any of those answers lives only in the conversation, the successor has to reconstruct it, and reconstruction is where long tasks drift.
Keep the record in files or a database that the harness controls, not in the model's memory. Model memory is tied to a session and often to a specific model version, while the harness record survives a model swap. That matters because a common reason to checkpoint is to hand the work to a stronger model later. The difference between memory and history is covered in AI memory vs chat history.
Separate verified state from claims
An agent that says 'the import is finished' has made a claim. The checkpoint should store that claim next to the evidence for it: a row count read back from the destination, a hash of the output file, or a status returned by the system of record. A claim without evidence is marked unverified, and the successor treats unverified items as work to re-check rather than as facts to repeat.
In practice, each entry in the record should fall into one of these groups:
- Reads from a system of record, with the identifier and the value returned.
- Results of validation scripts or tests, stored as results rather than as prose.
- Human approvals, with the approver, the scope approved and the action it covers.
- Agent statements, stored as unverified until a check confirms them.
This structure also makes review faster. A reviewer can see at a glance which parts of the work are proven and which are still assertions.
How to write a checkpoint, step by step
Write the checkpoint as the work happens, not at the end of the session. The following sequence works for most harnesses:
- Freeze the goal and the acceptance test in the record before the first step runs.
- After each step that changes external state or produces evidence, write the output and its evidence in the same operation.
- Record each external action with its identifier and whether it can be safely repeated.
- Write open items as specific next actions, each listing the input it needs and the approval it requires, if any.
- Save each checkpoint in a versioned location and note which harness version and model produced it.
- Before a session ends or pauses, read the checkpoint back and confirm it still matches the current state of the systems it describes.
The last step is the one most often skipped. A checkpoint that was never read back is a guess about what was saved.
Illustrative scenario: a three-day invoice reconciliation
Illustrative scenario: a finance operations team asks an agent to match supplier invoices against received goods over several days. On the first day, the agent exports the open invoices and writes a checkpoint with the export identifier and the invoice set, verified by a count read back from the export file. On the second day, it matches part of the set and flags mismatches. Its checkpoint lists each matched invoice with the matching rule version, and each flagged invoice with the reason. The session then stops at its usage limit, and the harness writes the checkpoint at the stop rather than losing the last hour of work.
On the third day, a stronger model takes over. It reads the checkpoint first, re-queries the open invoices, confirms the export still matches the stored count, and continues from the first unmatched item. It does not re-export or re-match invoices that the record shows as verified. A reviewer can see exactly where the handoff happened and why.
Make external actions safe to resume
The riskiest part of resuming is rarely the reasoning. It is side effects. If the previous session sent a supplier email or created a payment before it stopped, a successor that replays its plan may repeat that action. The standard protection is idempotency: each request carries a unique key so the provider returns the original result instead of executing twice. Stripe documents this pattern in its [idempotent requests guide](https://docs.stripe.com/api/idempotent_requests), and the same discipline applies to any tool, including those without a native key.
For tools without that feature, the harness can apply the pattern itself:
- Record the intent to call the tool before the call, so a crash in between is detectable.
- Derive the action key from the checkpoint identifier and the step, so the same step always produces the same key.
- On resume, look up the action in the record before any retry.
Session limits are the other half of this. Token and step budgets with alerts make a run stop at a predictable point, which gives the harness a clean moment to write the checkpoint.
How a managed setup keeps checkpoints current
Be Human treats checkpoints as part of the harness rather than an add-on. In an engagement, the useful role, its memory, tools and approval boundaries are defined first, and the checkpoint structure is written to match them. Managed operations then keep the record working over time: monitoring flags sessions that end without a read-back checkpoint, permission review confirms that a resumed session still holds only the access its role needs, and controlled improvements change the checkpoint format through versioned releases so older records remain readable.
Deciding when a successor may resume
Resumption should pass through a gate. Before the successor continues, the harness should confirm that the checkpoint has not changed since it was written, re-read the systems of record behind every verified item the next steps depend on, and check that the acceptance test still applies. Anything that fails moves back to unverified. Consequential actions such as payments, customer messages or deletions still need the approval named in the boundary, even if the earlier session held one, because the scope may have changed while the work was paused.
For a broader standard of what counts as finished, see a definition of done for AI agents, and for tracking how the harness itself changes between sessions, see AI harness versioning.
The free Be Human AI diagnostic can help you find the first task worth handing to an agent.
Frequently asked questions
How often should an agent write a checkpoint? Write one after every step that changes external state or produces evidence, and again at every natural stop, such as a usage limit or a pending approval. Waiting until the end of a session means a crash erases that session's work. Frequent small writes cost little compared with re-deriving a day of results.
Can a more capable model resume without a checkpoint? It can re-derive some state from the systems it can reach, but it cannot know which external actions already happened unless the record says so. A stronger model may also choose a different plan, which makes earlier decisions hard to audit. A checkpoint makes the handoff explicit and reviewable.
What is the difference between a checkpoint and a log? A log records everything that happened, in order, which is useful for investigation and incident review. A checkpoint records the current verified state and what remains, which is what a successor needs in order to continue. Keep both, and treat the log as observability data, as described in the [OpenTelemetry observability primer](https://opentelemetry.io/docs/concepts/observability-primer/).
Does checkpointing replace human review? No. Checkpoints make review practical by showing what was verified and what was only claimed. Approval boundaries still decide which actions need a person, and reviewers should focus on open items and unverified entries rather than rereading the full transcript.
Your next step
See where an AI agent fits in your company first.
Take the free Be Human AI diagnostic. A few questions about your work show which task to hand to an agent first, what it needs to know and where a person approves.
Be Human editorial guidance. Examples are illustrative unless explicitly attributed. Sources provide background; implementation choices depend on your workflow.


