AI Execution Governance, Part 13: The Key Protects the Call, Not the Money A developer building a runtime for AI agents that take real write actions in enterprise systems described how its idempotency key protects the call, not the money. The key, a hash of user, conversation, tool and arguments, is enforced by a partial unique index in the database so concurrent duplicate calls are refused, but it only holds during the unknown window and breaks if any argument character changes. The developer argued that protecting a resource like a $100 payment would require a key minted by the party holding the balance, one key per resource, a key that outlives the resource, and coverage of every path that can touch the money. We build a runtime that lets AI agents take real write actions inside enterprise systems: create a record, send a payment. Every action carries permissions, approvals and a record someone can review afterwards. Before anything goes out, we take a local hold whose name is the idempotency key — the same call arriving twice is refused by it. This piece is about what that hold actually protects, and about the place a reader found where it protects nothing. A $100 payment times out. The request may have reached the bank, or it may not have. The claim sits at claimed , outcome unknown. An operator watches it for a while, decides to stop handling it, and closes the case. What happens next is less than most people expect: the disposition changes, the status stays unknown, the key stays occupied, and nothing moves at the target. The reader's question: if closing the case frees the $100 reservation, a second payment with a different key could spend it before the first one settles. The premise does not hold — we have nothing to free, and no notion of a reservation. But the second half of what he wrote is right, and I had never written it down. "Don't pay twice" can be named three ways here: sha256 user:conversation:tool:args . The layers run from inside out, and the key names only the innermost. Most of the time the three coincide, which is why the difference is invisible: one call, one operation, one payment. They come apart exactly where money gets lost. The second layer works, and that should be said first. After canonicalisation, another call with the same user, tool and arguments is refused by a partial unique index in the database: the reading is operation in flight , and the refusal names the row that holds it and the conversation it came from. The arbitration is in the schema, not in application logic, so two concurrent requests cannot both pass. Closing the case does not release that lease. The lease only looks at whether the status is claimed , and closing does not change the status. The exposure the reader feared — "closing opens it up" — does not happen on the call side. It cannot be opened from there. The lease is valid only inside the unknown window: once anything settles, the same arguments can go out again. That is deliberate — identical arguments may genuinely be a second, legitimate payment. But it also says what we protect: the period of not knowing, not the money. The second layer is a function of the arguments. Change one character — a different reference, a note that says "retry", 100.00 written as 100 — and canonicalisation produces a different identity. The lease does not recognise it, the second payment goes out, and the bank sees the same $100. A second case is more complete: a person paying directly in the business system. That path never passes through us — no key, no hold, no record. A third is the amount itself. If the target froze the funds as part of the call, our ledger never sees the freeze; when it expires under the target's own rules, we never learn. The row says the outcome is unknown. It does not say that up to $100 may have moved. The question is not whether to record an amount. The key points at the wrong thing. To protect the resource, one key would have to satisfy four things at once: it is minted by the party holding the balance or at least accepted by it as the only identity ; there is one key per resource ours is a function of the arguments — one character and it is a different key ; it outlives the resource ours is valid only inside the unknown window ; and it is carried by every path that can touch the money a person paying in the UI carries nothing . Miss one and the thing protected is not the resource. So the move is not to make the call key stricter but to change what it names: send the resource identity as an argument, let the party holding the balance mint and accept the key, and shorten our own promise to one sentence — the same resource always carries the same key . Only we can do that part, because only we see both the call and its arguments. The cost is knowing what the resource is. customer id is a resource, amount is a quantity, note is a description, and that division belongs to the business, not to the tool. Declare it from the tool, or guess from the arguments; a wrong guess is worse than no record. One boundary survives all of this: even with the right resource, any path that does not carry the key walks around it. A key protects a path, not the money. So who keeps the money from being spent twice? Three parties, each holding one segment: we hold "the same call is not replayed"; the target holds "the same key is not accepted twice" — an assumption; the business side holds "the same balance is not spent twice" — through its own limits and reconciliation. Together they are one guarantee; separately nobody holds it, and "keep the exposure on the books" needs the whole of it: which resource, how much, when it can be closed. So the question is not whether to add an amount column: When a system calls itself idempotent, which of the three is it promising? What we can say is the negative: treating "the same call is not replayed" as the same thing as "the money cannot be spent twice" passes off the first promise as the third. On paper, the two sentences look almost alike. The implementation described here comes from the open-source project KeelBase: Drafted with an AI assistant. The system, the positions and the mistakes are mine.