Understanding Agentic AI: Fallback Instructions

Definition of Fallback Instructions

Fallback instructions in the context of agentic AI are predefined alternative instructions that specify how an AI agent should proceed when its primary instructions, preferred method, or intended workflow cannot be successfully performed. They provide the agent with an alternative path toward the same task objective rather than allowing the process to stop unnecessarily when the preferred approach encounters a limitation or failure. The fallback instructions may simplify the original procedure, relax nonessential requirements, use a different available tool or information source, substitute an alternative method, or produce a more limited but still useful result. For example, if the primary instructions require an agent to retrieve information from a specialized external tool that is unavailable, fallback instructions might direct the agent to use another approved information source or complete only the parts of the task that can be reliably performed. Fallback instructions therefore serve as a form of predefined contingency guidance: the primary instructions describe how the task should preferably be performed, while the fallback instructions describe an acceptable alternative when that preferred approach is not feasible. Importantly, fallback instructions do not necessarily represent an inferior method; they represent a secondary method selected because the conditions required for the primary method are not satisfied.

Conditions for Fallback Instructions to Hold

Fallback instructions should take effect only when predefined conditions indicate that the primary instructions cannot be successfully, reliably, or appropriately performed. Such conditions may include the unavailability of a required tool or resource, missing information that is necessary for the primary procedure, repeated failure of an attempted operation, an output that does not satisfy specified requirements, technical or environmental limitations, conflicting constraints, insufficient capabilities, or restrictions that prevent the preferred action from being carried out. The triggering condition should ideally be defined clearly enough that the agent can distinguish between a genuine inability to follow the primary instructions and an ordinary difficulty that can still be resolved within the primary procedure. In particular, fallback instructions should not normally be activated merely because the alternative method is easier, faster, or requires less effort if the primary instructions remain feasible and are explicitly preferred. Once the relevant fallback condition holds, the agent can transition from the primary instructions to the corresponding fallback instructions and continue pursuing the original objective within the alternative procedure’s permitted scope. If the fallback instructions themselves cannot be performed, the agent may proceed to another explicitly defined fallback level, request necessary information or assistance, or report that the task cannot be completed under the available conditions.

Primary and Fallback Instructions in Agentic Skill Engineering

Primary instructions and fallback instructions are both essential components of robust agentic skill engineering because they jointly define how an agent should perform a task under both intended and alternative execution conditions. The primary instructions should be attempted first because they represent the preferred workflow designed to achieve the expected result. If these instructions cannot be successfully performed because of tool unavailability, missing information, execution failure, capability limitations, environmental constraints, or other predefined conditions, the corresponding fallback instructions can then be triggered to provide an alternative execution path. This conditional transition allows the predefined workflow to continue progressing toward the expected result rather than terminating immediately when a particular step or method becomes infeasible. From this perspective, the inclusion of fallback instructions can be regarded as part of a dynamic continuity mechanism within an agentic skill: although the fallback instructions themselves are predefined, their activation occurs dynamically in response to conditions encountered during execution. By enabling the agent to move from a preferred execution path to an alternative viable path when necessary, this mechanism can improve workflow continuity, robustness, and adaptability while reducing avoidable abrupt interruptions before the expected result has been achieved.

# Pseudo-Algorithm: Primary–Fallback Execution for a Downstream Task

Input:
  Downstream Task T
  Agentic Skill(s) S
  AI Agent A
  Supporting LLM(s) M

1. Apply the applicable skill(s) S to perform T with agent A supported by LLM(s) M.
2. Execute the Primary Instructions defined for T.
3. Evaluate whether the primary execution succeeds according to the predefined requirements.

4. If successful:
      → Return the Expected Result for T.

5. If unsuccessful:
      Check whether a predefined Fallback Condition holds
      → If so, trigger the corresponding Fallback Instructions
      → Execute the Alternative Path for T
      → Evaluate the Result

6. If the fallback execution succeeds:
      → Return the Expected Result for T.
   Else:
      → Trigger another defined fallback, if available
      → Otherwise, return the best valid result or report the unresolved limitation.
      

Explore the Relevant Concepts

AI Agent

