Intelligent agent linkage method based on intention shunt triggering multi-skilled chain cooperation

Abstract

The application discloses an agent linkage method based on intention shunt triggering multi-skill chain cooperation, relates to the technical field of agent cooperative scheduling, and comprises the following steps: receiving a macro transaction target, extracting a transaction object, a time window, a constraint condition and a target preference, and generating an intention feature vector; the intention feature vector is matched with a process template library to generate an intention shunt label and a multi-stage task chain arranged according to dependence; multi-skill agents are registered and standardized input and output interfaces are configured, a callable resource pool is formed according to resource occupation and data quality; according to the intention shunt label and the callable resource pool, a first-stage skill agent of the multi-stage task chain is triggered, and a stage execution result is obtained; dependence judgment and data contract verification are performed on adjacent stages, a previous stage output is mapped into a next stage input, and chain calling is performed; the execution results of all stages are summarized for closed loop verification and state synchronization, and final execution feedback information is generated and output.

Description

Technical Field

[0001] This invention relates to the field of intelligent agent collaborative scheduling technology, specifically to an intelligent agent linkage method based on intent-triggered multi-skill chain collaboration. Background Technology

[0002] With the development of power market reform, the energy internet, and intelligent dispatch technology, business decision-making in power trading scenarios is gradually shifting from being driven by human experience to being driven by data and intelligent collaboration. Multi-agent technology is being introduced into stages such as transaction submission, load forecasting, price optimization, and risk verification to facilitate automated collaboration between different business capabilities. Simultaneously, large language models and intent recognition technology are being used to understand the macro-level trading objectives proposed by users, enabling natural language instructions to be converted into executable business tasks. However, power trading tasks often involve multiple conditions simultaneously, including trading objects, time windows, price constraints, energy preferences, and execution deadlines. A single agent or simple intent classification method struggles to fully express the dependencies between tasks.

[0003] Existing agent collaboration methods typically focus on invoking one or more target agents based on identified user intent, suitable for handling interactive tasks with relatively clear boundaries and short execution chains. However, in complex power trading scenarios, user-proposed goals are often not single operations but require continuous stages such as data collection, quantitative calculation, application execution, and result verification. Existing methods have a coarse-grained semantic decomposition of macro-level trading goals and lack a mechanism to convert trading objects, time windows, constraints, and goal preferences into computable features and match them with process templates, easily leading to unstable task chain selection. While some solutions can invoke multiple agents, there is a lack of unified filtering for input / output interfaces, resource status, and data quality between different agents, and there are no executable data contract verification rules to determine whether the output of the previous stage can be used as the input of the next stage. In trading tasks with high real-time requirements, this approach is prone to issues such as missing stage inputs, inconsistent field types, inability to accurately roll back after execution timeouts, and difficulty in tracing final feedback. Therefore, there is a need for an intelligent agent linkage method that can continuously connect intent diversion, resource screening, chain triggering to closed-loop feedback, so that macro transaction objectives can be stably transformed into a multi-stage task chain arranged according to dependencies, and the execution results of each stage can be verified, synchronized and rewritable. Summary of the Invention

[0004] In view of the above-mentioned problems, the present invention is proposed.

[0005] Therefore, the technical problem solved by this invention is that existing multi-agent collaborative methods based on intent recognition have insufficient granularity in decomposing the semantics of macro-transaction targets, lack a chain-like calling mechanism that arranges multiple skill agents according to stage dependencies, make it difficult to uniformly verify stage input / output interfaces, resource status and data quality, and how to stably convert intent diversion results into an executable task chain and complete closed-loop feedback.

[0006] To address the aforementioned technical problems, this invention provides the following technical solution: an intelligent agent linkage method based on intent-triggered multi-skill chain collaboration, comprising: receiving a macro-level transaction objective; extracting the transaction object, time window, constraints, and target preferences to generate an intent feature vector; matching the intent feature vector with a process template library to generate intent-triggered labels and a multi-stage task chain arranged by dependencies; registering multi-skill intelligent agents and configuring standardized input / output interfaces, forming a callable resource pool based on resource consumption and data quality; triggering the first-stage skill intelligent agent of the multi-stage task chain based on the intent-triggered labels and the callable resource pool to obtain the stage execution result; performing dependency judgment and data contract verification on adjacent stages, mapping the output of the previous stage to the input of the next stage and chaining them; summarizing the execution results of each stage for closed-loop verification and state synchronization, generating and outputting final execution feedback information.

[0007] As a preferred embodiment of the intelligent agent linkage method based on intent-triggered multi-skill chain collaboration described in this invention, the generation of intent feature vectors includes: receiving macro-level transaction targets in natural language or structured form; performing text normalization and semantic parsing on the macro-level transaction targets; extracting four types of fields involved in the judgment: transaction object, time window, constraints, and target preference; converting the four types of fields into corresponding codes; and forming the intent feature vector in the order of transaction object code, time window code, constraint code, and target preference code; converting each process template in the process template library into a template vector according to the same field order; multiplying the codes at the same position in the intent feature vector and the template vector item by item, summing the results, and then dividing by the product of the magnitude of the intent feature vector and the magnitude of the template vector to obtain the matching similarity between the intent feature vector and each process template; and writing all matching similarities into the matching result set according to the corresponding process template identifier.

[0008] As a preferred embodiment of the intelligent agent linkage method based on intent-triggered multi-skill chain collaboration described in this invention, the generation of intent-triggered labels and multi-stage task chains arranged by dependency includes: reading all matching similarities in the matching result set and determining the maximum similarity; when the maximum similarity is not less than 0.8, selecting the corresponding process template as the multi-stage task chain; when the maximum similarity is not less than 0.6 and less than 0.8, selecting several process templates with the highest matching similarity ranking, dividing the matching similarity of each process template by the sum of the matching similarities of the selected process templates to obtain the corresponding template weight; for each stage position in the task chain, reading the candidate stage types of the selected process templates at the same stage position, performing weighted voting on the candidate stage types, and only adding the corresponding template weight to the templates whose candidate stage types are consistent with the template stage types, and taking the one with the highest weighted score. The stage type is used as the final stage type for the corresponding stage position. When multiple stage types have the same score, the template stage type with the smallest target preference encoding distance is selected. When the maximum similarity is less than 0.6, the macro transaction target is returned for re-analysis. The semantic vector of the transaction instruction is input into the intent classification weight matrix to obtain the classification score of each intent category. The classification score is exponentially normalized and the maximum category probability is taken as the intent confidence. When the intent confidence is not less than 0.85, the historical case verification continues. The historical case verification calculates the angle similarity between the current intent feature vector and the historical case feature vector. When the angle similarity is not less than 0.7, intent diversion labels are generated. The information entropy function is introduced to calculate the diversion uncertainty based on the allocation probability of each task stage. When the diversion uncertainty is less than 0.5, the multi-stage task chain is confirmed to be stable. Otherwise, the final stage type for the corresponding stage position is re-determined.

[0009] As a preferred embodiment of the agent linkage method based on intent-triggered multi-skill chain collaboration described in this invention, the formation of a callable resource pool includes: reading the skill description, input specifications, output specifications, timeout time, and retry strategy of each skill agent; writing the input specifications, output specifications, timeout time, and retry strategy into a unified interface structure; and registering the corresponding skill type and call address with the resource pool; during the registration process, collecting the processor usage, memory usage, and bandwidth usage required for the operation of the corresponding skill agent; multiplying the ratio of processor usage to processor quota, the ratio of memory requirement to available memory, and the ratio of bandwidth requirement to available bandwidth by preset weights and then summing them to obtain the comprehensive resource utilization rate; when the comprehensive resource utilization rate is... When the source occupancy rate is higher than 0.9, a resource expansion warning is written and the corresponding skill agent is temporarily suspended from entering the callable state. When the overall resource occupancy rate is not higher than 0.9 and the test call return result meets the interface specification, the corresponding skill agent is written into the callable resource pool. For the data output by the collection-type skill agent, the missing rate, the number of outliers, and the total number of data points are read. The missing rate is converted into a missing penalty coefficient, and the ratio of the number of outliers to the total number of data points is converted into an anomaly penalty coefficient. The two penalty coefficients are combined to form a data quality score. When the data quality score is lower than 0.85, the corresponding data enters the re-collection or completion process. When the data quality score is not lower than 0.85, the standardized output is written into the task context and awaits invocation.

