Definition of Skill Repository

A skill repository is a managed collection of reusable skills available to an AI agent for performing different tasks and subtasks. It can contain both pre-installed skills supplied as part of the agent’s default capabilities and custom skills that have been subsequently developed, tested, validated, and approved for reuse. Rather than requiring the agent to consider every available skill directly during every task, the repository provides an organized source from which a task-relevant subset of skills can be retrieved. For a skill repository $\mathcal{S}={s\_1,s\_2,\ldots,s\_n}$, where $\mathcal{S}$ (skill repository) represents the complete collection of available skills and each $s\_i$ (reusable skill) represents an individual skill, a new task $\tau$ (target task) can be used as the basis for task-aware skill retrieval. Retrieval may use skill metadata, semantic matching, keyword or metadata search, capability matching, constraint filtering, ranking, or combinations of these methods to derive $\mathcal{S}\_{\tau}\subseteq\mathcal{S}$, where $\mathcal{S}\_{\tau}$ (task-relevant skill set) contains the skills considered sufficiently relevant or potentially useful for the particular task. For more complex repositories or tasks, this retrieval and filtering process may be delegated to a specialized skill-selection subagent operating within its own context window, allowing it to examine the task requirements and available skill descriptions without unnecessarily occupying the main agent’s working context. The resulting task-relevant skill set can then be made available to the main agent, which dynamically determines which skill to invoke for a particular subtask or execution state as the task progresses. The repository therefore serves not merely as storage, but as an organized and extensible skill-management layer supporting skill registration, discovery, retrieval, selection, reuse, and continued expansion across different agentic tasks.

Conditions for a Skill Repository to Hold

A skill repository holds when there is an identifiable and maintained collection of reusable skills that can be systematically registered, described, discovered, retrieved, and made available to an AI agent across multiple tasks. Each stored skill $s\_i$ should have sufficient skill metadata to support discovery and compatibility assessment, such as its name, description, intended capability, applicable task or subtask types, expected inputs and outputs, dependencies, required tools, constraints, or other relevant properties. Skills admitted to the repository should also satisfy defined validation and approval requirements appropriate to the application, so that inclusion indicates that the skill has reached an acceptable state for subsequent reuse rather than representing an arbitrary temporary instruction generated during a single execution. The repository should support one or more retrieval and matching mechanisms capable of reducing the complete skill collection $\mathcal{S}$ to a task-relevant candidate set $\mathcal{S}\_{\tau}$, without requiring exact wording between a task and a skill description; semantic retrieval, metadata filtering, capability matching, ranking, and related methods can therefore be combined according to the scale and requirements of the repository. A dedicated skill-selection subagent may perform this filtering when separation of context, specialization, or repository scale makes delegation useful, but such a subagent is an optional architectural mechanism rather than a defining requirement of the repository itself. Finally, retrieval of $\mathcal{S}\_{\tau}$ should not require all retrieved skills to be activated: the main agent should be able to select and invoke an appropriate skill dynamically when the corresponding subtask, condition, or execution state arises. Under these conditions, the skill repository functions as a persistent and reusable capability source from which task-specific skill availability can be constructed without exposing the entire skill collection to every task execution.

Definition of Agentic Task

An agentic task is a composite task performed by an AI agent through a structured combination of multiple subtasks, where each subtask represents a distinct part of what needs to be accomplished and is fulfilled by an appropriate reusable skill. An agentic task can be represented as $\tau=({T}\_{\tau},{S}\_{\tau},{R}\_{\tau},{M}\_{\tau})$, where $\tau$ (agentic task) denotes the complete task to be performed, ${T}\_{\tau}={t_1,t_2,\ldots,t_n}$ (subtask set) contains the subtasks that collectively constitute the task, ${S}\_{\tau}={s_1,s_2,\ldots,s_m}$ (skill set) contains the reusable skills available for fulfilling those subtasks, ${R}\_{\tau}$ (execution relations) specifies how the subtasks and their corresponding skills are organized and performed sequentially, iteratively, recursively, or through an appropriate combination of these patterns, and ${M}\_{\tau}$ (evaluation metrics) contains the task-specific measures used to determine whether intermediate results and the overall task outcome satisfy the expected requirements. For each subtask $t_i$ (subtask), an appropriate skill $s_j$ (reusable skill) may be selected from predefined skills or dynamically engineered during task execution when an existing skill does not adequately address the subtask.

Conditions for an Agentic Task to Hold

