Agent skill execution dependency tracing method, system and device
By tracing and supplementing prerequisite dependencies and managing parameter priorities in the Agent skill execution plan, a customized workflow is generated, which solves the problem of process interruption under fragmented user needs and achieves flexible response and accurate execution.
Patent Information
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- SHENZHEN RABBIT PREMISE TECH CO LTD
- Filing Date
- 2026-05-15
- Publication Date
- 2026-06-12
Smart Images
Figure CN122198596A_ABST
Abstract
Description
Technical Field
[0001] This application relates to the field of artificial intelligence technology, and provides a method, system and device for tracing agent skill execution dependencies. Background Technology
[0002] With the development of artificial intelligence technology, agent skills and workflow execution solutions are widely used in various business scenarios. However, existing agent skill execution solutions have significant shortcomings in handling fragmented user needs.
[0003] Existing technologies primarily employ fixed-process execution schemes, requiring execution to begin from the workflow's starting node and unable to skip preceding nodes. Therefore, they can only accommodate standardized, complete business requirements. When a user's business requirements (i.e., fragmented requirements) correspond only to a single intermediate node in the workflow, existing technologies lack cross-node dependency tracing capabilities and standardized parameter value management mechanisms. This prevents the system from automatically tracing upwards and completing preceding dependencies based on the target execution node. Furthermore, parameter loss or inconsistent values are prone to occur during parameter flow, ultimately leading to process interruption or execution failure. Summary of the Invention
[0004] This application provides a method, system, and device for tracing agent skill execution dependencies, which solves the technical problems that cause process interruption or execution failure in traditional solutions.
[0005] A method for agent skill execution dependency tracing, the method comprising: Obtain the user's business requirements, match target skills in the skill library based on the business requirements, and match target execution nodes that meet the business requirements among the target skills; Read the prerequisite dependency description of the target execution node, verify the availability of the required input parameters of the target execution node, and retrospectively complete the prerequisite nodes based on the verification results; Based on the preceding nodes obtained through tracing and the target execution node, an execution workflow is generated, and the execution order of each node in the execution workflow is determined; Each node in the execution workflow is executed sequentially, and the output parameters of each node are saved to the skill variable library in real time during the execution process. When a node is executed, values are matched and retrieved from the skill variable library or external tools based on preset parameter value priority rules.
[0006] A method for agent skill execution dependency tracing, the system comprising: The intent and node matching unit is used to obtain the user's business needs, match target skills in the skill library based on the business needs, and match target execution nodes that meet the business needs in the target skills; The dependency verification and tracing unit is used to read the prerequisite dependency description of the target execution node, verify the availability of the required input parameters of the target execution node, and trace and complete the prerequisite nodes based on the verification results. The process execution control unit is used to generate an execution workflow based on the preceding nodes obtained through tracing and the target execution node, and to determine the execution order of each node in the execution workflow, and execute each node in the execution workflow in sequence. The variable library and parameter management unit is used to save the output parameters of each node to the skill variable library in real time during the node execution process; The interaction triggering and parameter completion unit is used to obtain user feedback information by triggering the corresponding interaction card set to complete the parameter completion if user confirmation or user input annotation is detected in the target node during node execution. The exception handling and status feedback unit is used to trigger fallback logic when a node execution exception occurs, and to provide real-time feedback to the terminal on the execution status of each node in the execution workflow.
[0007] A computer device includes a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor, when executing the computer program, performs the steps of the method as described in any of the preceding claims.
[0008] In one of the solutions provided in this application, a customized workflow is generated by dynamically semantically matching the target execution node and performing graph topology reverse dependency tracing and completion based on parameter verification results. Simultaneously, strict value control is implemented during execution using a dedicated variable library and parameter priority rules. This cleverly breaks the rigid physical constraint that traditional fixed workflows must be forcibly executed from the starting node, reconstructing the execution graph driven by the actual input-output lineage dependencies of nodes. While endowing the system with extremely flexible and accurate response capabilities to high-frequency, fragmented user commands in B / G enterprise scenarios, it completely eliminates the redundant steps of users being forced to undergo tedious and ineffective pre-operations. Furthermore, thanks to rigorous reverse dependency graph completion and priority-based variable caching scheduling, the problems of repeated parameter acquisition and value overwriting errors are effectively avoided. Without relying on uncontrollable real-time inference of large models, the logical determinism of the underlying business execution chain and the accuracy of parameter flow are absolutely guaranteed, greatly reducing the risk of data loss and process execution crashes caused by sudden awakening of local intermediate nodes. Attached Figure Description
[0009] To more clearly illustrate the technical solutions of the embodiments of this application, the drawings used in the description of the embodiments of this application will be briefly introduced below. Obviously, the drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.
[0010] Figure 1 This is a flowchart illustrating an Agent skill execution dependency tracing method according to one embodiment of this application; Figure 2 This is a schematic diagram of an Agent skill execution dependency tracing system according to one embodiment of this application; Figure 3 This is a schematic diagram of an Agent skill execution dependency tracing system according to one embodiment of this application; Figure 4 This is a flowchart illustrating an Agent skill execution dependency tracing method according to one embodiment of this application; Figure 5 This is a structural schematic diagram of a computer device according to this application. Detailed Implementation
[0011] The technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.
[0012] In one embodiment, an Agent skill execution dependency tracing method is provided for use in an Agent skill execution dependency tracing system. The method includes the following steps: S10. Obtain the user's business requirements, match the target skills in the skill library based on the business requirements, and match the target execution nodes that meet the business requirements among the target skills; S20. Read the prerequisite dependency description of the target execution node, verify the availability of the required input parameters of the target execution node, and retrospectively complete the prerequisite nodes based on the verification results. S30. Based on the preceding nodes and target execution nodes obtained through tracing, generate an execution workflow and determine the execution order of each node in the execution workflow; S40. Execute each node in the workflow in sequence, and save the output parameters of each node to the skill variable library in real time during the execution process. S50. When a node is executed, values are matched and retrieved from the skill variable library or external tools based on the preset parameter value priority rules.
[0013] Specifically, this embodiment is mainly applied to a large language model intelligent agent service system in B / G (enterprise or organization) business scenarios. In traditional fixed workflow execution logic, the system is usually rigidly constrained to execute sequentially from the first starting node of the topology graph. This leads to users having to go through tedious and redundant operations when faced with fragmented needs; while real-time planning schemes that rely purely on large models are prone to execution loss of control due to the lack of logical boundaries. To achieve a balance between flexibility and determinism, the system first obtains the user's business requirements, which are usually fragmented or scenario-based instructions input by the user through natural language. After receiving the instruction, the system matches the target skill in the skill library based on the business requirements. In the underlying physical and logical architecture, the skill library stores a large number of predefined Agent skills and their metadata. The metadata is a structured data set that provides a global summary description of each independent Agent skill. As an example, it covers macro-feature identifiers such as skill name, core description text, and trigger instructions. The system calls natural language processing algorithms to extract high-dimensional semantic features of the business requirements, performs similarity calculation and semantic matching with the metadata, and thus accurately locates the target skill that matches the macro-intention. After identifying the target skill, the system does not directly start the entire fixed chain of that skill from scratch. Instead, it matches the target execution node within the target skill that meets the business requirements. The system further drills down, reading the full definition of functional nodes encapsulated within the target skill (i.e., the input-output boundaries and business intent of each fine-grained atomic step). It then performs a secondary comparison between the local semantics of the user's instructions and the functional boundaries of each independent node, thereby skipping redundant preliminary steps and accurately anchoring the target execution node that meets the user's specific fragmented needs. As a specific business scenario example, when a user requests, "Please print the enterprise qualification certificate I just queried," the system will directly identify the subsequent certificate printing node as the target execution node, logically silently skipping the preceding enterprise information query node.
[0014] After locking onto the target execution node in the intermediate state, the core engineering challenge for the system lies in ensuring the data integrity of underlying interface calls when the intermediate node suddenly starts. To this end, the system reads the pre-dependency specification of the target execution node and verifies the availability of its required input parameters. The pre-dependency specification defines the data environment necessary for the node's successful execution, and the required input parameters are indispensable data payloads in the underlying network requests (such as specific file resource locators or authentication tokens required for printing operations). The system rigorously verifies whether these parameters are already present in the current memory or context. If the verification finds upstream dependency gaps, the system's underlying graph computing engine will trace and fill in the missing parameters based on the verification results. In the specific processing logic, the system automatically traverses the upstream path along the pre-defined business topology directed edges, searching for pre-dependency nodes that can produce these missing parameters, and dynamically pulls these necessary pre-dependency nodes into the current execution sequence. If the target execution node is a completely self-contained operation with no upstream data dependencies, no filling is required. After this round of reverse graph traversal and repair based on gaps in the real data lineage, the system generates an execution workflow based on the preceding nodes and target execution nodes obtained through tracing, and determines the execution order of each node in the execution workflow. This step dynamically trims and reorganizes the originally rigid global static topology into a locally executed directed acyclic graph (DAG) that is logically rigorous and data-consistent, specifically customized for the current fragmented business needs.
[0015] After the customized dynamic workflow is generated, the nodes in the workflow are executed sequentially. To ensure accurate data flow and prevent state chaos during multi-node collaboration, the system saves the output parameters of each node to the skill variable pool in real time during execution. The skill variable pool is an isolated cache space in the system memory allocated independently for the current Agent session, used to persistently store intermediate business flow data. The result data returned after each successful underlying API call is serialized and written to this dedicated memory pool. Subsequently, during node execution, the system matches and retrieves values for the node's required input parameters from the skill variable pool or external tools based on preset parameter value priority rules. As a preferred parameter flow control mechanism, this preset parameter value priority rule strictly limits the trust hierarchy of data sources. For example, the system will force priority to read cached data from the skill variable pool of the current context, and only allow fallback calls to external tools (such as initiating new network requests or database queries) to dynamically retrieve data if it is missing from the variable pool. This hierarchical scheduling mechanism ensures the consistency and high reusability of business variables.
[0016] In this embodiment, a customized workflow is generated by dynamically semantically matching the target execution node and performing graph topology reverse dependency tracing and completion based on parameter verification results. Simultaneously, strict value control is implemented during execution using a dedicated variable library and parameter priority rules. This cleverly breaks the rigid physical constraint that traditional fixed workflows must be enforced from the starting node, reconstructing the execution graph driven by the actual input-output lineage dependencies of nodes. While endowing the system with extremely flexible and accurate response capabilities to high-frequency, fragmented user commands in B / G enterprise scenarios, it completely eliminates the redundant steps of tedious and ineffective pre-operations forced upon users. Furthermore, thanks to rigorous reverse dependency graph completion and priority-based variable caching scheduling, it effectively avoids problems such as repeated parameter acquisition and value overwriting errors. Without relying on uncontrollable real-time inference of large models, it absolutely guarantees the logical determinism of the underlying business execution chain and the accuracy of parameter flow, greatly reducing the risk of data loss and process execution crashes caused by sudden awakening of local intermediate nodes.
[0017] In one embodiment, step S20, which involves retrospectively completing the preceding nodes based on the verification results, includes: S21. If the target execution node has parameter dependencies on the upstream node, then tracing upwards will retrieve the upstream node with the corresponding input parameters. S22. If the same input parameter corresponds to multiple candidate nodes that can obtain the parameter, then select the candidate node closest to the target execution node as the preceding node to be traced. S23. If different input parameters correspond to multiple different upstream nodes, select the upstream node that is furthest from the target execution node as the tracing starting point, and include all the preceding dependent nodes between the tracing starting point and the target execution node into the execution workflow.
[0018] Specifically, this embodiment defines in detail the reverse reconstruction and addressing algorithms of the underlying workflow topology when the Agent system handles fragmented tasks. In complex enterprise-level intelligent agent operating environments, when the system suddenly starts with a non-initial intermediate business node as the target execution node, the operation of its underlying interface often faces severe data gaps. The system's underlying layer will first explore through the state machine. If the target execution node has parameter dependencies on upstream nodes, this means at the underlying data structure level that there is a missing required parameter slot in the API request (such as HTTP POST) that is about to be initiated. Moreover, in the preset data lineage contract, this missing slot is explicitly defined as the calculation result (i.e., output data) generated by other predecessor nodes pointed to by directed edges in the topology graph. Once the dependency is confirmed, the system will trigger a reverse topology graph traversal algorithm to search in reverse order along the directed graph of the data flow, tracing back to the upstream node that can obtain the corresponding input parameter, in an attempt to fill in the dangling data gap.
[0019] During the addressing process of reverse graph traversal, due to the complexity of microservice architecture, the system inevitably encounters overlapping branches and redundant nodes in the topology graph. If the same input parameter corresponds to multiple candidate nodes that can obtain the parameter, this means, both physically and logically, that there are multiple execution steps in the original long workflow that can produce the same type of variable. As a specific business example, in a long-link business flow, there may be an initial basic login node and a mid-term permission reset node. Both of these candidate nodes can refresh and output the key parameter, the global identity token, by calling the authentication microservice. At this time, the system will calculate the topology step size (i.e., the number of graph edges between each candidate node and the current target execution node) and strictly select the candidate node closest to the target execution node as the preceding node to be traced. The significance of selecting the closest node is that it can provide the current execution with the most up-to-date and most current context data payload, while directly pruning and cutting off earlier redundant interface call branches in the algorithm graph, avoiding unnecessary computational waste.
[0020] Furthermore, for more complex composite dependency scenarios, if different input parameters correspond to multiple different upstream nodes, this means that the current target execution node is a convergence hub of multiple data flows. For example, an approval and printing node may simultaneously depend on the approval status word output by the upstream qualification review node (parameter A) and the legal person credit code output by the even more upstream legal person information verification node (parameter B). Faced with this cross-level, multi-source heterogeneous data dependency, the system compares the absolute topological depth coordinates of all relevant upstream nodes in the directed acyclic graph (DAG) and forcibly selects the upstream node farthest from the target execution node (i.e., the node closest to the original graph start point) as the global tracing starting point. After setting the farthest node as the anchor point, the system follows the forward flow direction of the topological connection and fully incorporates all upstream dependent nodes between the tracing starting point and the target execution node into the execution workflow. As a preferred implementation, this incorporation is not a simple linear tiling, but rather fully preserves the original dependency execution sequence and data connection mapping relationship of each node between the tracing starting point and the target execution endpoint. The specific DAG memory assembly structure and pointer logic are not absolutely limited here.
[0021] As can be seen, in this embodiment, the system establishes an extremely sophisticated dependency pruning and inclusion mechanism at the underlying logic level. Its principle lies in utilizing network topology distance calculations to precisely eliminate redundant homogeneous interface call branches providing old, dirty data using the nearest principle, and establishing an absolutely secure encapsulation boundary for multi-source heterogeneous dependencies using the furthest principle. When facing the extremely fragmented instruction jumps of B / G-end enterprises, it can not only accurately fill all the data gaps required for the execution of the target node with minimal interface call cost, avoiding the loss of underlying parameters and microservice chain collapses caused by missing multi-source front-end nodes; it also completely eliminates the repeated execution of invalid redundant nodes, greatly improving the execution efficiency and absolute accuracy of parameter states of the reconstructed local workflow, perfectly ensuring the high availability and system robustness of enterprise-level intelligent agents under flexible scheduling in complex scenarios.
[0022] In one embodiment, step S10, namely obtaining the user's business requirements, matching target skills in the skill library based on the business requirements, and matching target execution nodes that meet the business requirements among the target skills, includes the following steps: S11. Read the metadata corresponding to each skill in the skill library and locate the target skill by semantic similarity matching; S12. Read the functional definitions of each functional node in the target skill, and determine the target execution node that meets the business requirements through semantic matching, so as to realize the execution starting point of any functional node.
[0023] Specifically, when processing highly divergent and non-standardized natural language input from B / G (enterprise or organization) users, the system first needs to narrow down the search and matching scope at a macro level to reduce computational overhead and improve response speed. The system reads the metadata corresponding to each skill in the skill library. In software engineering and intelligent agent system architecture, metadata is essentially a lightweight, structured collection of description files that globally summarize the complex underlying execution logic. As a concrete example, this metadata typically includes feature vectors such as the skill's globally unique identifier (ID), skill name, applicable business scenario description text, and frequently triggered instructions. The specific physical storage format (such as a JSON configuration file or a mapping table in a relational database) is not strictly limited here. After obtaining the user's natural language business requirements, the system's underlying natural language processing engine converts them into high-dimensional semantic vectors and performs deep semantic similarity matching by calculating the cosine distance or other multi-dimensional spatial distance metrics between the user's intent vector and the metadata vectors of each skill. This matching mechanism surpasses traditional literal regular expression extraction based on rigid keyword rules. It can accurately capture the true intent hidden in the user's non-standard text, and then quickly filter, select and locate the target skill from a huge global application pool.
[0024] After identifying the target skill at the macro level, to overcome the physical limitation that traditional fixed workflows must be started sequentially from the first starting node, the system further performs micro-level targeted matching. The system drills into the locked target skill, reading the functional definitions of each functional node within it. These functional definitions are pre-defined sets of local semantic boundaries and specific business action descriptions for each fine-grained atomic step (e.g., data query, risk control approval, form printing) that constitutes the complete workflow. The system also utilizes underlying semantic matching algorithms to perform a precise secondary comparison and mapping between the micro-operational intentions in the user's fragmented business needs and these discrete node functional definitions. This allows the system to directly determine the target execution node that meets the business requirements without invoking the entire fixed link. At the underlying code logic level, this operation is equivalent to transforming the traditional single-point static topology entry point into a distributed multi-point dynamic entry point matrix, completely opening up the technical channel using specific intermediate steps within the target skill as a sudden start-up environment, enabling any functional node to serve as the execution starting point. For example, when faced with a scenario-based fragmented need such as "I want to print the enterprise qualification certificate I just queried", the system, after locking onto the macro-level skill of "qualification processing", will directly match the internal post-processing certificate printing node as the target execution node, and silently skip the pre-processing condition input or information query nodes at the logical level.
[0025] In this embodiment, macro-level semantic similarity matching is performed by reading global skill metadata, and further drilling down to read the definitions of each internal functional node for micro-level secondary semantic localization. This ultimately achieves a feature processing mechanism that uses any functional node as the dynamic execution starting point of the workflow. This two-level progressive matching mechanism cleverly utilizes the multi-level intent understanding capabilities of natural language processing models, refining traditional coarse-grained skill-level routing to dynamic addressing at the atomic node level. This gives the system extremely high execution flexibility and adaptability to complex scenarios, enabling it to respond extremely accurately to and capture high-frequency, fragmented, jump-like commands generated by users in real B / G-end business scenarios. Simultaneously, it fundamentally breaks the rigid business sequence constraints, eliminating the inefficient and redundant operations where users are forced to complete the entire cumbersome pre-process to execute a single mid-to-late stage task, significantly improving the efficiency of human-computer interaction and the system's ability to directly access services for fragmented needs.
[0026] In one embodiment, the parameter value priority rule includes: firstly, reading parameter values from the skill variable library; if the corresponding parameter does not exist in the skill variable library, then reading parameter values from the task variable library; if the corresponding parameter does not exist in the task variable library, then obtaining parameter values by calling an external tool.
[0027] Specifically, this embodiment provides an in-depth technical definition of the data flow and parameter tracing mechanism between underlying microservice nodes when the Agent system executes fragmented workflows. In complex enterprise-level intelligent agent operating environments, a macro-level business often consists of multiple discrete nodes. When a target execution node is awakened, its underlying API interface heavily relies on accurate required input parameters. To address the technical pain points of chaotic parameter management, disordered value sources, and susceptibility to erroneous overwriting in existing technologies, the system constructs a strict three-level parameter value priority hierarchy in the underlying scheduling engine to standardize the data lineage flow path.
[0028] When the system prepares to match physical values for the required input parameters of the currently executing node (such as the total order amount or authorization token required by the payment node), the scheduler will prioritize reading the parameter values from the skill variable library. In the computer memory architecture, the skill variable library is a local, high-frequency cache space independently allocated for the specific Agent skill currently being executed. It stores in real time the output data of the preceding nodes within that skill. Prioritizing reading from this local cache is because the variables here have the highest time freshness and relevance to the business scenario, ensuring that the current node inherits the most direct contextual data.
[0029] However, in complex scenarios involving fragmented responses or cross-skill collaboration, the local cache within the current skill may not contain all the necessary parameters. Therefore, if the probe detects that the corresponding parameter is missing from the skill variable library (i.e., a local cache miss occurs), the underlying system logic will automatically degrade and read the parameter value from the task variable library. The task variable library plays the role of global context memory in the system's physical storage structure. It transcends the physical boundaries of a single skill, storing long-term shared variables accumulated by the current user throughout the entire macro-level dialogue task or multi-round interaction cycle. As an example, this could be a globally unique identifier (OneID) or enterprise department code that the user has already authenticated in the initial session. Retrieving parameters from the task level maximizes the reuse of existing global states and avoids requiring users to repeatedly provide the same background information.
[0030] Finally, if after the first two levels of memory addressing, the system finds that the corresponding parameter still does not exist in the task variable library (i.e., a global cache miss occurs), this means that the current execution environment is indeed severely lacking in the critical physical or business data required to advance the business. At this point, as a last resort, the system will call external tools to obtain the parameter value. External tools, at the network communication level, generally refer to external service units that are detached from the current Agent's memory environment, such as initiating new HTTP / RPC network requests to query remote databases, calling large language models for real-time inference, or calling physical sensors to collect real-time data. Placing external tool calls at the very bottom of the priority list is because such operations often involve high network communication overhead, potential network fluctuation risks, and longer system response latency.
[0031] In this embodiment, a three-tiered degradation addressing hierarchy is constructed, from a local skill variable library and a global task variable library to external tool calls. A highly rigorous and conflict-proof parameter transition state machine rule is established within the underlying scheduling architecture. This maximizes the reuse of high-confidence context parameters already acquired in system memory, fundamentally preventing parameter errors and data pollution caused by chaotic value sources. Simultaneously, it effectively curbs disordered and repeated calls to underlying interfaces, significantly reducing redundant network communication overhead and wasted computing power, and greatly improving the execution efficiency and absolute accuracy of parameter values in complex enterprise-level scenarios.
[0032] In one embodiment, during the execution of the workflow, the method further includes the following steps: S60. Monitor the labeling status of each node. If the currently executing node has a user-confirmed label or a user-input label, trigger the corresponding set of interactive cards. S70: Obtain the user input parameters or confirmation instructions based on the interactive card set, and continue to execute subsequent process nodes based on the obtained information.
[0033] Specifically, this embodiment provides a deep physical and logical definition of how to smoothly introduce human will and external entity data into the human-machine collaboration mechanism when the Agent system automatically schedules silent background tasks. During the sequential execution of the workflow by the underlying scheduling engine (such as a workflow engine based on a directed acyclic graph), the system does not perform completely blind closed-loop black-box operations. The system's internal execution probes monitor the annotation status of each node in real time. In the underlying computer data structure, the annotation status is typically represented by a specific Boolean identifier or state enumeration value appended to the node object's metadata attribute field, used to declare to the scheduler whether the underlying microservice interface needs to break the machine's silent state before being truly invoked.
[0034] When the execution probe slides along the graph topology to a specific node, if the system detects a user confirmation label or user input label at the current execution node, this means, at the underlying system call logic, that a hard state machine breakpoint that must be blocked has been encountered. As a specific business scenario example, user confirmation labels are usually assigned to business nodes involving high-risk control, such as internal fund transfers or the overwriting and modification of sensitive core data. Acting as a physical barrier, it forces the automatic operation of the machine to be suspended at this moment, awaiting explicit human authorization. User input labels, on the other hand, indicate that the current node contains dynamic, isolated parameters that cannot be traced back through the data lineage of previous nodes or deduced from the system context, and must be provided in real-time by the external physical world, such as a mobile phone verification code received immediately by the user or temporary supplementary comments. At this time, the underlying control logic of the system will immediately suspend the current silent execution thread in memory, blocking the automatic scheduling of subsequent nodes, and push and trigger the corresponding set of interactive cards to the front-end terminal device through the system bus or long-connection channel. At the front-end presentation level, interactive card sets are highly cohesive, visual, multimodal graphical user interface components that contain specific contextual business information, input form controls (such as text input boxes and drop-down radio buttons), or operation authentication buttons (such as agree / deny). The specific front-end rendering framework or underlying communication protocol used is not absolutely limited here.
[0035] After the front-end device successfully renders the interactive interface, the underlying graph execution engine enters an asynchronous waiting state to obtain user input parameters or confirmation commands based on the interactive card set. When the real user completes the input of the required data or clicks the risk confirmation button on the terminal screen, the front-end application injects the data payload containing entity business variables or action commands back into the suspended back-end execution environment through a callback interface. The system receives and verifies these feedback information in memory, accurately fills the missing parameters input by the user into the parameter slots of the current node (i.e., completes the parameter completion of the underlying API call), and then sends a thread wake-up signal to the scheduling engine. Upon receiving this release command and confirming that the call conditions of the current node have been completely closed based on the obtained information, the execution engine immediately releases the memory blocking state and smoothly drives the topology pointer to continue executing subsequent process nodes until the entire customized workflow is successfully completed.
[0036] As can be seen, this embodiment introduces a real-time monitoring mechanism for node interaction status within the core of the underlying execution engine. When encountering hard breakpoints indicating high-risk risk control confirmation or missing dynamic parameters, it suspends the underlying thread for asynchronous information collection by triggering a set of front-end interaction cards. Finally, execution seamlessly resumes based on reverse-filled instructions or parameters. This processing mechanism cleverly embeds controlled human interaction barriers and data replenishment channels into a fully automated machine execution graph. While maximizing the efficiency of automated silent workflow for enterprise-level agents, it absolutely guarantees from the underlying system architecture that high-risk business control links are not executed by machines without authorization. Furthermore, it effectively solves the problem of hard process crashes or interruptions caused by temporary missing external dynamic data, achieving flexible decoupling and seamless collaboration between humans and machines. This significantly improves the final success rate of complex B / G-end business models in fragmented scenarios and the overall security and fault tolerance of the system.
[0037] In one embodiment, the method further includes the following steps: S80: Real-time synchronization and feedback of the execution status of each node in the execution workflow, including execution in progress, execution successful, and execution failed; S90. If a node is detected to have failed to execute and the node has not defined a corresponding handling solution, then the global exception fallback logic is triggered.
[0038] Specifically, this embodiment provides an in-depth technical definition of the end-to-end runtime monitoring visualization and system-level fault tolerance and recovery mechanism of the Agent system under complex business orchestration. In complex business scenarios targeting B / G clients (enterprises or organizations), customized workflows composed of multiple underlying microservices are highly susceptible to interruption due to network fluctuations, third-party interface rate limiting, or data verification failures. To break the black-box state of large language model calls and backend interface calls, the system incorporates a global bypass listening and state machine reporting mechanism into the underlying scheduling engine. During the sequential execution of the workflow by the underlying pointers, probes synchronize and report the execution status of each node in the workflow in real time. In the underlying computer logic, the execution status is an enumerated identifier or memory flag pointing to the lifecycle of the current microservice thread. As a concrete engineering implementation example, when the system has just initiated a network addressing request to the target API but has not yet received a response body, the probe marks the memory state of the node as "in progress" and pushes it to the front-end UI panel to display a loading animation; when the system successfully receives a valid HTTP 200 response code and completes the output parameter parsing, the state machine transitions to "execution successful," and the node lights up in the visualization graph; however, when encountering serious errors such as request timeout, gateway access denied (HTTP 403), or internal calculation throwing a null pointer, the state machine is immediately marked as "execution failed." This state data is transmitted in real time and asynchronously to the front-end end user and the back-end management and maintenance platform through the system's internal message bus; the specific communication protocol is not absolutely limited here.
[0039] While achieving end-to-end state visualization, the system must possess the capability to intervene safely in cases of execution failure. When the scheduling engine detects that the state machine of a node has transitioned to execution failure, the system will not allow threads to suspend or cause the entire Agent service to crash. Instead, the system's exception handling dispatcher will first read the node's underlying configuration metadata to examine whether it has a predefined local exception handling strategy (e.g., locally defined retries three times after failure or calling a backup interface). If a node execution failure is detected and the node has not defined a corresponding handling plan, logically this means that the sudden failure exceeds the self-healing boundary of the single-point microservice. Therefore, the system will immediately block the delivery of subsequent nodes to be executed and throw an exception upwards, triggering the global exception fallback logic. This global exception fallback logic is a highest-priority security protection network pre-defined at the outermost layer of the Agent runtime framework within the system architecture. As a specific example of business fault tolerance, this fallback logic might include: immediately sending a rollback command to the database to undo sensitive state changes already executed in the current batch (such as preventing funds from being deducted unilaterally before the business is completed), writing detailed stack error logs and snapshots of the input parameters that caused the crash to a persistent operation and maintenance audit database, and simultaneously smoothly outputting friendly prompts encapsulated in natural language to end users (such as "The current external service is busy, please try again later"), rather than directly exposing the underlying garbled error messages to the front end.
[0040] In this embodiment, a runtime monitoring and defense system that balances high transparency and strong fault tolerance is constructed by embedding state machine probes into the scheduling engine of the execution workflow to synchronize and provide real-time feedback on the execution, success, and failure status of nodes. When a node fails uncontrollably, a mandatory takeover is initiated and global exception fallback logic is triggered. The principle behind this system is to break the black-box state of microservice calls using a lifecycle event subscription mechanism and to use a globally unified exception capture interceptor as the last line of defense against system-wide cascading failures. The specific technical effects are: complete visualization of the Agent's skill status throughout the entire workflow, enabling system administrators and end users to accurately and intuitively locate the specific problem node causing the blockage, greatly reducing the cost of maintenance, troubleshooting, and manual debugging of complex workflows; and, thanks to the robust global exception fallback takeover, completely eliminating system-wide deadlocks or persistent dirty data pollution caused by network anomalies or logical errors in a single node, significantly improving the robustness and business security of enterprise-level intelligent agent applications under extreme conditions.
[0041] In one embodiment, step S30, namely determining the execution order of each node in the execution workflow, includes: S31. Logically connect the preceding nodes, target execution nodes, and subsequent process nodes obtained from tracing to construct the logical link of the execution workflow.
[0042] Specifically, this embodiment provides an in-depth technical definition of the engineering implementation mechanism for how the Agent system dynamically reconstructs a complete executable code chain from the underlying data structure level after responding to fragmented instructions. In complex enterprise-level workflow orchestration, when the system allows sudden startup from any intermediate node (i.e., the target execution node), the originally fixed global workflow topology is broken. In order for the underlying scheduling engine to continue operating, the system must assemble a completely new temporary execution track in memory in real time. When determining the execution order of each node in the execution workflow, the system scheduling engine extracts three types of core components: the first type is the preceding node that is traced and completed by the preorder reverse graph traversal algorithm and is used to provide missing parameters (e.g., the authentication token acquisition interface called in advance to perform the printing operation); the second type is the target execution node itself that accurately hits the user's current fragmented intent (e.g., the document printing interface); and the third type is the subsequent process node that is naturally attached to the target execution node in terms of physical and business logic in the original target skill global blueprint (e.g., the log recording interface or system message push interface after printing is completed).
[0043] After acquiring the images of these three types of discrete microservice nodes, the system's underlying graph builder logically concatenates the traced preceding nodes, target execution nodes, and subsequent process nodes to construct the logical links of the execution workflow. In the underlying data structure of a computer, this logical concatenation is not simply placing these nodes into a one-dimensional linear array, but rather re-establishing the memory pointers and directed edges of a directed acyclic graph (DAG) based on their input-output data lineage relationships. Specifically, the system precisely maps and binds the output parameter memory addresses of the preceding nodes to the input parameter slots of the target execution node, and simultaneously binds the output parameter addresses of the target execution node to the input parameter slots of subsequent process nodes. As a concrete engineering implementation example, the system may solidify this concatenation relationship by dynamically generating a JSON or YAML orchestration configuration file that only exists in the current dialogue session; the specific data carrying protocol is not absolutely limited here. This splicing operation logically smooths out the context gap caused by the sudden wake-up of intermediate nodes, establishes the absolute order of data flow, and thus stitches the originally fragmented microservice interfaces back into a closed-loop local execution engine with a strict execution sequence.
[0044] In this embodiment, the preceding nodes obtained through dynamic tracing, the target execution node carrying the core intent, and the original subsequent process nodes are logically spliced and linked by pointers based on data lineage in the underlying data structure. This processing logic cleverly utilizes a graph reconstruction algorithm to generate a locally executed directed acyclic graph customized for the current fragmented request in real time within the system's runtime environment. Its principle lies in stitching together the gap between the dynamic tracing nodes and the existing static process through forced mapping and binding of input and output variables. This achieves seamless process assembly when complex agent skills face non-standardized jump execution, fundamentally ensuring that even if the system forcibly cuts into an isolated step in the middle of the overall macro business flow, its forward dependency preparation and backward closing actions can still be completely wrapped and flow correctly in sequence. This completely eliminates the business logic failures or underlying state machine errors caused by fragmented execution steps, greatly improving the system's execution integrity and architectural robustness in dealing with fragmented task scenarios.
[0045] In one embodiment, after verifying the availability of the required input parameters of the target execution node, the method further includes: If the target execution node has no dependency on the upstream node, then the target execution node is used as the starting point of the process, and all execution steps after the target execution node are read to generate the execution workflow.
[0046] Specifically, this embodiment provides a deep logical definition of the efficient scheduling strategy for underlying microservice nodes with self-closing characteristics when the Agent system processes fragmented business instructions. In complex enterprise-level workflow orchestration, not all target execution nodes are deeply embedded in intricate data dependency chains. After the system's graph computation probe completes the review and verification of the target execution node's pre-dependency descriptions, if it determines that the target execution node has no dependency on upstream nodes, this means, in terms of underlying computer data structures and network communication protocols, that the required data payload slots of the API interface to be invoked (e.g., HTTP GET / POST requests) are empty, or that the required parameters have been directly provided by the user in natural language dialogue, or can be directly inferred from the global context, without needing to wait for any intermediate dynamic variables output by the pre-interface computation.
[0047] The system's underlying control engine will immediately halt the upstream reverse graph traversal addressing algorithm and directly use the target execution node as the starting point of the process. At the memory scheduling level, this is equivalent to hard-anchoring the initial pointer of the current execution batch to the physical memory address of the target execution node, directly promoting it from the middle of the workflow to the first node of the current dynamic workflow.
[0048] However, identifying the starting node does not equate to executing that node in isolation. To ensure the continuity of business logic and the integrity of system state, after determining the starting point, the system performs a forward graph traversal along the lines of a pre-defined directed acyclic graph (DAG), and reads all execution steps following the target execution node to generate an execution workflow. In the underlying logic, these execution steps include derived microservices with a positive temporal correlation to the target execution node, such as a node to generate a summary summary after retrieval, a node to record user query logs, or a node to push messages to the client. By extracting this series of positively dependent nodes sequentially and reassembling them in memory, the system ultimately constructs a logically rigorous, coherent, and lightweight local execution workflow without executing any redundant pre-execution steps. The specific forward graph traversal algorithm and memory data format are not absolutely limited here; their core purpose is to ensure that no business cleanup actions after isolated intent execution are omitted.
[0049] In this embodiment, when the target execution node is confirmed to have no upstream data lineage dependency, the reverse tracing computational cost is decisively abandoned. Instead, it is directly anchored as the absolute physical starting point of the underlying scheduling, and the associated subsequent execution steps are extracted in a forward manner to dynamically close the loop and generate a local execution workflow. This cleverly utilizes the self-closing attribute of node parameters as a pruning condition for graph computation. The principle is to dynamically skip all redundant pre-processing steps in the original long link that do not contribute actual data. When facing highly fragmented and independently intended instructions from B / G enterprises, this approach maximizes the saving of network request overhead and graph reconstruction computational cost, compressing the response latency of microservices to the limit. At the same time, thanks to the leak prevention mechanism of forward reading of subsequent steps, it ensures that even single-point tasks initiated halfway can still maintain a very high standard of business logic integrity and the rigor of post-state machine transitions.
[0050] like Figure 2 and Figure 3 As shown, this diagram illustrates the underlying entity relationship architecture of the system. This diagram mainly shows how to define business boundaries and manage user information, and is the core of realizing the global context of the task variable library.
[0051] User and tag system: The user entity includes oneid, user nickname, mobile phone number and gender.
[0052] The tag library and the user tag library are linked via oneid. This corresponds to the global context memory mentioned in the embodiment, such as storing the user's globally unique identifier, to reuse parameters across different skill executions and avoid repeatedly querying the user.
[0053] Specifications and Project Definitions: Specifications include ID, name, terminal device, design specifications, and type. The project, as the core container, integrates project code, project name, integrated application, HostAgent, and specifications. This data constitutes the macro-background of the B / G-end business scenario and determines the logical boundaries of Agent execution.
[0054] Skill definition - the cornerstone of matching: A skill entity explicitly includes a name, description, and instructions.
[0055] This directly corresponds to the process mentioned in step S11 of reading the metadata corresponding to each skill in the skill library. The system calculates the semantic similarity between the user intent vector and the description or instruction here, thereby accurately locating the target skill in the vast application pool.
[0056] An Agent entity includes a name, type, underlying model (large language model), memory, opening remarks, and associated skills.
[0057] The memory attribute supports the persistence of task variables; skill association defines the range of capabilities that the Agent can invoke. Module entities (including module code, module name, and business Agent) act as intermediaries, linking projects to specific Agents. This embodies the distributed multi-point dynamic entry matrix mentioned in the embodiment, enabling the system to flexibly schedule specific Agent nodes according to the needs of business modules. Through the skill descriptions and instruction fields in the diagram, the system can drill down and match target execution nodes that conform to user instructions. Through the user / tag Agent memory in the diagram, the system constructs a descending addressing hierarchy from the skill variable library to the task variable library, ensuring the accuracy of parameter values. Through the hierarchical association of project-module-Agent-skill, the system can obtain a complete logical link reference when generating a dynamic execution workflow (DAG).
[0058] like Figure 4 As shown, Figure 4 This embodiment of the application provides a workflow topology diagram, illustrating a topology composed of main function 1 / main function 2 / main function 3, branch scenario 1 / branch scenario 2, and auxiliary function 1 / auxiliary function 2. This corresponds to the directed acyclic graph mentioned in the embodiment. When a user issues a fragmented command (such as directly executing main function 2), the system performs a reverse graph traversal based on this diagram, automatically filling in the missing dependency parameters in the branch scenario or main function 1. The directed arrows in the flowchart reflect the execution sequence of each node. The system ensures the logical integrity when fragmented tasks are initiated by logically concatenating the preceding nodes, the target execution node, and subsequent nodes.
[0059] In one embodiment, an Agent skill execution dependency tracing system includes: The intent and node matching unit is used to obtain the user's business needs, match the target skills in the skill library based on the business needs, and match the target execution nodes that meet the business needs in the target skills. The dependency verification and tracing unit is used to read the prerequisite dependency descriptions of the target execution node, verify the availability of the required input parameters of the target execution node, and trace and complete the prerequisite nodes based on the verification results. The process execution control unit is used to generate an execution workflow based on the preceding nodes and target execution nodes obtained through tracing, and to determine the execution order of each node in the execution workflow, and execute each node in the execution workflow in sequence. The variable library and parameter management unit is used to save the output parameters of each node to the skill variable library in real time during the node execution process; The interaction triggering and parameter completion unit is used to obtain user feedback information by triggering the corresponding interaction card set to complete the parameter completion if user confirmation or user input annotation is detected in the target node during node execution. The exception handling and status feedback unit is used to trigger fallback logic when a node execution exception occurs, and to provide real-time feedback to the terminal on the execution status of each node in the execution workflow.
[0060] Specifically, this embodiment deeply deconstructs the system-level engineering solution for achieving dynamic dimensionality reduction and closed-loop control of the workflow of a large language model intelligent agent from the perspective of underlying software architecture and modular hardware collaborative operation mechanism. In the highly complex and fragmented business environment facing B / G ends (enterprises or organizations), traditional monolithic applications or tightly coupled architectures are difficult to balance execution flexibility and determinism. To this end, this system is decoupled into six highly specialized core collaborative execution units in its architecture. As the semantic router of the entire system, the intent and node matching unit carries the retrieval computing power of the natural language processing model and vector database at the physical level. After receiving non-standardized natural language business requirements, this unit first reads the metadata (i.e., global skill description vector) in the underlying skill library at the macro level, and matches the target skill through high-dimensional cosine similarity calculation; then it drills down further into the skill, reads the fine-grained functional node definition for micro-level secondary semantic alignment, thereby accurately extracting the specific intermediate steps required by the user as the target execution node. This two-level progressive routing mechanism completely breaks the physical limitation of traditional systems that can only provide a static single entry point, reducing coarse-grained skill calls to atomic-level node-level dynamic addressing.
[0061] After locking onto the target node, to prevent the underlying microservices from crashing due to sudden system calls, the dependency verification and tracing unit, as the system's built-in graph computing engine, takes over control. This unit reads the target node's preset dependency descriptions, examines the required data payloads carried by its underlying API requests, and verifies the availability of these input parameters in memory. Once a data gap is detected, the unit initiates a reverse graph traversal algorithm, tracing upstream along the data lineage to accurately locate and extract the necessary preceding microservice nodes that can produce this missing data, and pulls them into the current cache sequence. This parameter gap-driven dynamic completion mechanism mathematically and physically ensures that isolated nodes have a 100% self-consistent data operation microenvironment when forcibly awakened. Subsequently, the process execution control unit, as the scheduling hub of the directed acyclic graph, binds pointers and logically assembles the traced discrete preceding nodes and the target execution node in memory, generating a local execution workflow with a strict execution sequence, and uses underlying communication protocols (such as RPC or HTTP) to sequentially issue microservice call instructions, driving data to flow forward between nodes.
[0062] During the high-speed operation of the microservice cluster, the variable library and parameter management unit acts as a global state machine and a high-frequency cache controller. It allocates a dedicated skill variable library in memory for the current session. Whenever the process execution control unit completes the scheduling of a node, this unit captures and serializes the output parameter results of that node in real time, persisting them to the skill variable library. This constructs an extremely robust parameter read / write state machine, enabling subsequent nodes to directly reuse high-confidence variables from the high-frequency cache, avoiding repeated network communication to the remote database. Simultaneously, the interaction triggering and parameter completion unit acts as a security gateway for human-machine collaboration. Its internal probes monitor the metadata annotations of nodes about to be issued in real time. When encountering high-risk risk control nodes or nodes dependent on external information with user confirmation or user input annotations, this unit immediately suspends the current silent execution thread in memory and pushes a visual interactive card set interface to the terminal through a long connection channel. After obtaining feedback information generated by the user's physical operation (such as confirmation commands, verification code characters) and completing the underlying parameter slot completion, this unit sends a wake-up signal to the scheduling engine to release the thread. In addition, the exception handling and status feedback unit, as the system's global bypass monitoring bus and safety fallback component, collects the lifecycle markers of each execution unit in real time and pushes fine-grained statuses such as "in execution", "execution successful", and "execution failed" to the front end synchronously. When encountering undefined exceptions such as network avalanche or low-level interface timeout, this unit forcibly takes over the control flow and triggers preset global fallback logic (such as performing database transaction rollback operations and outputting a friendly prompt after the mask) to prevent low-level garbled characters from being exposed or dirty data from being polluted.
[0063] The aforementioned system architecture deeply decouples the agent's operating environment into six highly cohesive modules: intent routing and matching, graph topology reverse tracing, DAG scheduling and control, global state caching, human-machine breakpoint interaction, and global anomaly takeover. Its principle lies in leveraging the modular collaboration of distributed systems to transform the unstable planning of large models into controlled semantic routing, and dynamically assembling the execution graph driven by parameter lineage verification, supplemented by state caching and breakpoint suspension mechanisms. The specific technical effects of this are: at the system level, it endows the agent with high-dimensional flexibility and direct access capabilities when facing extremely fragmented and non-standardized enterprise-level instructions; and through the close cooperation of underlying hardware computing power in parameter tracing, state machine anti-conflict, and global fault-tolerant rollback, it absolutely guarantees the integrity of data flow and high security of business execution under the condition of sudden wake-up of any node in the local workflow, significantly reducing the operation and maintenance costs and crash rate of complex business systems in high-pressure environments at the B / G level.
[0064] For further explanation of this system, please refer to the description of the aforementioned method embodiments, which will not be repeated here.
[0065] It should be understood that the sequence number of each step in the above embodiments does not imply the order of execution. The execution order of each process should be determined by its function and internal logic, and should not constitute any limitation on the implementation process of the embodiments of this application.
[0066] In one embodiment, such as Figure 5 As shown, a computer device is provided, wherein the processor of the computer device is used to provide computing and control capabilities, the computer device includes a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein when the processor executes the computer program, it implements the steps of an Agent skill execution dependency tracing method as described in any of the preceding claims.
[0067] In one embodiment, a computer-readable storage medium is provided having a computer program stored thereon, which, when executed by a processor, implements the steps of the Agent skill execution dependency tracing method described above.
[0068] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a non-volatile computer-readable storage medium, and when executed, it can include the processes of the embodiments of the methods described above. Furthermore, any references to memory, storage, user databases, or other media used in the embodiments provided in this application can include non-volatile and / or volatile memory.
[0069] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the above-described division of functional units and modules is used as an example. In practical applications, the above functions can be assigned to different functional units and modules as needed, that is, the internal structure of the system can be divided into different functional units or modules to complete all or part of the functions described above.
[0070] The above-described embodiments are only used to illustrate the technical solutions of this application, and are not intended to limit them. Although this application has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features. Such modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of this application, and should all be included within the protection scope of this application.
Claims
1. A method for tracing agent skill execution dependencies, characterized in that, The method includes: Obtain the user's business requirements, match target skills in the skill library based on the business requirements, and match target execution nodes that meet the business requirements among the target skills; Read the prerequisite dependency description of the target execution node, verify the availability of the required input parameters of the target execution node, and retrospectively complete the prerequisite nodes based on the verification results; Based on the preceding nodes obtained through tracing and the target execution node, an execution workflow is generated, and the execution order of each node in the execution workflow is determined; Each node in the execution workflow is executed sequentially, and the output parameters of each node are saved to the skill variable library in real time during the execution process. When a node is executed, values are matched and retrieved from the skill variable library or external tools based on preset parameter value priority rules.
2. The method according to claim 1, characterized in that, The process of tracing and supplementing the preceding nodes based on the verification results includes: If the target execution node has parameter dependencies on the upstream node, then tracing upwards can obtain the upstream node with the corresponding input parameters; If the same input parameter corresponds to multiple candidate nodes that can obtain the parameter, then the candidate node closest to the target execution node is selected as the preceding node to be traced. If different input parameters correspond to multiple different upstream nodes, the upstream node furthest from the target execution node is selected as the tracing starting point, and all preceding dependent nodes between the tracing starting point and the target execution node are included in the execution workflow.
3. The method according to claim 1, characterized in that, The process of obtaining user business requirements, matching target skills in the skill library based on the business requirements, and matching target execution nodes that meet the business requirements from the target skills includes: Read the metadata corresponding to each skill in the skill library, and locate the target skill by semantic similarity matching; The functional definitions of each functional node in the target skill are read, and the target execution node that meets the business requirements is determined through semantic matching, so as to realize the execution starting point of any functional node.
4. The method according to claim 1, characterized in that, The parameter value priority rules include: Parameter values are read first from the skill variable library; If the corresponding parameter does not exist in the skill variable library, the parameter value is read from the task variable library; If the corresponding parameter does not exist in the task variable library, the parameter value is obtained by calling an external tool.
5. The method according to claim 1, characterized in that, During the execution of the execution workflow, the method further includes: Monitor the labeling status of each node. If the current execution node contains a user confirmation label or a user input label, then the corresponding set of interactive cards will be triggered; Based on the set of interactive cards, the system obtains the parameters or confirmation instructions input by the user and continues to execute subsequent process nodes according to the obtained information.
6. The method according to claim 1, characterized in that, The method further includes: The execution status of each node in the execution workflow is synchronized and fed back in real time, including execution in progress, execution successful, and execution failed. If a node fails to execute and no corresponding handling solution is defined for that node, then the global exception fallback logic is triggered.
7. The method according to claim 1, characterized in that, Determining the execution order of each node in the execution workflow includes: The preceding nodes obtained through tracing, the target execution node, and the subsequent process nodes after the target execution node are logically concatenated to construct the logical link of the execution workflow.
8. The method according to any one of claims 1-7, characterized in that, After verifying the availability of the required input parameters of the target execution node, the method further includes: If the target execution node has no dependency on the upstream node, then the target execution node is used as the starting point of the process, and all execution steps after the target execution node are read to generate the execution workflow.
9. An Agent skill execution dependency tracing system, characterized in that, The system includes: The intent and node matching unit is used to obtain the user's business needs, match target skills in the skill library based on the business needs, and match target execution nodes that meet the business needs in the target skills; The dependency verification and tracing unit is used to read the prerequisite dependency description of the target execution node, verify the availability of the required input parameters of the target execution node, and trace and complete the prerequisite nodes based on the verification results. The process execution control unit is used to generate an execution workflow based on the preceding nodes obtained through tracing and the target execution node, and to determine the execution order of each node in the execution workflow, and execute each node in the execution workflow in sequence. The variable library and parameter management unit is used to save the output parameters of each node to the skill variable library in real time during the node execution process; The interaction triggering and parameter completion unit is used to obtain user feedback information by triggering the corresponding interaction card set to complete the parameter completion if user confirmation or user input annotation is detected in the target node during node execution. The exception handling and status feedback unit is used to trigger fallback logic when a node execution exception occurs, and to provide real-time feedback to the terminal on the execution status of each node in the execution workflow.
10. A computer device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that, When the processor executes the computer program, it implements the steps of the method as described in any one of claims 1-8.