[0010] As a preferred embodiment of the agent linkage method based on intent-triggered multi-skill chain collaboration described in this invention, the following steps are included: obtaining the stage execution result includes reading the task chain identifier, first stage type, and task context from the intent-triggered tag; matching skill agents with the same skill type and in a callable state from the callable resource pool; assembling the call parameters according to the corresponding standardized input interface; recording the start time when the call begins; recording the end time, return status code, output data, and number of retries when the call ends; using the difference between the end time and the start time as the actual execution time; comparing the actual execution time with the timeout time in the standardized interface, and combining this with the return status. The code determines the execution status of a stage. When the actual execution time is not higher than the timeout period and the returned status code is a success code, the stage execution status is recorded as successful, and the output data, status code, actual execution time, and stage identifier are encapsulated as the stage execution result. When the actual execution time is higher than the timeout period, the stage execution status is recorded as timeout and written to the breakpoint context. When the returned status code is not a success code and no timeout has occurred, the stage execution status is recorded as failure and written to the fault node. For stages that time out or fail, the corresponding skill agent is re-called according to the retry strategy in the standardized interface. After the number of retries reaches the retry limit, the chained calls stop, and the breakpoint context is handed over to the closed-loop verification process for recording.

[0011] As a preferred embodiment of the intelligent agent linkage method based on intent-triggered multi-skill chained collaboration described in this invention, the step of mapping the output of the previous stage to the input of the next stage and chaining the calls includes: after the execution status of the current stage is successful, reading the time interval between the current stage and the previous stage, the preset baseline interval, and the sensitivity coefficient; multiplying the difference between the time interval and the baseline interval by the sensitivity coefficient and inputting it into a logical incrementing function to obtain the dependency trigger weight; when the dependency trigger weight is greater than 0.7, the next stage waits for the output of the previous stage to be completed before execution; when the dependency trigger weight is not greater than 0.7, the next stage loads preloadable resources first, and enters field validation after the output of the previous stage is completed. The field validation reads the set of fields required by the input interface of the next stage and checks them one by one in the output data of the previous stage. The data contract validation results are as follows: if there is a field with the same name, if the actual type of the field is consistent with the expected type of the next stage, and if the field value is not null or an empty string; if all fields pass the existence, type consistency, and non-null validation, the data contract validation result is passed, and the output of the previous stage is mapped to the field according to the input interface of the next stage before calling the next skill agent; if any field fails the existence, type consistency, and non-null validation, the data contract validation result is failed, and stage rollback or review confirmation is triggered. During the chained call, the actual execution time of each stage and the state synchronization delay of adjacent stages are accumulated to obtain the total chained time; when the total chained time exceeds 1.2 times the user's expected time window, dynamic acceleration processing is performed, non-critical validation items are marked as delayed validation, and necessary field validation and state judgment are still retained.

[0012] As a preferred embodiment of the intelligent agent linkage method based on intent-triggered multi-skill chain collaboration described in this invention, the generation and output of final execution feedback information includes: reading the execution results of each stage according to the multi-stage task chain sequence, extracting the stage output, stage status, stage time, retry count, and exception description participating in the closed-loop verification, and comparing the transaction-related content in the stage output with the corresponding content in the macro transaction target for consistency. If the consistency comparison passes, the outputs of each stage are concatenated in the execution order, and the total chain time, overall execution status, and exception details are added to form the final execution feedback report; if the consistency comparison fails, To verify the integrity of the stage output during transmission and aggregation, the standardized output of each stage is concatenated in the stage order and a secure hash digest is calculated. The secure hash digest is then compared with the pre-stored digest. If the secure hash digest matches the pre-stored digest, the integrity check passes. If the secure hash digest does not match the pre-stored digest, an integrity alarm is written and a rollback is triggered. The overall performance score is then read, and the final execution feedback report, integrity check results, and overall performance score are written to the persistent task record. A structured log and natural language summary containing the declaration identifier, stage time, overall status, and exception details are output.

[0013] As a preferred embodiment of the intelligent agent linkage system based on intent-triggered multi-skill chain collaboration described in this invention, the system includes: an intent-triggered module, a skill-triggered module, and a closed-loop feedback module; the intent-triggered module receives macro-level transaction objectives, extracts transaction objects, time windows, constraints, and target preferences, and generates an intent feature vector; it matches the intent feature vector with a process template library to generate intent-triggered labels and a multi-stage task chain arranged by dependencies; the skill-triggered module registers multi-skill intelligent agents and configures standardized input / output interfaces, forming a callable resource pool based on resource consumption and data quality; it triggers the first-stage skill intelligent agent of the multi-stage task chain based on the intent-triggered labels and the callable resource pool, obtaining the stage execution result; the closed-loop feedback module performs dependency judgment and data contract verification on adjacent stages, maps the output of the previous stage to the input of the next stage and chaines them; it summarizes the execution results of each stage for closed-loop verification and state synchronization, and generates and outputs the final execution feedback information.

[0014] A computer device includes a memory and a processor, the memory storing a computer program, and the processor executing the computer program to implement a method for intelligent agent linkage based on intent-triggered multi-skill chain collaboration.

[0015] A computer-readable storage medium having a computer program stored thereon, wherein when executed by a processor, the computer program implements the steps of an agent linkage method based on intent-triggered multi-skill chain collaboration.

[0016] The beneficial effects of this invention are as follows: The intelligent agent linkage method based on intent-triggered multi-skill chain collaboration provided by this invention transforms macro-level transaction goals into structured intent features. Combined with process template matching, multi-template fusion, intent confidence, historical case verification, and triage stability judgment, it decomposes complex transaction goals into multi-stage task chains arranged according to dependencies, reducing task mis-triggering caused by coarse-grained intent recognition. By standardizing input / output interfaces, resource occupancy assessment, and data quality screening to form a callable resource pool, the skill-based intelligent agent completes interface, resource, and data verification before chain calls, reducing the probability of resource unavailability, field mismatch, and insufficient data quality during the execution phase. Through stage dependency judgment, data contract verification, state synchronization, integrity verification, and execution feedback aggregation, the output of the previous stage can verifiably accept the input of the next stage, and the final feedback retains execution status, exception details, and integrity records, improving the consistency and traceability of the execution results with the original macro-level transaction goals. Attached Figure Description

[0017] To more clearly illustrate the technical solutions of the embodiments of the present invention, the drawings used in the following description of the embodiments will be briefly introduced. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0018] Figure 1 The overall flowchart of the intelligent agent linkage method based on intent-triggered multi-skill chain collaboration provided by the present invention is shown below.

[0019] Figure 2 A schematic diagram of a computer device provided by the present invention. Detailed Implementation

[0020] To make the above-mentioned objects, features, and advantages of the present invention more apparent and understandable, specific embodiments of the present invention will be described in detail below with reference to the accompanying drawings. Obviously, the described embodiments are only a part of the embodiments of the present invention, and not all of them. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort should fall within the protection scope of the present invention.

[0021] Reference Figure 1 As an embodiment of the present invention, a method for intelligent agent linkage based on intent-triggered multi-skill chain collaboration is provided, comprising:

[0022] S1: Receive the macro trading objective, extract the trading object, time window, constraints and objective preferences, and generate an intent feature vector.