For an agentic task to hold, the task should be sufficiently compositional and execution-oriented to require or meaningfully support decomposition into one or more identifiable subtasks whose coordinated performance contributes to the completion of the overall task. Each required subtask $t_i \in {T}\_{\tau}$ should have an applicable skill $s_j \in {S}\_{\tau}$, either predefined and reusable from an existing skill set or dynamically engineered when no suitable existing skill is available, so that the agent has a viable means of performing the required work. The execution relations ${R}\_{\tau}$ should provide sufficient structure for determining how execution proceeds among subtasks, including when a subsequent subtask should begin, when an earlier subtask should be revisited, when repeated refinement is necessary, or when additional subtasks should be introduced during execution. The evaluation metrics ${M}\_{\tau}$ should also provide sufficiently clear criteria for assessing whether each relevant output $o_i$ and, ultimately, the overall task outcome meet the expected requirements. Accordingly, an agentic task holds when its necessary subtasks can be identified or dynamically determined, suitable skills can be assigned or engineered to fulfill them, their execution can be coordinated through appropriate sequential, iterative, or recursive relations, and their resulting outputs can be evaluated and progressively used to guide the task toward satisfactory completion.

Definition of Callable Skills

Callable skills in Agentic AI are skills that an AI agent can actively invoke during task execution when their capabilities, procedures, or instructions are relevant to the requirements of the current task. A callable skill typically represents a defined unit of task-supporting capability, such as retrieving information, analyzing content, processing data, generating or modifying an artifact, validating an output, interacting with a tool, or carrying out a specialized workflow. Describing a skill as callable emphasizes that the skill is not merely defined, documented, or known to the agent, but is available through an invocation mechanism that allows the agent to activate it and use its prescribed functionality as part of the ongoing workflow. Callable skills may be selected from a broader runtime skill catalog according to the task instructions, detected requirements, current context, intermediate results, and execution conditions. Multiple callable skills may therefore be invoked sequentially, conditionally, or in combination to support different subtasks, while skills that are available but irrelevant to the current task can remain unused.

Conditions for Callable Skills to Hold in Agentic AI

A skill can be treated as callable when the agent can identify it, determine when its use is appropriate, invoke it through an available mechanism, provide the information or inputs required for its execution, and receive or otherwise use its resulting output within the task workflow. Its required dependencies must also be satisfied: for example, necessary tools, resources, permissions, interfaces, contextual information, and execution capabilities must be available under the current runtime conditions. Merely defining a skill or including it in a broader skill repository does not necessarily make it callable; there must be a usable connection between the agent’s task-execution process and the skill itself. A callable skill does not need to be invoked in every task, nor does being callable mean that it is currently relevant. Rather, callability indicates that the skill is operationally available for invocation if the agent determines that the task requirements and applicable conditions justify its use. If required inputs, permissions, dependencies, or execution mechanisms are unavailable, the skill may remain defined or discoverable but should not be considered callable under those particular runtime conditions.

Definition of Instruction Space

An instruction space is the organized set of instructions that may govern, constrain, guide, or otherwise influence the behavior of an AI agent. It can be represented as $I = \{i_1, i_2, \ldots, i_n\}$, where $I$ denotes the instruction space and each $i_j \in I$ denotes a unit instruction expressing an individual rule, requirement, constraint, preference, procedure, condition, or behavioral direction that the agent can interpret and apply. The instruction space may contain instructions originating from different authorized sources or functional levels, such as system instructions $I^{S}$, user instructions $I^{U}$, task instructions $I_{\tau}$, and skill or workflow instructions $I^{K}$, with these instruction sets forming relevant parts of the broader space, for example $I^{S}, I^{U}, I_{\tau}, I^{K} \subseteq I$. The elements of $I$ do not necessarily have equal authority, applicability, or effect: some instructions may apply generally, others only to a particular task $\tau$, state $z_t$, or runtime condition, and some may be overridden, disabled, superseded, or rendered inapplicable according to the governing instruction hierarchy and applicable conditions. Thus, $I$ represents the broader space of instructions potentially relevant to agent behavior, while an active instruction set $I^{*}_{\tau,t} \subseteq I$ can represent the instructions that actually govern or guide the agent for task $\tau$ at execution step $t$.

Conditions for an Instruction Space to Hold

An instruction space $I$ can be considered to hold for an AI agent when its constituent instructions are available to, accessible by, or otherwise represented within the agent’s operative instructional environment and are capable of being considered under the applicable authority, scope, and runtime conditions. This does not require every $i_j \in I$ to be active simultaneously; rather, the space may contain both currently applicable and conditionally applicable instructions. Let $\alpha(i_j, \tau, z_t, E_t) \in \{0,1\}$ denote whether instruction $i_j$ is applicable to task $\tau$ under agent state $z_t$ and runtime environment $E_t$, and let $\lambda(i_j, I)$ represent the effect of instruction priority, authorization, conflict resolution, overriding, or disabling rules. The operative instruction set may then be expressed abstractly as $I^{*}_{\tau,t} = \{i_j \in I \mid \alpha(i_j, \tau, z_t, E_t) = 1 \land \lambda(i_j, I) = 1\}$. Accordingly, the instruction space continues to hold even when some instructions are inactive, provided that the space itself remains defined and available; what changes with the task and runtime conditions is the subset of instructions that actually governs, constrains, or guides the agent’s current behavior.

