AI automation

AI workflow automation: failures, retries and recovery

Plan AI workflow automation around exceptions, retries, duplicate actions and human handoff. Includes an onboarding example and recovery checklist.

By Point of AI Editorial team

Published 14 min read · Updated

The extraction worked, the draft looked reasonable and the demonstration finished with a new record in the CRM. Then the live workflow met an expired connection, a changed document and a request that arrived twice. The useful question is what the system does with those conditions after the presentation ends.

AI workflow automation needs an exception path as carefully defined as its successful path. That includes the state of the work, the effect of a retry and the person who receives an unresolved case. These decisions belong in the delivery scope, because they affect both the integrations and the daily operating work.

Consider a fictional onboarding process. An assistant reads an incoming request, extracts company details, prepares a CRM record and asks a member of staff to approve creation. A notification follows the confirmed write. The scenario below is an original planning example, not a report about a particular automation platform or client implementation.

Keep in mind

Key takeaways

  • Preserve the business state and the last confirmed action when a workflow stops.
  • Distinguish temporary errors, missing input and unknown operation outcomes.
  • Rehearse retries, reconciliation and operator handoff before accepting delivery.

Map the work as changes of state

A diagram showing “read, extract, save, notify” is a useful start, but it does not tell you what is true between those steps. Add states that a person can recognize: request received, extraction ready, waiting for clarification, awaiting approval, creation pending, record confirmed and notification pending.

Give each state an entry condition. Extraction is ready when the required output has passed the agreed checks. Approval is pending when the reviewer has a particular version to inspect. A record is confirmed when the system has evidence of creation, not merely because a request was sent. This makes the process discussable without requiring every stakeholder to read implementation code.

Attach the work to a stable identity. A request should remain recognizable as it moves through the flow, even if its content is corrected or a step is retried. Decide when an incoming item is a genuinely new request and when it is a repeat notification about existing work. That distinction matters before choosing where to store the state.

Review the map with an operator as well as the delivery team. Ask where a real person would expect to find an item that has stopped. If the only answer is a technical execution history, the operating process is incomplete. Someone needs a manageable view of unfinished work, including the reason it cannot continue.

Distinguish bad input from a failed connection

A missing company identifier is not the same problem as a temporary timeout. Retrying extraction may help when the response was interrupted; it will not supply a fact absent from the request. Put those conditions into separate branches with different owners and next steps.

In the onboarding example, a missing address can enter clarification. An expired CRM credential needs an integration owner. A rejected field value needs correction against the destination's requirements. A temporary connection problem may justify a controlled retry. A request the system is not permitted to handle should stop within its defined scope.

Illustrative exception states for an onboarding workflow

Scroll to view all columns →

ConditionState to preserveNext responsibility
Required detail absentWaiting for clarificationRequest owner supplies it
Temporary service interruptionRetry scheduledWorkflow follows its retry policy
Permission deniedAccess blockedAuthorized system owner investigates
Write outcome unknownReconciliation neededCheck the destination before resending
Destination rejects a valueCorrection neededReviewer fixes the proposed record

Microsoft's transient-fault guidance distinguishes temporary faults from persistent or terminal failures and calls for a suitable retry strategy. That principle is useful here, but the classification and ownership in this example are editorial design choices. Your integrations' actual response contracts and business rules determine how the implemented branches should work.

Reference: Best practices for transient fault handling ↗

Treat an unknown write outcome as its own problem

A request can time out after the destination has already created a record. From the workflow's perspective, the result is unknown. Sending the same create request again without checking may create another record, even though the first attempt appeared to fail.

Before implementing a retry, ask what evidence the destination can provide. It might accept an operation identifier, return a resource ID or allow a lookup using an agreed reference. The right approach depends on that system's contract. If the destination cannot support a reliable check, the workflow needs a bounded reconciliation process rather than an assumption that a timeout means nothing happened.

Show the operator the uncertainty honestly. “Creation needs checking” is more useful than “Failed” when the record may exist. Provide the reference needed to search the destination and a place to record the resolution. Avoid asking people to infer the outcome from an unexplained error string.

Also consider what happens after reconciliation. If the record is found, continue from confirmed creation and handle the notification separately. If it was not created and it is safe to proceed, make that decision explicit. Keep the operation history so a later operator can understand why the workflow resumed rather than repeating the same investigation.

Give retries a reason, a limit and a stopping point

A retry policy should identify the failures it covers and the conditions for stopping. “Retry on error” is too broad. In our example, a temporary service interruption can be treated differently from an invalid record or revoked access. The team needs to agree those distinctions before choosing delays and attempt counts.