[0023] Furthermore, generating the intent feature vector involves receiving a macro-level transaction objective in natural language or structured form, performing text normalization and semantic parsing on the macro-level transaction objective, extracting four types of fields involved in the judgment: transaction object, time window, constraints, and target preference, converting each of the four types of fields into corresponding codes, and assembling the intent feature vector in the order of transaction object code, time window code, constraint code, and target preference code; converting each process template in the process template library into a template vector according to the same field order, multiplying the codes at the same position in the intent feature vector and the template vector item by item, summing the results, and then dividing by the product of the magnitude of the intent feature vector and the magnitude of the template vector to obtain the matching similarity between the intent feature vector and each process template; and writing all matching similarities into the matching result set according to the corresponding process template identifier.

[0024] It should be noted that one specific approach to generating intent feature vectors includes: macro-level transaction objectives in natural language form, which may include transaction objects, time windows, constraints, and target preferences, such as "to purchase a specified amount of electricity at the lowest cost between 9:00 AM and 11:00 AM tomorrow, with priority given to clean energy"; and macro-level transaction objectives in structured form, which may directly include transaction object fields, time window fields, constraint fields, and target preference fields.

[0025] For macro-level transaction objectives in natural language form, text normalization is first performed. This normalization includes standardizing time expressions, standardizing units of measurement, replacing business synonyms, and deleting invalid words that are not involved in transaction judgment. For example, "tomorrow morning from 9:00 to 11:00" is converted into start and end times; "lowest cost" and "lowest expense" are uniformly mapped to cost constraints; and "green electricity priority" and "priority to clean energy" are uniformly mapped to clean energy preferences. For macro-level transaction objectives in structured form, field names and values ​​are directly read, and it is checked whether they contain the four necessary fields: transaction object, time window, constraints, and target preferences.

[0026] After field extraction, the transaction object, time window, constraints, and target preference are converted into numerical codes. The transaction object code can be determined using a pre-defined transaction object vocabulary; the time window code can be determined by the normalized positions of the start and end times within the transaction cycle; the constraint code can be determined by the constraint type and strength; and the target preference code can be determined by the preference type and strength. All four types of fields are converted to values ​​between 0 and 1 to participate in template matching calculations within the same vector space. If any necessary field cannot be extracted or encoded, the corresponding field is written to the missing field record, and the process is returned to the macro-level transaction target for re-analysis or supplementation. If all four types of fields are encoded, an intent feature vector is formed in a fixed order.

[0027]

[0028] in, Indicates the intention feature vector, Indicates the transaction object code, Indicates time window encoding, Represents constraint encoding. This represents the target preference encoding. All four encodings mentioned above are involved in process template matching, intent triage judgment, historical case verification, and eventual consistency comparison.

[0029] The first one in the process template library The process template is represented as follows:

[0030]

[0031] in, Indicates the first A process template vector, This indicates the transaction object code in the template. This indicates the time window encoding in the template. This represents the constraint encoding in the template. This indicates the target preference encoding in the template. This represents the process template index in the process template library. Each process template vector corresponds to a pre-defined multi-stage task chain, which stores the stage type, stage order, stage dependencies, and the type of skill agent associated with each stage.

[0032] Complete Intent Feature Vector and process template vector After construction, the matching similarity between the intent feature vector and each process template vector is calculated:

[0033]

[0034] in, Intended feature vector With the Process template vector The similarity between them. The numerator represents the sum of the products of the four corresponding encoded positions, and the denominator represents the product of the magnitude of the intention feature vector and the magnitude of the process template vector. If or If the modulus is 0, then the corresponding Record it as 0, and write the corresponding process template into the abnormal matching record to avoid the matching being interrupted due to division by zero.

[0035] S2: Match the intent feature vector with the process template library to generate intent routing labels and multi-stage task chains arranged by dependencies.

[0036] Furthermore, the generation of intent-based traffic splitting labels and multi-stage task chains arranged by dependency includes: reading all matching similarities in the matching result set and determining the maximum similarity; when the maximum similarity is not less than 0.8, selecting the corresponding process template as the multi-stage task chain; when the maximum similarity is not less than 0.6 but less than 0.8, selecting several process templates with the highest matching similarity ranking, dividing the matching similarity of each process template by the sum of the matching similarities of the selected process templates to obtain the corresponding template weight; for each stage position in the task chain, reading the candidate stage types of the selected process template at the same stage position, performing weighted voting on the candidate stage types, adding the corresponding template weight only to templates whose candidate stage types are consistent with the template stage types, and taking the stage type with the highest weighted score as the final stage class for the corresponding stage position. When multiple stage types have the same score, the template stage type with the smallest target preference encoding distance is selected. When the maximum similarity is less than 0.6, the macro transaction target is returned for re-analysis. The semantic vector of the transaction instruction is input into the intent classification weight matrix to obtain the classification score of each intent category. The classification score is exponentially normalized and the maximum category probability is taken as the intent confidence. When the intent confidence is not less than 0.85, historical case verification is continued. Historical case verification calculates the angle similarity between the current intent feature vector and the historical case feature vector. When the angle similarity is not less than 0.7, intent diversion labels are generated. The information entropy function is introduced to calculate the diversion uncertainty based on the allocation probability of each task stage. When the diversion uncertainty is less than 0.5, the multi-stage task chain is confirmed to be stable; otherwise, the final stage type of the corresponding stage position is re-determined.

[0037] It should be noted that one scheme for generating intent-based traffic splitting labels and a multi-stage task chain arranged by dependencies specifically includes reading the matching result set and then... The similarity of matching process templates is denoted as:

[0038]

[0039] in, Indicates the first A process template and intent feature vector Matching similarity. Read all The maximum similarity is then determined. When the maximum similarity is not less than 0.8, it indicates that the macro trading objective and a certain process template have a high degree of consistency in the four dimensions of trading object, time window, constraints and objective preferences. The process template corresponding to the maximum similarity is directly selected as the multi-stage task chain.

[0040] When the maximum similarity is not lower than 0.6 but lower than 0.8, it indicates that a single process template is insufficient to fully cover the macro trading objectives. However, several similar templates still possess combinable stage information, therefore, a weighted fusion of multiple templates is performed. The templates with the highest matching similarity ranking are selected. A process template, Ideally, select 3; if the total number of process templates is less than 3, then select all process templates. For the selected template... The process template first normalizes the similarity to obtain the template weight:

[0041]

[0042] in, Indicates the first The weight of each candidate process template Indicates the first The matching similarity of each candidate process template. Indicates the first The matching similarity of each candidate process template. This indicates the summation index of the candidate process template. This indicates the number of candidate process templates participating in the integration. If... If so, the fusion will stop and the macro trading target will be re-analyzed.

[0043] For the first in the task chain At each position, read the stage type of each candidate process template at the same position. Let the first position be... The phase sequence of the candidate process templates is as follows: , No. The candidate process template is in the first The stage type at each position is For candidate stage types Calculate the corresponding weighted score:

[0044]

[0045] in, Indicates candidate stage type In the Weighted scores for each position Indicates the first The weight of each candidate process template Indicates the indicator function; when the first... The candidate process template is in the first The stage type at each position is equal to the candidate stage type. When the condition is met, the indicator function is set to 1; otherwise, it is set to 0. Therefore, the score for each candidate stage type is derived from the sum of the weights of the candidate process templates containing the corresponding stage type.

[0046] No. The final stage type for each position is determined by the following formula:

[0047]

[0048] in, Indicates the fusion task chain in the 1st... Stage type at each position, Indicates to make Candidate stage types for achieving the maximum value When multiple stage types have the same highest score, compare the target preference code of the corresponding process template with... Target preference coding The process template with the smallest distance is selected first; if the distances are still the same, the process type is determined according to the preset stage priority. The preset stage priority can be set in the order of data preparation, calculation and processing, execution and submission and result verification.

[0049] When the maximum similarity is below 0.6, it indicates a significant difference between the current macro-level transaction objective and the process templates in the process template library. The macro-level transaction objective should be returned for re-parsed or fields supplemented. 0.8 and 0.6 serve as template selection boundaries with hierarchical judgment functions: 0.8 is used to directly map highly similar templates, reducing unnecessary fusion calculations; 0.6 is used to block low-relevance templates from participating in fusion, preventing the task chain from deviating from the macro-level transaction objective.

