An outbound write times out. The claim sits at claimed, and nobody knows the outcome. Three weeks later a hundred of them have piled up, and someone clicks release.

What comes back is not what they asked for: the disposition changes (closed_unknown), the status does not (still claimed), and the idempotency key stays occupied. They wanted the row gone and the key reusable. We did not do that.

This is not a defence of our choice. It is the disagreement laid out: what each path costs, which one we took, and what is still unsolved.

1. The disagreement is about what the key prevents

After a timeout there are three ways forward: a late completion settles the row; a human asks the target one read-only question (reconcile); or a human decides to stop handling it (release). The first two remove the unknown, the third only stops working on it. Nobody argues about that part. The argument is whether the idempotency key goes back.

It is easy to read reconciliation as "ask once and that is it". Precisely: one query per call. As long as the claim is still claimed and not released, it can be asked again, and every attempt is stored with its time and conclusion. Nobody has to click for it either: once a hold is in the pending-decision queue, the system asks again every hour, with the gaps growing to one, six, twenty-four and seventy-two hours, then stops. Each pass asks at most twenty-five rows; the rest wait for the next hour. Whether it has stopped is written on the row.

The cleanup camp is direct: a claim is a resource, the outcome is not coming, so close it out, return the key and let the same call become a clean new call; the target's own idempotency handles duplicates. Queue TTLs and close-on-timeout are what most systems do.

We did not. This key does not prevent duplicate execution; it prevents the system from quietly treating an old call as a new one. Whether the target deduplicates is something we do not know — that is a bet across a trust boundary. The key is the one thing we can assert on our own side.

Where the two sides differ:

  • What the key prevents. Cleanup: a duplicate execution, handled by the target. Ours: the system passing off an old call as a new one.
  • Returning the key on release. Cleanup: yes, or it is occupied forever. Ours: no, returning it is the same as permitting a resend.
  • What the queue should end up as. Cleanup: shorter. Ours: not shorter.
  • Main cost. Cleanup: one real double write when the target is not idempotent. Ours: the key is never returned and the pending queue only grows.

2. The cost: the key is not returned, and the queue does not get shorter

After a release the row is still there. It moves from "in flight" to "released", it is still selectable by decisionState, and someone still has to look at it. The one thing the operator wanted — a shorter queue — is not delivered at all.

And the key really does not come back: no path deletes the row and none returns it to a state where it can be reoccupied. Every release permanently spends one idempotency key. We accept that cost; we do not have a solution for it.

That is not a side effect. It is the net price. We are selling "stop handling it"; they were buying "make it stop appearing".

3. What breaks if we follow the cleanup camp

Both counterexamples are one step down from the code that exists.

A: release returns the key. The next retry looks like a brand-new call and goes out. If the first one did reach the target, that is a real double write — and no record can tie it back to the first, because the key is gone. The release created the thing it exists to prevent.

B: the expiry sweep marks rows released. A slow call may still be running; once it is marked, its late completion has no row to record itself into, and the claim stays at "nobody knows" forever, even after the evidence arrives. So the sweep decides nothing itself: every hour it moves overdue open rows to awaiting_decision, without changing the status, writing a conclusion or releasing anything. The asking is a separate path — the scheduled re-asks — and "released" still comes either from the target's answer or from a person.

The endpoint's shape follows from the same reasoning:

POST /ai/tool-effects/claims/:id/release -> { outcome: "released_unknown", status: "claimed", decisionState: "closed_unknown" } 

status staying claimed is not a typo. The status answers "did this write produce a result", and the answer is still no. Only the disposition changed.

4. The requirements we impose on a release are weak

A release needs a note of 8 to 500 characters and may carry an external reference; the act writes one chained audit row with no outcome. The requirement came from a reader: "the queue is full" is not a reason. A release must point at something someone looked at, or it is indistinguishable from clicking the queue away.

But we only check the length. "queue pressure" is 14 characters and it passes. The system does not know whether the note points at evidence, or whether that evidence exists.

5. The real problem: what the operator saw was never frozen into the record

The system does not keep what was in front of the person when they pressed the button. The reference is free text they typed; the claim's state, whether the target could be queried, how often, what it answered — none of it is frozen with the decision.

So the auditability of a release reaches "someone decided". It does not reach "the decision held up at the time". And the whole justification for this path rests on "it must point at evidence" — if the evidence cannot be reviewed afterwards either, that sentence is closer to a formality.

One more thing is not closed: reconciliation presupposes that the target offers a status query. Targets that cannot answer (target-status-unavailable) cannot even be asked, and the scheduled re-asks do not fire at them at all; those rows never converge and the only way out is a release. The volume of releases is set by a gap somewhere else.

So the question worth arguing is not whether release should change the status. It is this:

If a release cannot be reviewed afterwards for whether it was justified, is it a decision or a formality?

We do not have an answer. What we are sure of is the other direction: quietly ruling the row "executed" or "not executed" is worse — then not even the formality is left.

Closing

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.