Skip to content
Interface language: English
Audit / Signal

Automation retries: preventing duplicate effects

Test retries against operation identity, uncertain responses, concurrent attempts, protection limits and manual reconciliation.

Article language: English

A hand adjusts a gold-colored mechanism beside a clear teardrop-shaped object, a pale sphere and a dark bowl.
In this article

A click, silence, another click. Two records may already be waiting in the system while the user still sees one spinning indicator. A retry is safe only when the system can recognise the same intended operation and establish its earlier effect. A connection failure message does not prove that nothing happened. A record may have been created or a message accepted while the response was lost in transit. An audit should therefore cover this uncertain state as well as ordinary success and a clear error.

In this context, idempotency means being able to retry an operation without duplicating its intended effect. The actual protection depends on the system, the action and the conditions under which that protection applies. Disabling a button after a click is not enough. An integration may resume the task, a queue may deliver it again, or another person may execute it in parallel.

Define one operation before counting attempts

Decide what should happen once: creating a ticket, saving a particular document version or sending a specific message. Then define what counts as a retry of the same action and what is a new request. Without that decision, even a technically correct identifier cannot tell you whether the second execution was an error.

In a hypothetical service company, a customer sends a fault description and shortly afterward corrects the device number. Resubmission is not necessarily a duplicate of the first task. It may be an update or a new version requiring a decision. The rule should not rely solely on similar text or the same contact address.

Prepare a description of the purpose, significant data, version and owner. For each action, identify when it is considered started and confirmed. An automation process audit helps separate these stages. One business task can contain several operations that should not automatically be treated as one shared “done”. For related guidance, see the Polish Signal article “automation process audit (in Polish)”.

If AI prepares content, separate generating a proposal from executing it. Two different model answers may concern the same case. Their existence alone should not trigger two messages or two writes. An article on responsible agent workflow (in Polish) explains the appropriate boundaries.

Check what the destination system actually confirms

For each operation, find evidence at the place where the effect occurs. Acknowledging receipt of a request, creating a record and reading the completed result are different pieces of information. Establish which one your application receives and what it records against the case. Do not infer more from the word “accepted” alone. With an AI agent operating a browser, also distinguish a button click, a visible message and verification of the created record. See also the article on an AI agent operating a browser (in Polish).

Amazon describes the risk of retries after a timeout (in English): no response does not mean no effect occurred, and retrying can add load to a service. This is general technical guidance. Your acceptance test needs to cover the specific connections and confirmations involved.

If the system provides an identifier for the created object, check whether it can be read later. If it does not, agree on another way to establish the result or a manual path. Do not make an operator reconstruct the state from model text alone. “I sent it” is not evidence of an action at the other service.

The record should connect the task to all attempts and the final effect. AI logs without excess data help design that trail without copying the entire correspondence. The number of transport attempts should not accidentally become the number of completed cases in a report. This is also discussed in the Polish Signal article “AI logs without excess data (in Polish)”.

Examine the identifier and the limits of its protection

A key that identifies the same operation should remain the same on a retry and change for a genuinely new request. Check where it is created, where it is retained and who passes it onward. If each attempt automatically creates a new key, the system may have no basis for recognising a retry.

Stripe describes idempotent requests in its API documentation (in English), distinguishing rules for its API versions. This is an example of a particular mechanism, with conditions for parameters and retained results. Do not automatically transfer its rules to email, a ticketing system or another integration.

Ask about the duration and scope of protection. Does it apply to one account, a particular action or a specific environment? What happens when the record of the previous attempt is removed? If a retry comes later, the application may need an additional check in the destination system. The presence of a key field alone does not settle the entire flow.

Also test changed data with the same key. It should lead to defined behaviour, not silently perform a different action under an earlier approval. If the customer corrected a recipient address or a document version, first decide whether this is a new request. It is useful to connect this boundary with human approval of AI actions. The article on human approval of AI actions (in Polish) offers related guidance.

Test two attempts started almost simultaneously

Disabling a browser button limits one way of retrying. It does not resolve what happens when two process instances receive the same case or an operator and automation act in parallel. The test should check whether the operation is recognised before the effect and whether two runs can both regard themselves as first.

Ask the implementer to start two controlled attempts using artificial data. Record the result in the application and the destination system. The number of green messages is not the main point. What matters is whether one intended object was created, whether it can be found and whether the later run shows the correct state.

Test an interruption between the effect and recording the local confirmation. This case is especially instructive: the application may not know the operation succeeded. If the destination cannot safely establish the state, mark that boundary and prepare human handling. Do not turn lack of evidence into automatic permission for another attempt.

Permissions for manual checking and correction also need agreement. An integration permissions review (in Polish) should cover these actions. An operator needs a way to resolve the case, but not necessarily full administration of the entire service.

Set the retry rhythm and the stopping point

Not every error deserves a retry. Missing permission or invalid data may need correction rather than another identical attempt. Agree on categories and handling for the product in use. Do not add one automatic “try again” rule to every possible response.

Aeneia conceptual photography