An AI agent is LLM-supported software designed to interpret and follow dynamic instructions to perform different downstream tasks. For a particular task, the agent may operate under predefined default requirements while also determining newly specified or detected requirements from the user’s task instructions, provided context, intermediate results, and conditions encountered during execution. These requirements can correspondingly give rise to predefined default subtasks and newly detected subtasks, which are dynamically combined to form the complete task to be performed. Newly detected requirements and subtasks can be determined through multiple methods, including explicit instruction parsing, rule-based identification, contextual inference, classification, and semantic matching. Semantic matching can be particularly effective because it makes direct use of the LLM’s language-understanding capabilities to determine whether different expressions represent the same, overlapping, related, or distinct requirements and subtasks, rather than relying only on identical wording or fixed keywords. Based on task-specific and user-defined standards, this analysis can be conducted at different levels of granularity, from identifying broad task requirements and major subtasks to distinguishing finer-grained requirements, constraints, conditions, and individual operations. The practical capabilities of an AI agent can improve as its supporting LLM becomes more capable of language understanding, reasoning, tool use, and result evaluation; as human-designed workflows are progressively refined and optimized; and as more relevant, accurate, and sufficiently detailed contextual information is provided for the agent to comprehend and perform the task. The effectiveness of an AI agent therefore depends on the combined quality of its supporting LLM, instructions, requirement and subtask identification methods, workflow design, available tools and resources, contextual information, and mechanisms for dynamically adapting execution to the specific task and user requirements.

# Pseudo-Algorithm: LLM-Supported AI Agent Execution for a Downstream Task

Input:
  Downstream Task T
  User Task Instructions I
  Provided Context C
  Predefined Default Requirements R_default
  Predefined Default Subtasks U_default
  Agentic Skill(s) S
  Available Tool(s) and Resource(s) G
  AI Agent A
  Supporting LLM(s) M
  Evaluation Criteria E

1. Initialize the task execution for T using A supported by M.

2. Analyze I and C to identify the requirements for T:
      → Retain applicable predefined default requirements R_default
      → Identify newly specified or detected requirements R_new
      → Identify constraints, conditions, dependencies, and expected outputs
      → Resolve overlapping, equivalent, related, or conflicting requirements where necessary

3. Construct the complete requirement set:
      R = Combine(R_default, R_new)

4. Determine the subtasks required to satisfy R:
      → Retain applicable predefined default subtasks U_default
      → Derive newly required subtasks U_new from R, I, C, and task conditions
      → Remove redundant or semantically equivalent subtasks
      → Identify dependencies and required execution order

5. Construct the complete task structure:
      U = Organize(U_default, U_new)

6. Determine the execution method for each subtask:
      → Select and apply relevant Agentic Skill(s) S
      → Select appropriate Tool(s) and Resource(s) G where required
      → Use M for language understanding, reasoning, generation, tool-use decisions,
        semantic matching, and result evaluation as appropriate

7. Execute the subtasks in the required order.

8. During execution:
      → Observe intermediate results and encountered conditions
      → Detect newly emerging requirements, constraints, or subtasks
      → If material changes are detected:
            Update R
            Update U
            Adjust the remaining execution path

9. Evaluate intermediate and final results against E and the complete requirement set R.

10. If the result satisfies the required criteria:
       → Return the completed result for T.

11. If the result does not satisfy the required criteria:
       → Identify the unsatisfied requirement(s) or failed subtask(s)
       → Determine whether execution can be revised, retried, or redirected
       → Apply an alternative method, skill, tool, or fallback path where available
       → Re-execute the affected subtask(s)
       → Re-evaluate the result

12. If further valid execution paths remain:
       → Continue Steps 7–11 as required.

13. Otherwise:
       → Return the best valid result obtainable
       → Report any unresolved requirement, limitation, or execution failure.

Primary Instructions

Primary instructions are the principal set of instructions that define how an AI agent should perform an entire task, including the task objective, its constituent components or subtasks, their relationships and execution requirements, and the preferred execution path through which the expected result should be pursued. Their natural counterpart is fallback instructions, or more generally alternative instructions, which provide other execution paths when the primary path cannot be successfully followed or when multiple approaches are intentionally being explored. In established agentic skills, primary instructions may represent a preferred or widely verified method whose effectiveness in producing the expected type of result has already been demonstrated, while fallback instructions provide alternative methods for maintaining task execution when the primary method becomes infeasible or unsuccessful. However, primary instructions do not necessarily imply that the corresponding method has already been established as the best method. For tasks in which the final result, optimal procedure, or relative effectiveness of different approaches is not known in advance, an agentic skill may instead support dynamic exploration of multiple predefined or dynamically constructed execution paths. These paths can be assessed using predefined evaluation metrics or success criteria, allowing the agent to compare their outcomes and identify a more effective method through execution and evaluation. In such cases, the primary instructions may initially represent one preferred or candidate method among several possible approaches rather than a permanently established procedure, and the agentic skill can progressively determine which execution path is most effective for achieving the task objective.