[0050] After generating candidate multi-stage task chains, intent confidence is determined based on the semantic vector of the transaction instruction. The semantic vector of the transaction instruction is denoted as... The transaction intent classification weight matrix is ​​denoted as: The total number of intent categories is recorded as .Will enter The classification scores for each intent category are obtained, and the probabilities of each intent category are obtained through exponential normalization. The highest category probability is taken as the intent confidence score.

[0051]

[0052] in, Indicates confidence level of intent. Represents the semantic vector of a trading instruction. This represents the weight matrix for classifying transaction intentions. Indicates the intent category index, Indicates the intent category summation index. Indicates the total number of intent categories. Represents the natural constant. Transaction instruction semantic vector. It can be obtained by concatenating or expanding the codes for transaction objects, time windows, constraints, and target preferences. Transaction Intent Classification Weight Matrix It can be trained from historical labeled transaction instructions. During training, the semantic vector of historical transaction instructions is used as input, and the intention category confirmed by humans is used as output. Cross-entropy loss is used for updating. Training is stopped and data is saved when the validation set loss changes by less than 0.001 for several consecutive rounds or when the preset number of training rounds is reached. .

[0053] The optimal confidence threshold for intent is 0.85. For electricity trading tasks, false triggers pose a high execution risk. A threshold that is too low allows ambiguous intents to enter the execution process, while a threshold that is too high reduces the degree of automation. Therefore, 0.85 is the preferred value that balances recognition reliability and automatic execution rate. When, enter historical case verification; when If necessary, return to the macro trading target for re-analysis or proceed to the review and confirmation stage.

[0054] Historical case verification calculates the angle similarity between the current intent feature vector and the historical case feature vectors. Let the current intent feature vector be denoted as... The feature vector of historical cases is denoted as The similarity between the current intention and a certain historical case is:

[0055]

[0056] in, This indicates the similarity between the current intention and historical cases. This represents the current intent feature vector. Represents the feature vector of historical cases. and These represent the magnitudes of the two vectors, respectively. If the historical case library is empty, or the magnitude of the historical case feature vector is 0, then... Record it as 0 and proceed to review and confirmation. The preferred threshold for historical case similarity is 0.7. When When this indicates that the current intent is comparable to historically executed cases, intent triage tags can be generated; when If necessary, return to the macro trading target for re-analysis or proceed to the review and confirmation stage.

[0057] To further assess the stability of a multi-stage task chain, an information entropy function is introduced to measure the probability of task stage allocation:

[0058]

[0059] in, Let represent the uncertainty of the diversion, and let represent the information entropy of the intended diversion. Indicates the first Each task stage is assigned an execution probability corresponding to its stage type. Indicates the task stage index. This indicates the total number of task phases. This can be obtained from the frequency of stage allocation in the historical task execution log. At that time, the diversion result is considered stable and the multi-stage task chain is confirmed; when When this happens, the task decomposition process is called back. A threshold of 0.5 serves as an optimal boundary, filtering out overly dispersed task chains and reducing the probability of rollback during chained execution.

[0060] It should also be noted that matching intent feature vectors with the process template library to generate intent triage labels primarily addresses the problem that single intent classification is insufficient to cover complex transaction goals and that coarse-grained identification is prone to triggering erroneous skill chains. When the matching degree is high, the corresponding process template is directly selected to avoid unnecessary fusion calculations. When the matching degree is in the intermediate range, it is not directly abandoned, nor is a single template forcibly used. Instead, multiple similar templates are selected, and the participation weight is determined based on the matching degree of each template. Then, the candidate stage types at each stage position are selected with weights. If the scores of different stage types are close, they are further compared in conjunction with the target preference encoding to ensure that the stage composition of the task chain is consistent with user preferences. Subsequently, intent confidence judgment, historical case verification, and triage uncertainty judgment continue to constrain task chain generation, preventing low-confidence intents, instructions lacking historical comparability, or task chains with overly dispersed stage allocations from entering the execution stage. This approach changes the single-line mode of "identifying an intent and calling an executor" to make task chain generation simultaneously constrained by template similarity, target preferences, historical execution records, and stage stability, reducing execution interruptions caused by fuzzy intents, misallocation of template boundary scenarios, and unstable stage sequences.

[0061] S3: Register multi-skill intelligent agents and configure standardized input / output interfaces to form a pool of callable resources based on resource consumption and data quality.

[0062] Furthermore, forming a callable resource pool includes reading the skill descriptions, input specifications, output specifications, timeout periods, and retry policies of each skill agent; writing the input specifications, output specifications, timeout periods, and retry policies into a unified interface structure; and registering the corresponding skill type and calling address with the resource pool. During the registration process, the processor usage, memory usage, and bandwidth usage required for the corresponding skill agent to run are collected. The ratios of processor usage to processor quota, memory requirement to available memory, and bandwidth requirement to available bandwidth are multiplied by preset weights and then summed to obtain the overall resource utilization rate. When the overall resource utilization rate is higher than 0.9, a resource expansion warning is written. The corresponding skill agent is temporarily suspended from entering the callable state. When the overall resource utilization rate is not higher than 0.9 and the test call return result meets the interface specification, the corresponding skill agent is written into the callable resource pool. For the data output by the collection-type skill agent, the missing rate, the number of outliers, and the total number of data points are read. The missing rate is converted into a missing penalty coefficient, and the ratio of the number of outliers to the total number of data points is converted into an anomaly penalty coefficient. The two penalty coefficients are combined to form a data quality score. When the data quality score is lower than 0.85, the corresponding data enters the re-collection or completion process. When the data quality score is not lower than 0.85, the standardized output is written into the task context and waits for invocation.

[0063] It should be noted that one scheme for forming a callable resource pool based on resource consumption and data quality specifically includes reading the stage type in a multi-stage task chain and retrieving skill agents that match the stage type. Each skill agent submits a skill description, input specifications, output specifications, maximum execution timeout, and retry strategy during registration. Input specifications include field names, field types, whether they are required, and their value range; output specifications include field names, field types, status codes, and output field descriptions; the maximum execution timeout is in seconds; and the retry strategy includes the maximum number of retries and the backoff interval. The above information is written to a standardized interface.

[0064]

[0065] in, A standardized interface representing a skill-based intelligent agent. Indicates the input data specifications. Indicates the output data specification. Indicates the maximum execution timeout. This indicates the retry strategy. Standardized interfaces, skill types, call addresses, and current states are all registered in the resource pool.

[0066] During the registration process, the processor usage, memory usage, and bandwidth usage required for the corresponding skill-based intelligent agent to run are collected, and the overall resource utilization rate is calculated:

[0067]

[0068] in, This represents the overall resource utilization rate of a skill-based intelligent agent. Indicates the processor's usage weight. Indicates peak processor usage. Indicates the baseline processor quota. Indicates memory usage weight. Indicates memory requirements. Indicates the total available memory. Indicates bandwidth usage weight. Indicates the required bandwidth. Indicates available bandwidth. Preferably, , , Processor usage has a significant impact on the quantization calculation stage, therefore it has a high weight; memory and bandwidth affect data residency and interface transmission respectively, therefore they are set as secondary weights. , or If any value in the above is 0, the corresponding skill agent will not enter the callable resource pool and will be written into the resource configuration exception record.

[0069] when When resource expansion warning is issued, the corresponding skill agent's entry into the callable state is temporarily suspended; when At that time, the test call is executed. The test call is executed according to... Construct minimal executable test data and check the return status code, the existence of output fields, and the type of output fields. If the test call returns a success status code and the output meets the requirements... If the status code is unsuccessful, a required output field is missing, or the field type is inconsistent, the status of the corresponding skill agent will be recorded as uncallable, and an interface verification exception record will be written.