Explore Instruction Space Relevant Concepts

Unit Instruction

A unit instruction is an individual instruction within an instruction space ${I}$ that expresses a distinct direction, requirement, constraint, preference, condition, or other guidance for an AI agent when performing a task. For a user task $\tau$, the user’s task instruction at step $t$ can be represented as ${I}^{U}\_{\tau,t}={I}^{E}\_{\tau,t}\cup{I}^{I}\_{\tau,t}={i\_1,i\_2,\ldots,i\_{n\_t}}$, where each $i\_j$ is a unit instruction, ${I}^{E}\_{\tau,t}$ contains explicit unit instructions directly stated by the user, and ${I}^{I}\_{\tau,t}$ contains implicit unit instructions indirectly expressed by the user and identified through instruction detection, such as semantic matching or contextual interpretation. A unit instruction does not need to correspond to a separate sentence or command; it represents a distinct instructional meaning that can be identified as part of the user’s broader task instruction. Because additional instructions or instructional meanings may arise or become identifiable as the task proceeds, the user’s task instruction can change over time, so ${I}^{U}\_{\tau,t+1}$ may include new unit instructions that were not included or identified at an earlier step.

Definition of Runtime Skill Catalog

A runtime skill catalog in Agentic AI is the collection of skills that are available to an AI agent for consideration and use while it is actively performing a task. Each skill represents a defined capability, procedure, workflow, or set of instructions for handling a particular type of requirement or subtask, such as information retrieval, document analysis, data processing, content generation, validation, or interaction with an external tool. The catalog provides the agent with an organized set of possible skills from which relevant ones can be identified and selected according to the current task, rather than requiring every available skill to be applied. It may contain skills that are permanently available in the agent’s environment as well as skills that become available dynamically because of the current configuration, connected tools, user permissions, task context, or other runtime conditions. In this sense, the runtime skill catalog describes the agent’s currently accessible skill space: it indicates what skills the agent can potentially use at a particular point during execution, while the actual skills triggered for a task form only a task-relevant subset of that catalog.

Conditions for the Runtime Skill Catalog to Hold in Agentic AI

A runtime skill catalog holds when the agent has access, during task execution, to a defined and discoverable set of skills whose availability and applicability can be determined from the current runtime environment. For a skill to meaningfully belong to the catalog, the agent should be able to identify the skill and obtain sufficient information about what it does, when it should be used, what inputs or resources it requires, and any constraints governing its use. The skill must also be operationally available under the current conditions; for example, required tools, resources, permissions, dependencies, or execution capabilities must either already be available or be obtainable through an explicitly supported procedure. The catalog does not require every listed skill to be relevant to every task, because skill selection occurs after the agent interprets the current requirements and determines which available skills correspond to them. Its contents may therefore remain fixed for an execution session or change dynamically as tools are connected, permissions change, additional skills are discovered or loaded, or environmental conditions change. If a nominally defined skill cannot be discovered, accessed, interpreted, or executed under the current runtime conditions, it should not normally be treated as an immediately usable member of the agent’s runtime skill catalog, even if that skill exists elsewhere in the broader system.

Definition of Agentic AI

Agentic AI refers to an approach to artificial intelligence in which an AI system is designed not only to generate responses but also to pursue defined objectives by determining and performing actions within an operational environment. An agentic AI system may interpret a task, reason about what needs to be accomplished, plan or select appropriate actions, use available tools and information sources, execute individual steps, evaluate intermediate results, and determine subsequent actions according to the current state of the task. Depending on its design, these activities may include searching for information, analyzing data, interacting with software, generating or modifying files, calling external tools, coordinating multiple operations, or requesting additional information when necessary. The defining characteristic of agentic AI is therefore not simply the use of a large language model, but the organization of AI capabilities into a goal-directed process in which reasoning and action can be connected across multiple steps. The degree of autonomy can vary substantially: some agentic AI systems operate within tightly predefined workflows, while others are given greater flexibility to determine how an objective should be achieved.

Conditions for Agentic AI to Operate

For an AI system to operate agentically, it generally requires a defined objective or task, instructions or rules governing its behavior, access to the information and capabilities necessary for performing relevant actions, and some mechanism for determining what should happen as execution progresses. The system must be able to connect its current task state with an appropriate next action rather than treating every interaction as an isolated response. Depending on the application, this may involve reasoning, planning, task decomposition, tool selection, memory or state management, result evaluation, error handling, fallback mechanisms, and decisions about whether to continue, revise, retry, switch methods, request assistance, or terminate the workflow. Not every agentic AI system requires all of these capabilities, and their implementation can range from relatively simple predefined procedures to more adaptive workflows in which the agent selects actions dynamically. The important condition is that the system can use available instructions, information, tools, and execution results to determine and perform actions that contribute to accomplishing the specified objective within established constraints.

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.