provantix / insights

Engineering / FIELD NOTES

Why an agent's success message is not proof of execution

Design tool results and verification around accepted requests, destination outcomes and unresolved states instead of optimistic completion messages.

THE SHORT ANSWER

A request, an acknowledgement and a confirmed business result are different observations. Completion language should reflect the strongest result actually available.

A user asks an agent to update a customer record. The agent calls a tool and replies, “Done.” Later, the customer record is unchanged. The tempting repair is to tell the model to be more careful. That may improve the wording, but it does not establish where the workflow first diverged from the intended result.

The cause might be a misleading tool contract, an asynchronous job, an incorrect account identifier or a failed persistence step. The first task is to trace the request from the user's instruction to the destination state. A confident sentence at the end cannot identify which earlier layer failed.

Name the states before writing the reply

HTTP provides a useful example. A 202 Accepted response means that a request was accepted for processing, while processing is not complete. RFC 9110 explicitly leaves the eventual result open. An application that turns every successful HTTP status into “the work is finished” loses this distinction. RFC 9110, section 15.3.3.

We recommend designing tool responses around business states rather than a single generic boolean. For an asynchronous update, a response might identify the submitted job and say that confirmation is pending. For a synchronous mutation, it might identify the affected object and return the destination's recorded result. The exact fields should follow the real API contract.

Do not invent a “confirmed” state merely because the upstream request did not throw an exception. The system needs evidence that corresponds to the claim it will make.

Trace one hypothetical failure end to end

Consider a fictional CRM integration. The user requests a phone-number correction for customer C-104. The tool submits a background job, receives a job identifier and reports success. The agent then says the customer's number was updated. The background job later fails because the customer was merged into another record.

The first demonstrated divergence is the tool's conversion of submission into completion. A narrow repair would preserve the job identifier and pending state, then expose a supported way to obtain the eventual result. The conversational instruction can require the agent to report that state accurately.

If instead the tool had already returned a clear failure and the agent ignored it, the responsible layer would be different. Inspect the actual result before choosing between a prompt change and an integration change.

Decide what counts as confirmation

Confirmation should be specific to the action. A readback might establish that a stored field now has the requested value. A destination audit event might establish that a particular actor made the change. A delivery receipt might establish that a receiving service accepted a message. Each supports a different statement.

For a field update, compare the intended object and value with the returned object and value. For a queued job, inspect its terminal state through the documented interface. For a transaction that can be reversed, retain the initial result and record the later reversal separately.

These are engineering recommendations, not universal guarantees. A readback from the wrong tenant is still the wrong evidence. A destination event may arrive late. A connector may have incomplete permissions. The verification design should expose those limitations.

Treat uncertainty as an operational state

When confirmation cannot be obtained, preserve the operation reference and say what remains unresolved. “Submitted; confirmation is pending” gives both the user and the next operator a useful starting point. “Done” creates an obligation the evidence does not support.

Timeouts deserve particular care. A timeout does not, on its own, tell the caller whether the remote system performed the action. Before retrying a consequential mutation, consult the destination's documented retry and deduplication behavior. Record retry attempts so investigators can distinguish one logical request from several executions.

Do not conceal the uncertainty with a canned success response or a hidden second route. If recovery is required, make its conditions and resulting state part of the visible contract.

Test the claim, not just the call

Build acceptance checks around the user's intended outcome. Include the normal completion path, a rejection, delayed completion, an unavailable status endpoint and a correction to the requested object. Verify the persisted state where access permits, not only the final chat response.

For a second enquiry in the same conversation, confirm that the new object and operation references do not inherit the first enquiry's result. For a user correction while a job is pending, define whether the operation can be cancelled or whether a separate action is necessary.

The desired result is a workflow that says exactly what it knows. A well-designed agent can be helpful while a task is pending, precise when it fails and confident when completion is supported by the destination. That is a stronger foundation than teaching the model to sound certain more cautiously.

Sources and further reading

Primary sources checked on 16 November 2026. Examples in this article are illustrative unless stated otherwise.

  1. RFC 9110: 202 Accepted ↗
About the publication

Provantix Insights explores agent accountability from an engineering perspective. Read our editorial approach.