For transient errors, consider intervals, an attempt limit and a way to spread starts over time. In the cited material, Amazon explains why simultaneous retries can sustain overload. In an audit, check the actual rhythm, including when several integration layers have their own retry mechanisms. Together they may behave differently from a single setting shown in a panel.

Define when a case moves to an exception queue. It should have an owner and a clear next step even when the outcome is unknown. Include this in the continuity plan for an AI outage (in Polish) before manual takeover. A person should not restart the task if the automation can still execute it in the background.

Returning to normal work requires reconciling pending operations. Separate confirmed successes, explicit failures and unresolved cases. Emptying a queue alone does not close the problem. For some entries the right action is a read, for others a new attempt, and for others a deliberate decision not to proceed. For pending messages also check the order of status-changing events (in Polish): two distinct events may need a different resolution from retrying the same operation.

Split a batch into parts that can be confirmed

One automation may create several records, send a notification and save a document. If it stops halfway, retrying the whole thing can repeat actions already completed. Determine which stages have their own confirmations and how the process recognises a partial result. A shared “failed” message does not provide enough information for safe resumption.

In a hypothetical flow, a ticket was created and only the message to the team failed. The next attempt should refer to the existing case if that is the agreed approach. It need not create a new case merely because the final stage did not complete. The process owner should understand that boundary without reading the configuration.

Ask to see the state after each important step. Record what can be retried independently, what needs a joint decision and what cannot be confirmed unambiguously. Do not promise atomic execution of the whole batch if the services in use do not provide it. Well-described handling of partial results can be more realistic than a slogan about perfect reliability.

In a test, stop the process after its first completed action and check resumption. Then stop it later. Each point can reveal a different dependency. This tests the actual sequence rather than only a complete connection failure before work starts.

Decide how to handle a duplicate that already exists

Protection that limits retries does not replace a plan for reconciling existing duplicates. If two tickets were created, identify the correct record, related actions and the decision maker. Deleting one entry may not undo a message, work assignment or later notification.

Prepare instructions using a controlled example. They should make it possible to recognise both results, retain the necessary trail and indicate how to close the case. Depending on the task, this may mean marking a duplicate, linking cases or another agreed correction. Do not impose one method on every system merely because they have a delete button.

Also check who is informed of the change. If two people have already begun work on different records, a technical correction will not resolve their coordination. The owner should know which case remains current and what to do with work performed on the other. The audit ends with an orderly outcome for the people affected.

Record the cause of the duplicate without adding one based on guesswork. Similar content in two records can result from a retry, but also from two deliberate submissions. If there is no evidence, mark the uncertainty. The correction should address the actual problem rather than the first convenient interpretation.

Test a retry started through another route

The same operation may return from a panel, a message, a schedule or an administrator's manual intervention. Establish which entry points belong to the shared process. If each creates its own identifier without a connection to the case, protection working in one channel may not cover another.

In a test, start the task through the usual route and then perform an agreed retry through the fallback channel. Assess the result at the destination and the information given to the operator. This is not a search for arbitrary ways around the application; it checks routes the company actually uses in its work.

If the manual channel deliberately creates a separate request, say so and show the required check of the earlier state. The user should understand that they are starting a new operation rather than merely refreshing confirmation. Clear interface language helps reduce mistakes, but it must rest on proper handling by the system.

Prepare acceptance with a concrete result

A minimum test should cover normal execution, a lost response after the effect, concurrent starts, changed data and a retry after the protection period. The scope depends on the process. Record expected behaviour and the approver before looking at the result. Otherwise it is easy to call whatever the application did correct.

Keep cases that exposed a problem in regression tests (in Polish). Include the control and exception reconciliation in the cost of the process (in Polish). Protection against repetition has value when it still works after changes and does not require the operator to guess.

Also prepare a simple operator card: case identifier, last confirmed stage, intended final state of the case, last verified effect in the destination system or an indication that it remains unconfirmed, and permitted next step. It need not contain the entire technical history. It should help answer whether the action may be retried and where to check the earlier effect. If the card says only “error”, it does not fulfil that purpose.

In a small exercise, give it to someone who did not configure the system. Ask them to reconcile one confirmed execution and one uncertain one. Record what information they needed to find and whether they used the right system. This distinguishes a working mechanism from a solution understood only by its author.

After a correction, return to the example that revealed the duplicate. Check the number of records, notifications and work assignments. One object with two independent messages can still create a duplicate effect for the team. Acceptance should cover the whole intended action, not a convenient fragment of the report.

To discuss retry handling, see the Aeneia Audit overview.

Aeneia / Aeneia editorial

Editorial article. Source links are included in the text.

About Aeneia

Brands we have worked with

  • L’Oréal
  • Garnier
  • Netflix
  • Carrefour
  • Warner Bros. Discovery
  • Biedronka
  • HBO Max
  • Wolt
  • Żabka
  • COSRX
  • Embassy of China in Poland
  • Mixa
Aeneia / Initium

From knowledge to a decision

Tell us what you want to put in order. We will agree on where to start.

Contact Aeneia

We partner with and use solutions from:

  • Google
  • OpenAI
  • Microsoft
  • Stripe
  • Anthropic
  • Linear