Set limits using the requirements of the workflow and the service involved. There is no universal number of attempts that fits every integration. Consider how long an onboarding item can wait, what the destination permits and what happens when many items encounter the same problem. Review the service's documented guidance where it exists.

Record the attempt state with the work. An operator should be able to see that a retry is scheduled, why it is scheduled and what happens after the limit is reached. Give the user a useful expectation without promising that the next attempt will succeed. A person should not have to keep pressing a button to discover that the underlying connection remains unavailable.

Coordinate retries across the layers involved. If an integration client, a job runner and a whole-workflow restart each repeat the same request, the effective number of attempts may be different from the one shown in a configuration screen. Ask the delivery team to explain the complete path for a failed operation and demonstrate the resulting behaviour.

Design repeat operations to have a known effect

Idempotency describes an operation whose repeated execution has the same intended effect as executing it once. In practice, ask a concrete question: if this item is processed again, will the destination end up with another onboarding record or the same one? The answer must come from the implemented operation, not a label in the workflow diagram.

Choose an identity appropriate to the business action. An email address alone may be a poor duplicate key when one company can submit several legitimate requests. Conversely, a new random ID on every retry cannot help the destination recognize repeated attempts at the same action. Work through the actual distinction between a new request, a correction and a replay.

Keep the duplicate check consistent with the write. A process that checks whether a record exists and then creates it can still race with another process doing the same work. Ask engineering which guarantees the destination offers and where the business rule is enforced. A manual operator should not be expected to resolve an avoidable ambiguity on every busy day.

Include notifications in the analysis. Preventing duplicate CRM records does not automatically prevent duplicate messages. Give a notification its own delivery state and an appropriate reference to the confirmed action. If the message cannot be reliably deduplicated, explain that limitation and agree how the workflow will handle uncertainty rather than claiming a guarantee it cannot support.

Resume from a useful checkpoint

Restarting the entire flow is often unnecessary when only the last step failed. If the approved CRM record was created successfully but the notification did not send, preserve the confirmed write. The next attempt should address the unresolved notification within the agreed rules.

Choose checkpoints that preserve the information needed to continue safely. For the onboarding workflow, that may include the approved record version, the destination's record ID and the status of the notification. Decide what can be recomputed and what should remain tied to the earlier decision. Do not silently regenerate fields after a person has approved a particular version.

Account for changes between attempts. A request may be corrected while a retry waits in a queue. An account may lose access, or the destination may change. On resumption, the system needs to determine whether the stored state remains valid for the intended action. A checkpoint is useful only if the continuation rules are understood.

Document what a restart does. “Resume notification” and “Reprocess request” should not be interchangeable operator actions. The latter may repeat extraction, invalidate an earlier approval or create a different draft. Give each action a clear effect and show which parts of the previous work will be retained, replaced or reviewed again.

Related reading: Define AI agent permissions and approvals

Send a person a work item they can actually resolve

An alert is not a complete handoff. The operator needs the request reference, the current state, the last confirmed action and the reason the process stopped. Include the information necessary to resolve the case without exposing unrelated confidential content in a message or dashboard.

For an invalid CRM value, show the proposed record and the destination's useful validation detail. For an unknown write outcome, show the operation reference and the reconciliation route. For missing information, make it clear who can supply the fact and how the workflow will receive the correction. These are different work items and should not all land in an undifferentiated error inbox.

Name the receiving role and a backup route. What happens when the usual reviewer is absent or the queue is ignored? The answer may be escalation, reassignment or a deliberate pause in the affected service. Agree the process with the team that will operate it, including what response expectations it can realistically meet.

Record the resolution and its effect. A person may correct a field, confirm that a record already exists or decide that the request should be cancelled. The workflow should resume or stop according to that decision. A free-text note can explain the reasoning, but it should not be the only mechanism controlling what the automation does next.

Decide which changes can be reversed and which need repair

Some actions can be cancelled before they take effect. Others require a later action to compensate for what already happened. Sending another message to correct a mistaken notification does not erase the original message. Deleting a record may also be inappropriate if another person has already started using it.

Work through the business meaning of recovery. In the fictional onboarding process, an incorrect draft can be edited before creation. A confirmed record with a wrong field may need an authorized update. An externally delivered notification may need a follow-up handled by a person. The correct route depends on what happened and who is allowed to change it.