[0070] For data output by the AI ​​agent focusing on data collection skills, a data quality score is further calculated. This involves reading the missing rate, the number of outliers, and the total number of data points. The missing rate represents the ratio of missing samples to the number of samples that should have been collected. The number of outliers can be identified using the three-standard-deviation rule or business upper and lower limits. The data quality score is:

[0071]

[0072] in, Indicates the data quality score. Indicates the missing rate. Indicates the number of outliers. This represents the total number of data points. If... ,but Record it as 0 and trigger resampling; if Then according to Cut off the abnormal ratio to avoid it exceeding 1.

[0073] The optimal data quality scoring threshold is 0.85. For data entering the quantization calculation stage, missing and anomalies directly affect the calculation results. A threshold that is too low can easily lead to insufficiently quality data being included in chained calls, while a threshold that is too high may result in frequent resampling. Therefore, 0.85 is the preferred value that balances execution continuity and data reliability. When this happens, the corresponding data enters a re-collection or completion process; the completion process can use interpolation between adjacent time points, replacement with historical samples of the same type, or filling with default values ​​allowed by the business, and the completion field is written to the completion identifier. At that time, the standardized output is written to the task context, waiting for the multi-stage task chain to be called.

[0074] S4: Based on the intent-based traffic distribution label and the pool of callable resources, trigger the first-stage skill agent of the multi-stage task chain and obtain the stage execution result.

[0075] Furthermore, obtaining the stage execution results includes: reading the task chain identifier, first stage type, and task context from the intent triage tag; matching skill agents with the same skill type and in a callable state from the callable resource pool; and assembling the call parameters according to the corresponding standardized input interface; recording the start time at the start of the call and the end time, return status code, output data, and number of retries at the end of the call, using the difference between the end time and the start time as the actual execution time; comparing the actual execution time with the timeout time in the standardized interface and determining the stage execution status based on the return status code; when the actual execution time is not high... When the timeout period expires and the returned status code is a success code, the stage execution status is recorded as successful, and the output data, status code, actual execution time, and stage identifier are encapsulated into the stage execution result. When the actual execution time is longer than the timeout period, the stage execution status is recorded as timeout and written to the breakpoint context. When the returned status code is not a success code and no timeout has occurred, the stage execution status is recorded as failure and written to the fault node. For stages that time out or fail, the corresponding skill agent is re-called according to the retry strategy in the standardized interface. After the number of retries reaches the retry limit, the chained calls stop, and the breakpoint context is handed over to the closed-loop verification process for recording.

[0076] It should be noted that one specific approach to obtaining the stage execution result includes reading the task chain identifier, the first stage type, and the task context index from the intent triage tag, and retrieving skill agents from the callable resource pool whose skill type matches the first stage type and whose status is callable. If multiple skill agents meet the conditions, they are selected first. lower and The skill agent with a higher match to the task context field is selected; if no skill agent meets the conditions, a resource missing exception is written and the chained calls are stopped.

[0077] After selecting the skill agent, proceed according to the corresponding The system reads required fields, field types, and value ranges, and extracts the corresponding input values ​​from the task context. If any required field is missing or of inconsistent type, the call is not triggered; instead, a parameter assembly exception is written, and field completion or stage rollback is returned. If parameter assembly is successful, the first-stage skill agent is triggered, recording the start time at the start of the call and the end time, return status code, output data, and number of retries at the end. The actual execution time is obtained by subtracting the start time from the end time.

[0078] The execution status of a stage is determined based on the actual execution time, timeout time, and return status code:

[0079]

[0080] in, Indicates the stage execution status. This indicates successful execution. This indicates that the execution timed out. This indicates that the execution failed. Indicates the actual execution time. This indicates the maximum execution timeout in the corresponding standardized interface. Indicates the returned status code. This indicates statuses other than success and timeout. If the transaction interface defines a success code other than 200, the corresponding success code will be written into the success status code set, and the success status code set will be used for judgment.

[0081] when When this happens, the output data, return status code, actual execution time, stage identifier, and number of retries are encapsulated into a stage execution result and written to the task context. When a timeout occurs, the execution status of the stage is recorded as timed out and written to the breakpoint context. The breakpoint context includes the task chain identifier, stage identifier, assembled input parameters, call address, execution time, and number of retries. When this happens, the return status code, exception description, stage identifier, and skill agent identifier will be written to the fault node.

[0082] For stages that time out or fail, according to Recall the corresponding skill agent. The preferred retry strategy is a maximum of 3 attempts, with backoff intervals of 2 seconds, 4 seconds, and 8 seconds respectively. Increasing the backoff interval reduces consecutive failures caused by short-term interface congestion and avoids excessively long waiting times that could impact transaction efficiency. If any retry returns... If the retry result is successful, the execution result of the phase is updated, and the actual number of retries is recorded. If the number of retries reaches the upper limit and the retry is still unsuccessful, the chained call is stopped, and the breakpoint context is handed over to the closed-loop verification process for recording.

[0083] S5: Perform dependency checks and data contract verification on adjacent stages, map the output of the previous stage to the input of the next stage, and chain the calls.

[0084] Furthermore, mapping the output of the previous stage to the input of the next stage and chaining the calls includes, after the execution status of the current stage is successful, reading the time interval between the current stage and the previous stage, the preset baseline interval, and the sensitivity coefficient. The difference between the time interval and the baseline interval is multiplied by the sensitivity coefficient and then input into a logically incrementing function to obtain the dependency trigger weight. If the dependency trigger weight is greater than 0.7, the next stage waits for the output of the previous stage to complete before execution; if the dependency trigger weight is not greater than 0.7, the next stage first loads preloadable resources and, after the output of the previous stage is completed, enters field validation. Field validation reads the set of fields required by the input interface of the next stage and checks one by one whether there are fields with the same name in the output data of the previous stage, and whether the actual type of the fields is the same as the next stage's. If the expected type of each stage is consistent, and the field values ​​are not null or empty strings, the data contract verification result is passed when all fields pass the existence, type consistency, and non-null checks. The output of the previous stage is then mapped to the field of the input interface of the next stage and the next skill agent is called. If any field fails the existence, type consistency, and non-null checks, the data contract verification result is failed, and stage rollback or review confirmation is triggered. During the chained call, the actual execution time of each stage and the state synchronization delay of adjacent stages are accumulated to obtain the total chained time. When the total chained time exceeds 1.2 times the user's expected time window, dynamic acceleration processing is performed, non-critical verification items are marked as delayed verification, and necessary field verification and state judgment are still retained.

[0085] It should be noted that one scheme for mapping the output of the previous stage to the input of the next stage and chaining the calls specifically includes, only if the current stage's... When the current stage is successfully executed, the system reads the information for the next stage in the multi-stage task chain. First, it reads the dependencies between adjacent stages recorded in the multi-stage task chain and the set of fields required by the input interface of the next stage to determine if the next stage needs to use the required fields from the output of the previous stage. If the required fields in the input interface of the next stage originate from the output of the previous stage, then a data dependency exists between adjacent stages; if the next stage only requires fixed configuration parameters or parameters that can be directly obtained from the task context, then there is no strong data dependency between adjacent stages. In other words, the source of the dependency is not the time interval, but the stage order and data contract in the task chain; the time interval is merely a scheduling quantification factor for the strength of the dependency; for adjacent stages, the time interval, baseline interval, and sensitivity coefficient between the current stage and the predecessor stage are read first, and the dependency trigger weight is calculated.

[0086]

[0087] in, Indicates the first Dependency trigger weights for each stage Represents the natural constant. Represents the sensitivity coefficient. Indicates the first The time interval between each stage and the preceding stage Indicates the reference interval. This indicates the task stage index. Preferably, Second, A 5-second timeframe can cover most interface state synchronization and context write times, while 0.8 allows dependency weights to change smoothly over time intervals, avoiding frequent switching caused by small time differences.

