Paper of the Week — Idempotency Is Not Recovery: A Fault-Injection Study of Language-Model Agent Tool Actions
Coding agents expose an overlooked trap: idempotency ≠ recovery, and retrying interrupted tool calls can silently corrupt state or miss actions entirely.
Idempotency Is Not Recovery: A Fault-Injection Study of Language-Model Agent Tool Actions
Song Xu. Published 2026-11-17. arXiv:2611.23353
One sentence summary
Interrupted tool calls in LLM agents create a hidden class of fault — partial execution without confirmation — that neither retry logic nor idempotency guards reliably catch.
Why this paper
As agentic coding frameworks mature, the gap between “the model picked the right tool” and “the action safely completed” is becoming a production reliability problem. With Claude Code, Muse Code, and similar autonomous agents now acting as primary actors on real systems, understanding failure modes at the tool-call boundary is urgent.
What they did
The authors built a controlled agent runtime combining authorization, tool execution, and an interruption harness, then injected faults at the point where a tool call is in-flight — after external state has changed but before the agent receives confirmation. They categorized outcomes across retry, skip, and assume-success recovery strategies to map which failure modes each approach exposes.
Key findings
- Retrying a non-idempotent interrupted call duplicated the action in a majority of tested scenarios — the most dangerous silent failure mode
- Assuming success after an interrupted call concealed genuine failures roughly as often as it correctly inferred completion
- Idempotent tool signatures did not prevent the issue: idempotency guarantees safe re-execution, not correct state inference after interruption
- The runtime’s authorization layer was insufficient — once a call was issued, no mechanism could determine whether the external system had acted
- A fail-closed admission gate (reject the step, surface ambiguity to the caller) was the only strategy that consistently prevented compounding downstream errors
Why it matters for practitioners
If you’re wrapping APIs — file writes, database mutations, payment calls, webhook dispatches — inside an agentic loop, an interrupted step leaves you in an ambiguous state that the agent’s retry and reflection logic is not equipped to resolve. This is especially sharp today because Claude Code Auto Mode and similar systems are running with minimal human checkpoints, meaning a duplicated mutation or silently skipped action can propagate several steps before anyone notices.
What you can use today
- Audit every tool in your agent’s toolkit for whether it is observably idempotent — meaning the agent can verify post-call state, not just re-invoke safely
- Add an explicit “confirm or surface ambiguity” step between any tool call that mutates external state and the next planning step; don’t let the model assume confirmation from silence
- For high-stakes actions, implement a fail-closed pattern: if the confirmation signal is missing, halt and return an ambiguity error to the orchestrator rather than proceeding or retrying blindly