AI Infrastructure
Agent Checkpoints: Which Task Runs Again After Resume?
In fictional case CK64, resumption reuses task A's retained successful return RA and executes unfinished task B's body again. The entrypoint E begins again. B's earlier external operation OB is resolved by independently supplied receipt RB and a still-valid recognition contract. Those external records explain why this repeat adds no OB effect; the workflow checkpoint alone cannot establish that conclusion.
The Functional API restarts the entrypoint and looks up retained results
This explanation selects the historical LangGraph 1.0.0 Functional API at commit c4144bb48f97e6afeaa002de318580cc41c19893. The official 1.0.0 release links that commit. Other releases and APIs require their own applicable evidence.
The entrypoint is the workflow's starting function. Distinguish reaching a task call from executing the task's function body. A call can obtain an already saved return without another body invocation.
The durable-execution guide places Functional API resumption at the entrypoint's beginning, rather than the stopped line. The Functional API guide describes retrieval along the recorded sequence, requires JSON-serializable task outputs and entrypoint inputs/outputs, and says a task that started without finishing successfully runs again on resumption.
The following case supplies the actual retained history needed to apply those rules. It concerns sequential task calls inside one entrypoint; no StateGraph node, superstep or subgraph behavior is assigned to it.
References: [LG-RELEASE][LG-DURABLE][LG-FUNCTIONAL]
CK64: A's retained return and B's external receipt describe different events
CK64 is an original fictional documentary case. Every identity, receipt, retention record and eventual completion below is a supplied premise. No framework, model or external service was executed.
Fix entrypoint E in run R and thread T. E calls A, obtains its result, then calls B. The same interrupted run is resumed once with unchanged code, task order, inputs and matching history. There is no concurrent branch, intervening retry or new run. Entrypoint inputs/outputs and task returns are JSON-serializable.
On the first pass, A invokes external operation OA. Its completion acknowledgement is RA. A successfully returns that serializable result, and the successful task result RA is actually retained by the persistent checkpointer across the interruption.
B then invokes external operation OB. Independent external evidence supplies receipt RB establishing that OB completed. B fails before successful completion and before a successful task return is recorded. At interruption, A and B have each had one body invocation, but only A has a reusable successful result.
A separate premise belongs to the external service: repeating OB with the same operation identity, scope and parameters, within the still-valid recognition period, returns existing RB without an additional OB effect. That behavior is stipulated independently of LangGraph.
Resume E: reuse A's RA and execute B's body again
E begins again and encounters A in the unchanged history. The retained match supplies RA. No new A body invocation occurs, so this resumption makes no new OA call through A.
Next E encounters B. RB is external evidence, not a retained successful B task return. It cannot fill B's missing runtime record. B's body executes again.
During that invocation, B repeats OB under the independently stipulated recognition contract and receives existing RB. This repeat adds no OB effect. B now finishes successfully, and its serializable return is actually retained. Successful completion of E is separately supplied as a final premise.
Across the first pass and this one resumption, A's body has executed once and B's twice. The completed account contains acknowledgements for both intended external operations, B's later retained successful return and E's completion. It resolves this finite execution history.
References: [LG-DURABLE]
Scroll the table horizontally on smaller screens.
| Task | Body invocations before interruption | New body invocations on resume | Result supplied on resume | Source |
|---|---|---|---|---|
| A | 1 | 0 | Matching retained successful return RA. | Planning analysis |
| B | 1 | 1 | A new successful B return, after receiving existing RB; that return is then retained. | Planning analysis |
Original fictional history. RB already exists before resumption. The external service's separately supplied recognition contract accounts for the repeated OB request.
Why OB can be complete while B still needs to execute
CK64 places the failure between two different events: OB has completed at the external service, while B has not completed at the workflow boundary. A description that calls both events done loses the distinction that determines resumption.
Before resumption, RB already has a useful positive meaning: it establishes OB's completed external operation in the supplied history. The recognition contract adds the necessary fact about what the repeated request will do. After resumption, B's newly retained return answers a further question: this task has now finished successfully and its result has been retained. E's separate completion premise closes the entrypoint account.
Checkpointing B has not made OB and B's return one atomic commit. No cross-system transaction is supplied. The original failure demonstrates the gap: the external acknowledgement exists while the successful task return does not.
The no-additional-effect conclusion concerns OB under its stated contract. Neither one receipt per intended operation nor the body-invocation totals count every incidental log entry, file write or other surrounding effect.
Remove a record and preserve the resulting uncertainty
First remove the independent evidence for OB's completion and the service's recognition of its repeat while keeping the runtime history fixed. A still reuses RA and B still executes again. Whether that repeated B invocation adds an external effect is unknown. Assigning zero or one additional OB effect would insert the missing fact. An old receipt without evidence covering the repeated request's identity, scope, parameters and recognition period cannot supply the complete case.
Now instead remove proof that RA was actually retained across the interruption. A's reuse is unsupported. An A-start log establishes a start; it does not establish successful completion or retained RA. A checkpoint label or a selected durability mode cannot replace that missing record.
Changing the code, task order, inputs, run/thread or matching history creates a different question outside CK64. Its unchanged sequence and retained-result premises are material to the conclusion.
Even in the complete case, cached RA remains a past task return. If it acknowledged creation of an external object earlier, it would not establish that the object still exists unchanged now. Current object state needs its own evidence.
Choose the explanation that accounts for both task selection and external completion
An offer claiming that a checkpoint prevents every earlier task body from ever running again fails CK64: B executes twice. An offer saying E continues at the stopped line also gives the wrong account.
A sufficient response identifies A's retained successful result, B's missing successful result and the same-run matching history. It then identifies independent RB evidence and the contract covering the repeated OB request. Finally, it accounts for the later retained B return and E's separately supplied completion. That response answers which body executes and how the external operation is resolved.
Ask the appointed platform and application owners to connect those records to the same identities and observation boundary. A response supplying only RB leaves task-result selection unanswered. A response supplying only workflow history leaves OB's external outcome unanswered. Both can be valuable evidence within their respective scopes.
This finite account supplies no deadline, downtime, resource-release, useful-output or broader recovery result. It establishes no universal exactly-once or agent-platform guarantee. Actual workflow design, deployment, persistence and external-operation acceptance belong to the appointed software and application teams.
Connect an independently required equipment package to physical preparation
If the wider project independently requires approved equipment receiving, preparation or rack assembly, Leviathan's Rack Assembly & Preparation service and related project inquiry provide the physical scoping route. Share a nonconfidential equipment and configuration summary, proposed location, permitted physical tasks and required handoff to discuss scope, resources and availability.
The inquiry concerns that physical package. Agent hosting, integration, training, platform operation, software testing and workflow recovery administration remain with separately appointed providers.
Primary sources
- [LG-RELEASE] LangGraph 1.0.0 — official historical releaseChecked 2026-10-22. Identifies the selected release and its c4144bb commit; it is not a claim about the latest release or an installed deployment.
- [LG-DURABLE] LangGraph 1.0.0 — Durable ExecutionChecked 2026-10-22. Requirements, Determinism and Consistent Replay, and Starting Points for Resuming Workflows. The selected case uses the Functional API and expressly supplied retained history.
- [LG-FUNCTIONAL] LangGraph 1.0.0 — Functional API conceptsChecked 2026-10-22. Example explanation, Task, Serialization, Determinism and Idempotency. Supports recorded-result lookup and unfinished-task re-execution; CK64's external receipt and recognition behavior are separate premises.