[0088] when When, it indicates that the current stage is closely dependent on the output of the predecessor stage, and the next stage will wait for the output of the predecessor stage to be written into the task context before execution; when This indicates a relatively loose dependency, meaning that preloadable resources can be loaded in the next stage. Preloadable resources include metadata for the skill agent interface in the next stage, runtime environment handles, and non-dependent configuration parameters, but do not include business input fields that require output assignment from the previous stage.

[0089] After the output of the previous stage is written to the task context, data contract verification is performed. Then, the set of fields required by the input interface for the next stage is read. And check the output data of the previous stage one by one. The data contract validation rules are as follows: Does the data contain a field with the same name? Does the actual data type match the expected data type for the next stage? Are the data values ​​not null or empty strings?

[0090]

[0091] in, This indicates the data contract verification result. This indicates that a logical AND operation is performed on the validation results of all required fields. This represents the field to be validated. This represents the set of fields required by the input interface in the next stage. This indicates the output data from the previous stage. This indicates field existence validation. This indicates field type matching validation. This indicates that the field is not null.

[0092] Field existence validation is represented as follows:

[0093]

[0094] in, This represents the set of field names in the output data from the previous stage. Field type matching validation is represented as:

[0095]

[0096] in, This indicates the fields in the output data of the previous stage. The actual type, This indicates the fields in the input interface for the next stage. The expected type. Field not null validation is represented as:

[0097]

[0098] in, This indicates the fields in the output data of the previous stage. The value of , Indicates a null value. A non-empty string.

[0099] when At this point, the output of the previous stage is mapped to the input interface of the next stage. Field mapping is performed in the following order: field name consistency first, field alias mapping second, and unit conversion third. If the field names and types are consistent, they are passed directly. If the field names are inconsistent but a pre-defined alias relationship exists, they are renamed according to the alias relationship. If the field unit is inconsistent with the requirements of the next stage, it is converted according to the unit conversion table and then written into the input parameters. After the field mapping is completed, the next stage skill agent is called, and the stage execution state judgment, dependency judgment, and data contract verification are repeated until all stages of the multi-stage task chain are completed or a stopping condition is met.

[0100] when When the error occurs, the system reads the field name, failure reason, and corresponding stage identifier of the failed field, and triggers stage rollback or audit confirmation. If the existence validation fails, the system returns to the previous stage to re-output or supplement the field; if the type matching validation fails, if there is an explicit type conversion rule, the field is converted and re-validated; if there is no conversion rule, the system proceeds to audit confirmation; if the non-empty validation fails, if the field can be obtained from the completion rule, it is completed and re-validated; if the field is a mandatory field that cannot be completed, the chained calls are stopped and the exception details are written.

[0101] The total time for chained collaboration is obtained by summing the execution time of each stage and the state synchronization delay between stages:

[0102]

[0103] in, This represents the total time required for a complete chain of collaborations. Indicates the first The actual execution time of the skill agent associated with the stage. Indicates the first Phase to the first The synchronization delay caused by the phase transfer of task context and status information This represents the total number of stages in a multi-stage task chain. When... When the time is right, the second term is recorded as 0.

[0104] when When the time exceeds 1.2 times the user's expected time window, dynamic acceleration processing is executed. Dynamic acceleration processing only marks non-critical validation items as deferred validations, without skipping required field existence checks, field type matching checks, field non-empty checks, and stage execution status checks. Non-critical validation items may include optional field range checks, log format supplementation, or unnecessary summary generation. Using 1.2 times as the trigger boundary creates a buffer between transaction timeliness and validation completeness, avoiding the execution risk caused by drastically reducing validation just after exceeding the expected time.

[0105] It should also be noted that dependency judgment and data contract verification for adjacent stages are mainly aimed at addressing the problem of unreliable transition from the previous stage's output to the next stage's input and unclear state synchronization between stages leading to task gaps in multi-skill chain collaboration. After the current stage succeeds, the dependency of the next stage on the predecessor's output is first determined based on the time interval between adjacent stages, the baseline interval, and the sensitivity coefficient. If the dependency is tight, the predecessor's output is waited to be written into the task context; if the dependency is weak, only preloading of interface metadata, runtime environment handles, and non-dependent configurations is allowed to avoid using business inputs that have not yet been generated. After the predecessor's output is completed, the existence, type consistency, and value of each field are checked according to the input specifications of the next stage. Only after all required fields pass the verification is the input mapping completed and the next skill agent called in the order of field name consistency, alias mapping, and unit conversion. If any necessary field fails the verification, a rollback, completion, or review confirmation is triggered. During the chain call process, the stage execution time and state synchronization delay are also accumulated. If the expected time boundary is exceeded, only non-critical verifications are postponed, without skipping necessary fields and state judgments. This process transforms stage transitions from simple sequential calls to data transfer constrained by dependencies and data contracts, reducing execution conflicts caused by missing fields, type errors, null value passing, and synchronization delays.

[0106] S6: Summarize the execution results of each stage, perform closed-loop verification and status synchronization, and generate and output the final execution feedback information.

[0107] Furthermore, generating and outputting the final execution feedback information includes reading the execution results of each stage in the order of the multi-stage task chain, extracting the stage outputs, stage status, stage time, number of retries, and exception descriptions participating in the closed-loop verification, and comparing the transaction-related content in the stage outputs with the corresponding content in the macro transaction objectives. If the consistency comparison passes, the outputs of each stage are concatenated in the execution order, and the chained total time, overall execution status, and exception details are appended to form the final execution feedback report. If the consistency comparison fails, exception details are written and a rollback is triggered. To verify the integrity of the stage outputs during transmission and aggregation, the standardized outputs of each stage are concatenated in the stage order and a secure hash digest is calculated. The secure hash digest is compared with the pre-stored digest. If the secure hash digest matches the pre-stored digest, the integrity verification passes. If the secure hash digest does not match the pre-stored digest, an integrity alarm is written and a rollback is triggered. The overall performance score is further read, and the final execution feedback report, integrity verification results, and overall performance score are written to the persistent task record. A structured log and natural language summary containing the declaration identifier, stage time, overall status, and exception details are output.

[0108] It should be noted that one specific approach to generating and outputting final execution feedback information includes reading the execution results of each stage in the order of the multi-stage task chain, and extracting the stage output, stage status, stage time, number of retries, and exception description. The stage status can be... , and Records can also be mapped to 1, 0, and -1 respectively for persistent storage and statistics. If all stage states are... The overall execution status is recorded as If some stages succeed but timeouts or failures occur, the overall execution status is recorded as follows: If there is no success phase, the overall execution status is recorded as follows: .

[0109] The closed-loop verification first performs a consistency comparison. This compares the transaction objects, time windows, constraints, and target preferences in the stage output with their corresponding content in the macro-level transaction objectives. The transaction object comparison uses a coding consistency rule; the time window comparison uses a rule that inputs the output transaction time segment into the target time window; the constraint comparison uses a rule that the output scheme satisfies the constraint expression; and the target preference comparison uses a rule that the output scheme preference coding matches the target time window. The difference does not exceed the preset tolerance rule. If the consistency comparison passes, the outputs of each stage are concatenated in execution order, and a chained total execution time, overall execution status, and exception details are appended to form the final execution feedback report:

[0110]

[0111] in, This indicates the final execution feedback report. This represents the concatenation function. Indicates the first The output results of each stage Indicates the total number of final execution stages. Represents a metadata structured object, Indicates the total time spent in the chain. Indicates the overall execution status. This represents the list of exception details. If the consistency comparison fails, the exception details are written and a rollback is triggered. The rollback position is the most recent state. And the breakpoints at the stages where integrity verification passes.

[0112] To verify that the stage outputs were not tampered with during transmission and aggregation, the standardized outputs of each stage were concatenated in stage order and a secure hash digest was calculated.

[0113]