Microsoft's compensating-transaction guidance notes that compensation is specific to the application, can itself fail and may require manual intervention. Use that as a reason to specify recovery work explicitly. Do not describe the whole workflow as reversible without examining the effects of its individual actions.

Keep enough progress information to support the chosen repair. Record the relevant identifiers, versions and confirmed outcomes, with appropriate access and retention. The goal is a usable account of the operation, not a copy of every sensitive input in every log. Review the recovery instructions with the people who would be asked to follow them during an incident.

Reference: Compensating Transaction pattern ↗

Show the business queue as well as the technical history

The operator's first question is often which requests need attention. A view of unfinished work can be organized by state and responsibility: waiting for input, awaiting approval, retrying, blocked by access or requiring reconciliation. That is easier to act on than a list of all execution events.

Keep the technical detail available for investigation. A request reference should connect the business item to relevant attempts and confirmed destination actions. Engineers may need more diagnostic context than an everyday reviewer, so design the access boundaries accordingly. Operational visibility does not require giving every user access to raw prompts, documents or credentials.

Define what completion means. A CRM record might be confirmed while its notification remains pending. The workflow can display that distinction without either hiding unfinished work or claiming that the entire request failed. Use language that reflects the state of the business task and the obligations that remain.

Agree which conditions need attention beyond an individual item. Repeated permission failures may indicate a shared connection problem, while one rejected address may be a local correction. The dashboard should help operators identify the difference. The team can then pause the affected step or route work elsewhere instead of treating every item as an unrelated incident.

Walk through a partially completed onboarding request

Take one fictional request through the map. The staff member approves the proposed company record, the CRM accepts the create operation and the workflow loses its connection before recording the result. The correct next state is uncertain creation, because the workflow cannot yet establish whether the approved action took effect.

The operator opens the work item and uses the stored operation reference to check the destination through the agreed reconciliation route. If the record exists and matches the approved request, the workflow can record confirmed creation. It should not repeat extraction and send another create operation just to make the earlier execution appear successful.

The notification is still unfinished work. Resume that step according to its own delivery rules and show its outcome separately. If the notification result is also unknown, apply the appropriate check or handoff rather than assuming that every unconfirmed message can be resent without consequence.

Now change the example: while the workflow waits, the request owner corrects the company address. That correction does not automatically authorize overwriting a confirmed record. The process needs to identify the new version, determine which action is required and obtain any approval the changed operation needs. Preserving state makes this distinction possible.

Use this walkthrough as a conversation between the person operating the queue and the person implementing the integrations. Ask each to explain the last confirmed action and the next permitted action at every pause. If their answers differ, resolve the process rule before adding another retry branch. The disagreement is useful evidence of an incomplete workflow specification.

Rehearse interruptions at the boundaries

Test where the flow changes systems and where it changes authority. In our example, stop the process before a CRM write, after the destination accepts it and before the notification result is recorded. Observe whether the stored state supports the continuation the team expected.

Include a repeated incoming request, a corrected request waiting for approval and a permission change between approval and execution. Check that the workflow does not treat stale context as permission to act. Demonstrate the operator route for each unresolved case, including the information shown and the result of the chosen resolution.

Use controlled test fixtures or an appropriate test environment. A recovery exercise should not send real customer messages or create uncontrolled business records. Keep evidence of the state transitions and final outcomes so the team can distinguish a correct recovery from a screen that merely looks successful.

End the delivery conversation with operating ownership. Who monitors unfinished work, maintains credentials, reviews repeated failures and updates the process when a connected tool changes? Ask an automation agency to include those responsibilities, the recovery instructions and the rehearsal results in its handover. A useful automation continues to make sense after its first exception.

Keep the rehearsal conditions with the findings. A successful exercise using a test connection and a small set of representative requests establishes what happened under those conditions. It does not establish behaviour at every volume or with every external service interruption. Record the remaining assumptions so the operating team knows which conditions still need observation or further testing.

Related reading: Compare AI automation agencies

Read the original thinking

Sources & further reading

This is original Point of AI analysis. The sources support the statements attributed to them. Hypothetical examples and suggested questions are editorial guidance.

  1. Best practices for transient fault handling ↗Microsoft · Checked November 13, 2026

    Supports distinguishing transient failures, bounded retries and checking the consequences of repeated operations. The exception-map exercise and work-item scenario are Point of AI's original editorial examples.

  2. Compensating Transaction pattern ↗Microsoft · Checked November 13, 2026

    Explains application-specific compensation, its own failure cases and manual intervention. The onboarding states and recovery walkthrough are original editorial examples.