[0114] in, Represents the hash check value. This indicates a 256-bit secure hash algorithm. to These represent the first stage to the second stage. The stage output after standard serialization. This indicates concatenation in stage order. Standard serialization uses a fixed field order, fixed time format, and fixed numerical precision to avoid different hash values ​​for the same data due to different field orders. The integrity check is compared with the pre-stored hash value; if they match, the integrity check passes; if they do not match, an integrity alarm is written and a rollback is triggered.

[0115] Furthermore, the baseline expected execution time, actual total execution time, number of successfully executed stages, total number of stages, data acquisition quality score, and total number of retries are read, and the overall performance score is calculated using a normalized performance scoring function.

[0116]

[0117] in, Indicates the overall performance score. Indicates the baseline expected time. This indicates the actual total time spent. Indicates the number of stages successfully executed. Indicates the total number of stages. This indicates the data collection quality score. This represents the total number of retries. , , , These represent the weight coefficients for the time consumption item, the stage success item, the data quality item, and the retry penalty item, respectively. Preferably, , , , During calculation, , , , , and All data originates from the execution records of the same chained collaborative task, avoiding data commingling across tasks; when At that time, Record it as 0 and write it into the time-consuming exception record; when At that time, Record it as 0 and write it to the stage exception log. After the calculation is complete, Normalize to 0-100 points. If the score is below 60, an optimization suggestion report is automatically generated. The optimization suggestion report records the specific reasons for excessive time consumption, insufficient data quality, or excessive number of retries.

[0118] The final execution feedback information should include at least the declaration identifier, stage duration, overall execution status, anomaly details, integrity verification results, and overall performance score. The final execution feedback report, integrity verification results, and overall performance score are written to the persistent task record, and a structured log and natural language summary are output. The structured log is stored in key-value pair format for easy auditing and retrieval; the natural language summary is generated based on the structured log. And when the integrity check passes, the summary includes that the application has been completed, the application identifier, the time spent at each stage, and that there are no abnormal records; when or The summary includes completed phases, abnormal phases, breakpoint locations, and recoverable operations.

[0119] It should also be noted that summarizing the execution results of each stage and generating final execution feedback information mainly addresses the issues of difficulty in tracing results after the completion of chained tasks, inconsistencies between stage outputs and the original goals, or alterations during transmission. The execution results of each stage are summarized in the order of the task chain, and stage outputs, stage status, time consumption, number of retries, and exception descriptions are all retained, forming an auditable execution record. Closed-loop verification first compares the transaction objects, time windows, constraints, and target preferences in the stage outputs with the macro-level transaction goals to confirm that the execution results have not deviated from the original goals; if consistency fails, an exception is written and the process is rolled back to the most recent recoverable breakpoint. Through integrity verification, the standardized outputs of each stage are concatenated sequentially to generate a security digest, which is then compared with a pre-stored digest to identify tampering or inconsistencies during transmission and summarization. The final feedback report also includes the total chain time consumption, overall execution status, exception details, and overall performance score. The score is generated by combining time consumption, the number of successful stages, data quality, and the number of retries. This process ensures that the final output is not just a declaration result, but a closed-loop record that includes the execution chain, the source of the anomaly, the integrity status, and the performance evaluation, reducing the chances of untraceable results, unidentifiable causes of anomalies, and deviations from the target in execution results.

[0120] One embodiment of the present invention provides an intelligent agent linkage system based on intent-triggered multi-skill chain collaboration, including an intent-triggered module, a skill-triggered module, and a closed-loop feedback module.

[0121] The intent triage module receives macro-level transaction objectives, extracts transaction objects, time windows, constraints, and target preferences, and generates intent feature vectors. It then matches these intent feature vectors with a process template library to generate intent triage labels and a multi-stage task chain arranged by dependencies. The skill triggering module registers multi-skill agents and configures standardized input / output interfaces, forming a pool of callable resources based on resource consumption and data quality. Based on the intent triage labels and the callable resource pool, it triggers the first-stage skill agent in the multi-stage task chain to obtain the stage execution result. The closed-loop feedback module performs dependency judgments and data contract verification on adjacent stages, maps the output of the previous stage to the input of the next stage, and chaines these inputs. Finally, it summarizes the execution results of each stage for closed-loop verification and state synchronization, generating and outputting the final execution feedback information.

[0122] Reference Figure 2 This embodiment also provides a computer device applicable to the intelligent agent linkage method based on intent-triggered multi-skill chain collaboration, including: a memory and a processor; the memory is used to store computer-executable instructions, and the processor is used to execute the computer-executable instructions to realize the intelligent agent linkage method based on intent-triggered multi-skill chain collaboration proposed in the above embodiment.

[0123] The computer device can be a terminal, comprising a processor, memory, communication interface, display screen, and input devices connected via a system bus. The processor provides computing and control capabilities. The memory includes non-volatile storage media and internal memory. The non-volatile storage media stores the operating system and computer programs. The internal memory provides an environment for the operation of the operating system and computer programs stored in the non-volatile storage media. The communication interface is used for wired or wireless communication with external terminals; wireless communication can be achieved through Wi-Fi, carrier networks, NFC (Near Field Communication), or other technologies. The display screen can be an LCD screen or an e-ink screen. The input devices can be a touch layer covering the display screen, buttons, a trackball, or a touchpad on the computer device's casing, or an external keyboard, touchpad, or mouse.

[0124] This embodiment also provides a storage medium storing a computer program. When executed by a processor, the program implements the agent linkage method for triggering multi-skill chain collaboration based on intent shunting, as proposed in the above embodiments. The storage medium can be implemented by any type of volatile or non-volatile storage device or a combination thereof, such as Static Random Access Memory (SRAM), Electrically Erasable Programmable Read-Only Memory (EEPROM), Erasable Programmable Read Only Memory (EPROM), Programmable Red-Only Memory (PROM), Read-Only Memory (ROM), magnetic storage, flash memory, magnetic disk, or optical disk.

Claims

1. An agent linkage method based on intent-triggered multi-skill chain collaboration, characterized in that, include: Receive macro trading objectives, extract trading targets, time windows, constraints, and target preferences, and generate an intent feature vector; Match the intent feature vector with the process template library to generate intent triage labels and multi-stage task chains arranged by dependencies; Register multi-skill intelligent agents and configure standardized input / output interfaces to form a pool of callable resources based on resource consumption and data quality; Based on the intent-based traffic distribution tags and the pool of available resources, the first-stage skill agent of the multi-stage task chain is triggered to obtain the stage execution result; Perform dependency checks and data contract verifications on adjacent stages, map the output of the previous stage to the input of the next stage, and chain the calls. The execution results of each stage are summarized for closed-loop verification and status synchronization, and the final execution feedback information is generated and output.

2. The agent linkage method based on intent-triggered multi-skill chain collaboration as described in claim 1, characterized in that: The generated intention feature vector includes, The system receives macro-level transaction objectives in natural language or structured form, performs text normalization and semantic parsing on the macro-level transaction objectives, extracts four types of fields involved in the judgment: transaction object, time window, constraints, and target preference, converts the four types of fields into corresponding codes, and forms an intent feature vector in the order of transaction object code, time window code, constraint code, and target preference code. Each process template in the process template library is converted into a template vector according to the same field order. The intent feature vector is multiplied by the encoding of the same position in the template vector item by item, and the sum is then divided by the product of the magnitude of the intent feature vector and the magnitude of the template vector to obtain the matching similarity between the intent feature vector and each process template. Write all matching similarities into the matching result set according to the corresponding process template identifier.

3. The agent linkage method based on intent-triggered multi-skill chain collaboration as described in claim 2, characterized in that: The generation of intent-based traffic-splitting labels and the multi-stage task chain arranged by dependency include, Read all matching similarities in the matching result set and determine the maximum similarity. When the maximum similarity is not less than 0.8, select the corresponding process template as the multi-stage task chain. When the maximum similarity is not less than 0.6 and less than 0.8, select several process templates with the highest matching similarity ranking, divide the matching similarity of each process template by the sum of the matching similarities of the selected process templates, and obtain the corresponding template weight. For each stage position in the task chain, read the candidate stage types of the selected process template at the same stage position, perform weighted voting on the candidate stage types, and only add the corresponding template weight to the template whose candidate stage type is consistent with the template stage type during voting. Take the stage type with the highest weighted score as the final stage type of the corresponding stage position. When multiple stage types have the same score, select the template stage type with the smallest target preference encoding distance. When the maximum similarity is less than 0.6, return to the macro trading target for re-analysis. Input the semantic vector of the transaction instruction into the intent classification weight matrix to obtain the classification score of each intent category. Perform exponential normalization on the classification score and take the maximum category probability as the intent confidence. When the intent confidence is not lower than 0.85, continue to perform historical case verification. Historical case verification calculates the angle similarity between the current intent feature vector and the historical case feature vectors. When the angle similarity is not less than 0.7, intent triage labels are generated. The information entropy function is introduced to calculate the split uncertainty based on the allocation probability of each task stage. When the split uncertainty is less than 0.5, the multi-stage task chain is confirmed to be stable; otherwise, the final stage type of the corresponding stage position is re-determined.

4. The agent linkage method based on intent-triggered multi-skill chain collaboration as described in claim 3, characterized in that: The formation of the callable resource pool includes, Read the skill description, input specifications, output specifications, timeout and retry policy of each skill agent, write the input specifications, output specifications, timeout and retry policy into a unified interface structure, and register the corresponding skill type and calling address with the resource pool; During the registration process, the processor usage, memory usage, and bandwidth usage required for the operation of the corresponding skill-based intelligent agent are collected. The ratio of processor usage to processor quota, the ratio of memory requirement to available memory, and the ratio of bandwidth requirement to available bandwidth are multiplied by preset weights and then summed to obtain the comprehensive resource utilization rate. When the overall resource utilization rate is higher than 0.9, a resource expansion warning is written and the corresponding skill agent is temporarily suspended from entering the callable state; When the overall resource utilization rate is not higher than 0.9 and the test call return result meets the interface specification, the corresponding skill agent will be written into the callable resource pool. For data output by intelligent agents that collect skills, the missing rate, number of outliers, and total number of data points are read. The missing rate is converted into a missing penalty coefficient, and the ratio of the number of outliers to the total number of data points is converted into an anomaly penalty coefficient. The two penalty coefficients are combined to form a data quality score. When the data quality score is lower than 0.85, the corresponding data is re-collected or completed. When the data quality score is not lower than 0.85, the standardized output is written to the task context and awaits invocation.

5. The agent linkage method based on intent-triggered multi-skill chain collaboration as described in claim 4, characterized in that: The results of the obtained phase execution include, Read the task chain identifier, first stage type and task context from the intent triage tag, match the skill agent with the same skill type and in the callable resource pool, and assemble the call parameters according to the corresponding standardized input interface; When a call starts, the start time is recorded. When a call ends, the end time, return status code, output data, and number of retries are recorded. The difference between the end time and the start time is used as the actual execution time. The actual execution time is compared with the timeout in the standardized interface, and the stage execution status is determined by combining the return status code; When the actual execution time is not higher than the timeout time and the returned status code is a success code, the stage execution status is recorded as successful, and the output data, status code, actual execution time and stage identifier are encapsulated into the stage execution result. When the actual execution time exceeds the timeout period, the stage execution status is recorded as timeout and written to the breakpoint context; When the returned status code is not a success code and no timeout occurs, the stage execution status is recorded as failure and written to the fault node. For stages that time out or fail, the corresponding skill agent is called again according to the retry strategy in the standardized interface. After the number of retries reaches the retry limit, the chained call stops and the breakpoint context is handed over to the closed-loop verification process for recording.

6. The agent linkage method based on intent-triggered multi-skill chain collaboration as described in claim 5, characterized in that: The step of mapping the output of the previous stage to the input of the next stage and chaining the calls includes, After the execution status of the current stage is successful, read the time interval between the current stage and the previous stage, the preset baseline interval, and the sensitivity coefficient. Multiply the difference between the time interval and the baseline interval by the sensitivity coefficient and input it into the logic increment function to obtain the dependency trigger weight. When the dependency trigger weight is greater than 0.7, the next stage waits for the previous stage to complete its output before execution. When the dependency trigger weight is no greater than 0.7, the next stage loads the preloadable resources first, and enters the field validation after the output of the previous stage is completed. The field validation reads the set of fields required by the input interface of the next stage, and checks one by one whether there are fields with the same name in the output data of the previous stage, whether the actual type of the field is consistent with the expected type of the next stage, and whether the field value is not an empty value or an empty string. When all fields pass the existence, type consistency and non-null checks, the data contract check result is passed, and the output of the previous stage is mapped to the fields according to the input interface of the next stage before calling the next skill agent. If any field fails the existence, type consistency, and non-null checks, the data contract check result is "failed," triggering a stage rollback or audit confirmation. During the chained call process, the actual execution time of each stage and the state synchronization delay of adjacent stages are accumulated to obtain the total chained time. When the total chain time exceeds 1.2 times the user's expected time window, dynamic acceleration processing is performed, non-critical validation items are marked as delayed validation, and necessary field validation and status judgment are still retained.

7. The agent linkage method based on intent-triggered multi-skill chain collaboration as described in claim 6, characterized in that: The generation and output of the final execution feedback information includes, Read the execution results of each stage in the order of the multi-stage task chain, extract the stage output, stage status, stage time, number of retries and exception descriptions that participate in the closed-loop verification, and compare the transaction-related content in the stage output with the corresponding content in the macro transaction target. After the consistency comparison is passed, the outputs of each stage are spliced ​​together in the execution order, and the chain total time, overall execution status and exception details are attached to form the final execution feedback report. If the consistency comparison fails, write the exception details and trigger a rollback. To verify the integrity of the stage output during the transmission and aggregation process, the standardized output of each stage is concatenated in the stage order and a secure hash digest is calculated. The secure hash digest is then compared with the pre-stored digest. The integrity check passes when the secure hash digest matches the pre-stored digest. When the secure hash digest is inconsistent with the pre-stored digest, an integrity alarm is written and a rollback is triggered. The overall performance score is then read, and the final execution feedback report, integrity verification results, and overall performance score are written to the persistent task record. A structured log and natural language digest containing the declaration identifier, stage time, overall status, and anomaly details are output.

8. An agent linkage system based on intent-triggered multi-skill chain collaboration, employing the agent linkage method based on intent-triggered multi-skill chain collaboration as described in any one of claims 1 to 7, characterized in that: This includes an intent triage module, a skill triggering module, and a closed-loop feedback module; The intent triage module is used to receive macro-level transaction objectives, extract transaction objects, time windows, constraints, and target preferences, and generate intent feature vectors. Match the intent feature vector with the process template library to generate intent triage labels and multi-stage task chains arranged by dependencies; The skill triggering module is used to register multi-skill intelligent agents and configure standardized input and output interfaces, and form a callable resource pool based on resource consumption and data quality; based on the intent diversion label and the callable resource pool, the first-stage skill intelligent agent of the multi-stage task chain is triggered to obtain the stage execution result; The closed-loop feedback module is used to perform dependency judgment and data contract verification between adjacent stages, map the output of the previous stage to the input of the next stage and call them in a chain. The execution results of each stage are summarized for closed-loop verification and status synchronization, and the final execution feedback information is generated and output.

9. A computer device comprising a memory and a processor, wherein the memory stores a computer program, characterized in that, When the processor executes the computer program, it implements the steps of the agent linkage method based on intent-triggered multi-skill chain collaboration as described in any one of claims 1 to 7.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by the processor, it implements the steps of the intelligent agent linkage method based on intent-triggered multi-skill chain collaboration as described in any one of claims 1 to 7.

Images