Cross-vendor agent security collaboration method and system based on standardized protocol

Abstract

This invention provides a cross-vendor intelligent agent secure collaboration method and system based on a standardized protocol, relating to the field of intelligent agent collaboration. The method includes extracting protocol data to construct a dependency graph and converting standard fields; extracting operational features to calculate and coordinate permission vector conflict degrees; authorizing resource access based on the coordinated permission vectors and predicting release times; constructing a task dependency tree to decompose subtasks and allocate execution time periods; and correcting resource release predictions based on execution results. This invention solves the protocol compatibility and resource conflict problems in heterogeneous intelligent agent collaboration, improving system security and resource utilization efficiency.

Description

Technical Field

[0001] This invention relates to intelligent agent collaboration technology, and more particularly to a cross-vendor intelligent agent secure collaboration method and system based on a standardized protocol. Background Technology

[0002] With the rapid development of artificial intelligence technology, intelligent agent systems have been widely applied in numerous fields such as industry, healthcare, and transportation. As software entities capable of autonomously perceiving their environment, making decisions, and executing actions, intelligent agents' cross-vendor collaboration has become a crucial means of improving overall system performance and expanding application scenarios. Intelligent agents from different vendors exchange data and collaborate functionally through protocols to jointly complete complex tasks. Currently, collaboration between intelligent agents primarily relies on proprietary protocols defined by each vendor, which differ significantly in data structures, communication mechanisms, and security strategies.

[0003] Security issues are becoming increasingly prominent in cross-vendor intelligent agent collaboration. Intelligent agents from different vendors need to share resources, exchange data, and coordinate task execution, which necessitates the establishment of a unified and secure collaboration mechanism. Existing intelligent agent collaboration technologies typically employ point-to-point protocol adaptation or require vendors to adhere to the same protocol standard, but these methods face numerous challenges in practical applications.

[0004] In existing technologies, different vendors' intelligent agents use different protocol formats, and their data field definitions and semantics differ, making direct collaboration difficult. When integrating intelligent agents from new vendors, it is often necessary to develop specialized adapters, increasing system complexity and maintenance costs. In multi-agent collaborative environments, it is difficult to precisely control the access permissions of each agent to shared resources, easily leading to permission conflicts or resource contention. The lack of an effective permission coordination mechanism makes it difficult to achieve efficient resource utilization while ensuring security. Traditional resource allocation methods typically employ static pre-allocation or simple first-come, first-served strategies, failing to dynamically adjust resource allocation based on task dependencies and resource usage characteristics. This can result in resource idleness or task blocking during task execution, impacting overall execution efficiency. Summary of the Invention

[0005] This invention provides a cross-vendor intelligent agent secure collaboration method and system based on a standardized protocol, which can solve the problems in the prior art.

[0006] A first aspect of this invention provides a cross-vendor intelligent agent secure cooperation method based on a standardized protocol, comprising:

[0007] Receive raw protocol data, extract the relationships between data fields to construct a dependency graph, determine the semantic level based on the in-degree and out-degree of nodes in the dependency graph, and convert it into standard fields according to the semantic level to obtain adapted data;

[0008] Operational features are extracted from the adaptation data and encoded into permission vectors. The Euclidean distance between permission vectors is calculated as the conflict degree. When the conflict degree exceeds a preset conflict threshold, the conflict dimension is weighted down to obtain a coordinated permission vector.

[0009] Resource access authorization is sent to the agent based on the coordination permission vector. The average resource occupancy time is calculated based on the resource access record. The resource release time is predicted based on the average occupancy time. When the resource release time is earlier than the demand time, a time reservation binding is established.

[0010] Receive task requests, construct a task dependency tree based on the data flow between operations in the task request, traverse the task dependency tree to decompose it into subtasks, and allocate execution time slots to subtasks based on time reservations;

[0011] During the execution period, send subtask execution instructions, extract the actual resource consumption based on the subtask execution results, correct the resource release time based on the deviation between the actual resource consumption and the average occupied time, update the time reservation binding based on the corrected resource release time, and reallocate the execution period of subsequent subtasks.

[0012] The process involves receiving raw protocol data, extracting relationships between data fields to construct a dependency graph, determining the semantic level based on the in-degree and out-degree of nodes in the dependency graph, and converting the data into standard fields according to the semantic level to obtain adapted data, including:

[0013] Receive raw protocol data, parse it to obtain a set of data fields, and generate a field mapping table containing data field identifier codes;

[0014] Construct all data fields in the field mapping table into initial directed graph nodes, and record the field identifier code corresponding to each node;

[0015] The temporal overlap between fields is calculated based on the state transition sequence of data fields. The temporal correlation strength between fields is obtained by calculating the temporal overlap and the state transition frequency, forming a temporal correlation strength matrix.

[0016] Based on the temporal correlation strength matrix, directed edges are established between corresponding nodes, and the in-degree and out-degree values ​​of all nodes are counted to generate a node metric matrix.

[0017] The in-degree and out-degree values ​​in the node metric matrix are weighted and fused, and a node comprehensive score matrix is ​​obtained through multi-level combination calculation. Based on the node comprehensive score matrix, semantic levels are divided and a hierarchical mapping table is generated.

[0018] The hierarchical mapping table is used to traverse from the highest semantic level node to obtain the set of transmission paths. The path score value is calculated based on the number of transmission steps between nodes and the node comprehensive score matrix. The transmission path with the highest score value is taken as the main transmission path, and a path connection table is generated.

[0019] Reconstruct the dependency graph based on the path connection table, and convert the data fields into standard fields according to the semantic hierarchy order using the hierarchical mapping table to obtain adapted data.

[0020] Operational features are extracted from the adaptation data and encoded into permission vectors. The Euclidean distance between permission vectors is calculated as the conflict degree. When the conflict degree exceeds a preset conflict threshold, the conflict dimension is weighted down to obtain a coordinated permission vector, including:

[0021] Extract resource access operation sequences from the adaptation data, identify operation types and operation timestamps, generate an operation record table and establish an operation type index;

[0022] Calculate the operation time interval matrix based on the timestamps in the operation record table, construct the time feature matrix by combining the operation type index, and map the operation type to the feature code to generate the operation feature matrix;

[0023] The time series feature matrix is ​​normalized to generate a time series weight matrix. The time series weight matrix and the operation feature matrix are weighted to obtain a weighted feature matrix. The weighted feature matrix is ​​then converted into a permission vector through feature space mapping.

[0024] Calculate the Euclidean distance between permission vectors as the conflict degree, extract the dimensions that exceed the preset conflict threshold from the conflict degree, and generate a set of conflict dimensions;

[0025] Calculate the correlation coefficient matrix between each dimension in the conflict dimension set, group and cluster the conflict dimensions based on the correlation coefficient matrix, allocate the weight reduction ratio according to the number of dimensions in the group, perform differentiated weight reduction on each group dimension until the conflict degree of all dimensions meets the preset conflict threshold constraint, and obtain the coordination permission vector.

[0026] Resource access authorization is sent to the agent based on the coordinated permission vector. The average resource occupancy time is calculated based on the resource access records. The resource release time is predicted based on the average occupancy time. When the resource release time is earlier than the demand time, a time reservation binding is established, including:

[0027] Based on the coordinated permission vector, the agent identifier and permission dimension are extracted, the permission dimension is mapped to the accessible resource type, and a resource access authorization containing the resource type and access time limit is sent to the agent.

[0028] Receive resource access records generated by intelligent agents under resource access authorization, calculate the time difference between the start time and end time of resource access as the single occupancy duration, and generate an occupancy duration sequence according to resource type;

[0029] Calculate the time distance between the time corresponding to each single time of occupation in the occupation duration sequence and the current time, calculate the time-series decay weight based on the time distance, and calculate the average resource occupation duration by weighting the occupation duration sequence with the time-series decay weight;

[0030] Receive a resource request containing the demand time and resource type, obtain the corresponding average resource occupancy time according to the resource type in the resource request, extract the access start time of the currently occupied resource instance, and add the access start time to the average resource occupancy time to obtain the resource release time;

[0031] Extract task priority from resource requests, calculate the time interval between resource release time and demand time, calculate reservation confidence based on time interval and task priority, bind resource instance identifier to resource request identifier when resource release time is earlier than demand time, and store reservation confidence in the establishment time reservation binding.

[0032] Upon receiving a task request, a task dependency tree is constructed based on the data flow between operations within the task request. The task dependency tree is traversed to decompose the task into subtasks. Execution time slots are allocated to the subtasks based on time reservations, including:

[0033] Receive task requests, extract operation sequences from task requests, identify data input ports and data output ports of each operation, determine the data flow between operations based on the connection relationship between data output ports and data input ports, and construct a task dependency tree based on the data flow between operations.

[0034] Extract the dependency path formed by the parent node and child node from the task dependency tree, calculate the matching degree between the output data of the parent node and the input data of the child node in the dependency path, assign path weight to each dependency path based on the matching degree, traverse the task dependency tree to decompose each node into subtasks, and establish the association between subtasks and dependency paths.

[0035] Extract the resource release time and reservation confidence from the time reservation binding, obtain the path weight of the subtask's associated dependency path, combine the path weight and reservation confidence to calculate the allocation priority, and allocate execution time slots to the subtasks according to the allocation priority order based on the time reservation binding;

[0036] Monitor the data transmission rate of the path that the subtask depends on during execution. When the data transmission rate deviates from the preset transmission rate by more than the preset rate threshold, adjust the path weight according to the rate deviation and recalculate the priority allocation based on the adjusted path weight.

[0037] Extract dependency paths consisting of parent and child nodes from the task dependency tree, calculate the matching degree between the output data volume of the parent node and the input data volume of the child node in the dependency path, assign path weights to each dependency path based on the matching degree, traverse the task dependency tree to decompose each node into subtasks, and establish the association between subtasks and dependency paths, including:

[0038] Extract all directed connections between parent and child nodes from the task dependency tree to form a dependency path. Extract the output data volume of the operation corresponding to the parent node and the input data volume of the operation corresponding to the child node in the dependency path. Calculate the data flow saturation based on the output data volume and the input data volume. Calculate the matching degree based on the data flow saturation and the number of levels crossed between nodes in the dependency path.

[0039] Identify the convergence node where multiple dependency paths converge in the task dependency tree, count the number of incoming dependency paths in the convergence node, and extract the matching degree of each incoming dependency path to calculate the distribution dispersion.

[0040] The path competitiveness is calculated based on the number and distribution dispersion of the dependent paths, and the path weight is calculated based on the matching degree of the dependent paths and the path competitiveness.

[0041] Starting from the root node of the task dependency tree, traverse each node in terms of level depth, break down the operation corresponding to the traversed node into subtasks and record the level position of the subtasks.

[0042] Identify the incoming edge dependency path of the corresponding node of the subtask as the child node and the outgoing edge dependency path as the parent node, extract the path weight of the incoming edge dependency path and the path weight of the outgoing edge dependency path, calculate the path inheritance degree of the subtask, and bind the subtask identifier with the path inheritance degree to establish the association relationship between the subtask and the dependency path.

[0043] During the execution period, subtask execution instructions are sent. Based on the subtask execution results, the actual resource consumption is extracted. The resource release time is adjusted based on the deviation between the actual resource consumption and the average usage time. The time reservation binding is updated based on the adjusted resource release time, and subsequent subtask execution periods are reallocated, including:

[0044] Send subtask execution instructions during the execution period and monitor the subtask execution process;

[0045] Collect the start and end times of subtask execution to calculate the actual execution time, extract the resource instance identifiers used during the execution of the subtask, and calculate the actual resource consumption based on the resource instance identifiers and the actual execution time;

[0046] Extract historical resource consumption data of the same resource type from historical execution records to calculate the average usage time, calculate the consumption deviation between the actual resource consumption and the average usage time, extract the load fluctuation coefficient of the resource instance identifier, and calculate the deviation correction amount based on the consumption deviation and the load fluctuation coefficient.

[0047] Identify the path inheritance degree of the dependent paths corresponding to subtasks, determine the propagation range of the deviation correction amount based on the path inheritance degree, extract the resource instance identifiers associated with subsequent subtasks within the propagation range, and correct the resource release time corresponding to the resource instance identifiers within the propagation range based on the deviation correction amount.

[0048] Extract the time offset between the corrected resource release time and the original resource release time, and identify subsequent reserved records in the time reservation binding where the resource release time is later than the corrected resource release time;

[0049] Adjust the resource release time in the subsequent reserved records according to the time offset, update the time reservation binding according to the corrected resource release time, and reallocate the execution time of subsequent subtasks according to the allocation priority.

[0050] A second aspect of this invention provides a cross-vendor intelligent agent secure collaboration system based on a standardized protocol, comprising:

[0051] The protocol adaptation module is used to receive raw protocol data, extract the relationship between data fields to construct a dependency graph, determine the semantic level based on the in-degree and out-degree of the nodes in the dependency graph, and convert it into standard fields according to the semantic level to obtain adaptation data.

[0052] The permission coordination module is used to extract operation features from the adaptation data and encode them into permission vectors. It calculates the Euclidean distance between permission vectors as the conflict degree. When the conflict degree exceeds the preset conflict threshold, the conflict dimension is reduced in weight to obtain the coordinated permission vector.

[0053] The resource reservation module is used to send resource access authorization to the agent based on the coordination permission vector, calculate the average resource occupancy time based on the resource access record, predict the resource release time based on the average occupancy time, and establish time reservation binding when the resource release time is earlier than the demand time.

[0054] The task decomposition module is used to receive task requests, build a task dependency tree based on the data flow between operations in the task request, traverse the task dependency tree to decompose it into subtasks, and allocate execution time slots to subtasks based on time reservations.

[0055] The dynamic scheduling module is used to send subtask execution instructions within the execution period, extract the actual resource consumption based on the subtask execution results, correct the resource release time based on the deviation between the actual resource consumption and the average occupied time, update the time reservation binding based on the corrected resource release time, and reallocate the execution period of subsequent subtasks.

[0056] A third aspect of the present invention provides an electronic device, comprising:

[0057] processor;

[0058] Memory used to store processor-executable instructions;

[0059] The processor is configured to invoke instructions stored in the memory to execute the aforementioned method.

[0060] A fourth aspect of the present invention provides a computer-readable storage medium having stored thereon computer program instructions that, when executed by a processor, implement the aforementioned method.

[0061] In this embodiment, by extracting the relationships between data fields to construct a dependency graph and performing standardized transformation based on semantic hierarchy, the incompatibility of protocols between intelligent agents from different vendors is resolved, enabling seamless data interaction between heterogeneous systems. Employing permission vector encoding and conflict degree calculation mechanisms, the system can intelligently identify operational conflicts and adaptively adjust weighting, effectively avoiding permission contention in multi-agent systems and improving system stability. Predicting resource release times based on average resource occupancy time and establishing time reservation bindings achieves efficient resource allocation and utilization, reducing resource idle waiting time and improving the overall system throughput. By constructing a task dependency tree for task decomposition and time allocation, and dynamically adjusting resource release predictions based on actual execution results, a closed-loop feedback task scheduling mechanism is established, ensuring task execution efficiency and resource utilization during cross-vendor intelligent agent collaboration. The overall solution does not require changes to the existing internal structure of the intelligent agents; secure and efficient collaboration between cross-vendor intelligent agents can be achieved solely through external coordination mechanisms, reducing system integration difficulty and implementation costs. Attached Figure Description

[0062] Figure 1 This is a flowchart illustrating a cross-vendor intelligent agent secure collaboration method based on a standardized protocol, as described in an embodiment of the present invention.

[0063] Figure 2 This is a flowchart illustrating the task priority calculation and dynamic scheduling execution process in an embodiment of the present invention. Detailed Implementation

[0064] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0065] The technical solution of the present invention will be described in detail below with reference to specific embodiments. These specific embodiments can be combined with each other, and the same or similar concepts or processes may not be described again in some embodiments.

[0066] Figure 1 This is a flowchart illustrating a cross-vendor intelligent agent secure collaboration method based on a standardized protocol, as described in an embodiment of the present invention. Figure 1 As shown, the method includes:

[0067] Receive raw protocol data, extract the relationships between data fields to construct a dependency graph, determine the semantic level based on the in-degree and out-degree of nodes in the dependency graph, and convert it into standard fields according to the semantic level to obtain adapted data;

[0068] Operational features are extracted from the adaptation data and encoded into permission vectors. The Euclidean distance between permission vectors is calculated as the conflict degree. When the conflict degree exceeds a preset conflict threshold, the conflict dimension is weighted down to obtain a coordinated permission vector.

[0069] Resource access authorization is sent to the agent based on the coordination permission vector. The average resource occupancy time is calculated based on the resource access record. The resource release time is predicted based on the average occupancy time. When the resource release time is earlier than the demand time, a time reservation binding is established.

[0070] Receive task requests, construct a task dependency tree based on the data flow between operations in the task request, traverse the task dependency tree to decompose it into subtasks, and allocate execution time slots to subtasks based on time reservations;

[0071] During the execution period, send subtask execution instructions, extract the actual resource consumption based on the subtask execution results, correct the resource release time based on the deviation between the actual resource consumption and the average occupied time, update the time reservation binding based on the corrected resource release time, and reallocate the execution period of subsequent subtasks.

[0072] In one optional implementation, raw protocol data is received, the relationships between data fields are extracted to construct a dependency graph, the semantic level is determined based on the in-degree and out-degree of nodes in the dependency graph, and the data is converted into standard fields according to the semantic level to obtain adapted data, including:

[0073] Receive raw protocol data, parse it to obtain a set of data fields, and generate a field mapping table containing data field identifier codes;

[0074] Construct all data fields in the field mapping table into initial directed graph nodes, and record the field identifier code corresponding to each node;

[0075] The temporal overlap between fields is calculated based on the state transition sequence of data fields. The temporal correlation strength between fields is obtained by calculating the temporal overlap and the state transition frequency, forming a temporal correlation strength matrix.

[0076] Based on the temporal correlation strength matrix, directed edges are established between corresponding nodes, and the in-degree and out-degree values ​​of all nodes are counted to generate a node metric matrix.

[0077] The in-degree and out-degree values ​​in the node metric matrix are weighted and fused, and a node comprehensive score matrix is ​​obtained through multi-level combination calculation. Based on the node comprehensive score matrix, semantic levels are divided and a hierarchical mapping table is generated.

[0078] The hierarchical mapping table is used to traverse from the highest semantic level node to obtain the set of transmission paths. The path score value is calculated based on the number of transmission steps between nodes and the node comprehensive score matrix. The transmission path with the highest score value is taken as the main transmission path, and a path connection table is generated.

[0079] Reconstruct the dependency graph based on the path connection table, and convert the data fields into standard fields according to the semantic hierarchy order using the hierarchical mapping table to obtain adapted data.

[0080] In one embodiment, raw protocol data is first received, which may originate from various communication devices or network monitoring systems. The raw protocol data typically contains multiple formatted or unformatted information blocks. The received raw protocol data is then parsed to extract various data fields, such as request identifiers, timestamps, and data payloads. The parsing process employs a layered parsing strategy, first parsing the packet header to obtain basic information, and then further parsing the data body based on the header information.

[0081] After parsing, a field mapping table containing data field identifiers is generated. The field mapping table is stored in key-value pair format, where the key is an automatically generated unique identifier, and the value is the corresponding data field content and its attribute description. For example, for a network communication protocol, the identifier "F001" might correspond to the field "source IP address," and the identifier "F002" might correspond to the "destination port number." The field mapping table not only records field names but also contains metadata such as data type and length limits, laying the foundation for subsequent analysis.

[0082] Based on the generated field mapping table, all data fields are used to construct nodes in an initial directed graph. Each node corresponds to a data field, and the identifier of that field is recorded as the unique identifier of the node. Initially, there are no connections between nodes, forming a discrete set of points. To facilitate subsequent processing, a node attribute table is also maintained to record characteristic information such as the data type and frequency of occurrence of the corresponding fields of the nodes.

[0083] By analyzing the state transition sequences of each field in the original data, the temporal overlap between fields is calculated. Temporal overlap reflects the correlation between the changes of two fields over time. Specifically, a state transition time window is constructed for each pair of fields, and the probability of a state change occurring within the same time window is statistically analyzed. For example, if field A changes, and field B also frequently changes within a specific time window, then the two have a high degree of temporal overlap.

[0084] Furthermore, the temporal correlation strength between fields is calculated by combining state transition frequency and temporal overlap. The temporal correlation strength is obtained by applying a state transition frequency weight to the temporal overlap, forming a temporal correlation strength matrix. This matrix is ​​an N×N two-dimensional array (N is the number of fields), where each element represents the correlation strength value between the corresponding row and column fields. The values ​​are usually normalized to between 0 and 1, with larger values ​​indicating stronger correlations.

[0085] Based on the temporal association strength matrix, directed edges are established between corresponding nodes. Specifically, a threshold T is set; when the association strength between two nodes exceeds T, a directed edge is established from the source field to the target field, with the edge weight being the corresponding association strength value. After constructing the edges, the in-degree and out-degree values ​​of each node are calculated to generate a node metric matrix. The node metric matrix records the in-degree (the number of edges from other nodes to this node) and out-degree (the number of edges from this node to other nodes) of each node.

[0086] The in-degree and out-degree values ​​in the node metric matrix are weighted and fused to calculate the comprehensive score for each node. The weighting method can be adjusted according to the specific application scenario; generally, an in-degree weight slightly higher than the out-degree weight is used, such as an in-degree weight of 0.6 and an out-degree weight of 0.4. Through multi-level combination calculations, considering the first-order connectivity and second-order propagation effects of nodes, the comprehensive node score matrix is ​​obtained.

[0087] Based on the node comprehensive scoring matrix, all nodes are semantically hierarchically divided. Nodes with higher scores typically represent higher-level semantic abstractions and are classified into higher levels; nodes with lower scores may represent basic data fields and are classified into lower levels. After the division is completed, a hierarchical mapping table is generated, recording the semantic level number and description information corresponding to each node.

[0088] Using a hierarchical mapping table, starting from the node at the highest semantic level, the dependency graph is traversed to obtain the set of all possible propagation paths. For each propagation path, a path score is calculated based on the number of propagation steps between nodes and the node comprehensive score matrix. The path score calculation considers path length and node importance; generally, the shorter the path and the more important nodes it contains, the higher the score. The propagation path with the highest score is determined as the main propagation path, and a path connection table is generated to record the connection relationships between nodes on the main path.

[0089] Based on the reconstructed and optimized dependency graph using the path connection table, and combined with the hierarchical mapping table, data fields are converted into standard fields according to semantic hierarchy. During the conversion process, higher-level nodes are typically mapped to core standard fields, while lower-level nodes are mapped to auxiliary or extended standard fields. After the conversion is complete, adapted data conforming to the standard format is generated, which can be used for subsequent system processing or data exchange.

[0090] In practical applications, there may be multiple proprietary protocols that need to be converted into a unified standard. This method can automatically identify the dependencies and semantic levels between fields in a proprietary protocol, achieving efficient and accurate protocol conversion, reducing manual intervention, and improving system interoperability.

[0091] In one optional implementation, operational features are extracted from the adaptation data and encoded into permission vectors. The Euclidean distance between permission vectors is calculated as the conflict degree. When the conflict degree exceeds a preset conflict threshold, the conflict dimension is weighted down to obtain a coordinated permission vector, including:

[0092] Extract resource access operation sequences from the adaptation data, identify operation types and operation timestamps, generate an operation record table and establish an operation type index;

[0093] Calculate the operation time interval matrix based on the timestamps in the operation record table, construct the time feature matrix by combining the operation type index, and map the operation type to the feature code to generate the operation feature matrix;

[0094] The time series feature matrix is ​​normalized to generate a time series weight matrix. The time series weight matrix and the operation feature matrix are weighted to obtain a weighted feature matrix. The weighted feature matrix is ​​then converted into a permission vector through feature space mapping.

[0095] Calculate the Euclidean distance between permission vectors as the conflict degree, extract the dimensions that exceed the preset conflict threshold from the conflict degree, and generate a set of conflict dimensions;

[0096] Calculate the correlation coefficient matrix between each dimension in the conflict dimension set, group and cluster the conflict dimensions based on the correlation coefficient matrix, allocate the weight reduction ratio according to the number of dimensions in the group, perform differentiated weight reduction on each group dimension until the conflict degree of all dimensions meets the preset conflict threshold constraint, and obtain the coordination permission vector.

[0097] When extracting resource access operation sequences from the adaptation data, the access requests generated by each agent are parsed, and the operation type and timestamp information in the requests are recorded. Taking a cross-vendor data analysis scenario as an example, the operation sequences generated by the data acquisition agent include reading sensor data, writing to the cache, and querying historical records, etc., and each operation includes a timestamp of the operation execution. The collaboration center organizes this information into an operation record table, with each row containing three fields: operation identifier, operation type, and timestamp. At the same time, an operation type index is created to map operations of the same type to the index table for easy and fast retrieval later.

[0098] Based on the timestamp information in the operation log table, the collaboration center calculates the temporal interval matrix between operations. For n operations in the operation log table, an n×n matrix is ​​constructed, where the element (i, j) represents the time interval between operation i and operation j. Taking a data acquisition agent as an example, the timestamp of the operation "read sensor data" is 10:15:30, and the timestamp of the operation "write to cache" is 10:15:45, so the time interval between these two operations is 15 seconds. Combining the operation type index, the collaboration center constructs a temporal feature matrix, where each element represents the strength of the temporal relationship between different types of operations. Simultaneously, according to a preset feature mapping rule, the operation type is mapped to a feature code. For example, "read sensor data" is mapped to the code [1, 0, 0, 0, 1], and "write to cache" is mapped to the code [0, 1, 0, 0, 1], which are combined to form the operation feature matrix.

[0099] The collaboration center normalizes the temporal feature matrix using the Min-Max normalization method to scale the temporal feature values ​​to the [0, 1] interval, generating a temporal weight matrix. After normalizing the temporal features of the data acquisition agent, the resulting weight values ​​are distributed between 0.2 and 0.8, representing the temporal correlation strength of different operations. The temporal weight matrix and the operation feature matrix are weighted and calculated using the weight fusion formula: Weighted Feature = Σ(Temporal Weight × Feature Value), resulting in a weighted feature matrix. The collaboration center uses principal component analysis to reduce the dimensionality of the weighted feature matrix, extracting the main feature components, and converting it into a multi-dimensional permission vector through feature space mapping. Taking the data acquisition agent as an example, the final generated permission vector is [0.75, 0.82, 0.45, 0.38, 0.91], where each dimension represents the permission strength of read, write, modify, delete, and query operations, respectively.

[0100] The collaboration center calculates the Euclidean distance between the permission vectors of different agents as a quantitative indicator of permission conflict. The Euclidean distance calculation formula is: Distance = √(Σ(vector 1 dimension value - vector 2 dimension value)²). The Euclidean distance between the permission vectors of the data acquisition agent [0.75, 0.82, 0.45, 0.38, 0.91] and the permission vectors of the data analysis agent [0.68, 0.35, 0.72, 0.41, 0.88] is 0.57. The collaboration center sets a preset conflict threshold of 0.3 and finds that the overall conflict level of 0.57 exceeds the threshold, requiring further identification of specific conflict dimensions. By calculating the difference dimension by dimension, it is found that the difference in the write dimension (0.47) and the difference in the modify dimension (0.27) are the main sources of conflict, generating a conflict dimension set {1, 2}, corresponding to write and modify operations.

[0101] The Collaboration Center calculates the correlation coefficient matrix among the dimensions in the conflict dimension set and uses the Pearson correlation coefficient formula to assess the correlation between dimensions. Based on historical operation data, the correlation coefficient between write and modify operations is calculated to be 0.32, indicating a moderate level of correlation. Based on the correlation coefficient matrix, a hierarchical clustering algorithm is used to group the conflict dimensions, grouping dimensions with correlation coefficients higher than 0.3 into a single group, resulting in a group containing both write and modify dimensions. The Collaboration Center assigns a weighting ratio based on the number of dimensions within each group: 0.3 for single-dimensional groups, 0.4 for two-dimensional groups, and 0.5 for groups with three or more dimensions. For the group containing both write and modify dimensions, a weighting ratio of 0.4 is applied, reducing the write permission of the data acquisition agent from 0.82 to 0.492 and the modify permission from 0.45 to 0.27; for the data analysis agent, reducing the write permission from 0.35 to 0.21 and the modify permission from 0.72 to 0.432.

[0102] After weight reduction, the Euclidean distance was recalculated, resulting in a conflict degree of 0.287, which is lower than the preset conflict threshold of 0.3, thus satisfying the conflict constraint. The collaboration center uses the weighted permission vector as the coordination permission vector. The coordination permission vector for the data acquisition agent is [0.75, 0.492, 0.27, 0.38, 0.91], and the coordination permission vector for the data analysis agent is [0.68, 0.21, 0.432, 0.41, 0.88]. The collaboration center sends the coordination permission vectors to the corresponding agents, and the agents adjust their local permission configurations according to the coordination permission vectors, achieving dynamic adjustment of resource access control. When an agent submits a resource access request, the collaboration center determines whether the operation is allowed based on the permission strength in the coordination permission vector. The permission strength threshold for write operations is set to 0.4, therefore the data acquisition agent is allowed to perform write operations, while the data analysis agent is denied write operations, ensuring resource access security during cross-vendor agent collaboration.

[0103] In this embodiment, complex resource access behaviors are transformed into vector representations in a multi-dimensional permission space, transforming permission conflict analysis from qualitative judgment to quantitative calculation. Euclidean distance is used as the conflict metric, combined with dimensional correlation analysis and grouping clustering weight reduction strategies to achieve precise permission adjustment. Through differentiated weight reduction technology, while ensuring resource access security, the original permissions of the agent are preserved to the greatest extent, avoiding the "one-size-fits-all" restriction problem in traditional permission management. This improves the security and efficiency of cross-vendor agent collaboration, providing a reliable permission management mechanism for collaborative work between agents from different vendors in a shared environment.

[0104] In one optional implementation, resource access authorization is sent to the agent based on a coordinated permission vector; the average resource occupancy time is calculated based on the resource access records; the resource release time is predicted based on the average occupancy time; and a time reservation binding is established when the resource release time is earlier than the demand time, including:

[0105] Based on the coordinated permission vector, the agent identifier and permission dimension are extracted, the permission dimension is mapped to the accessible resource type, and a resource access authorization containing the resource type and access time limit is sent to the agent.

[0106] Receive resource access records generated by intelligent agents under resource access authorization, calculate the time difference between the start time and end time of resource access as the single occupancy duration, and generate an occupancy duration sequence according to resource type;

[0107] Calculate the time distance between the time corresponding to each single time of occupation in the occupation duration sequence and the current time, calculate the time-series decay weight based on the time distance, and calculate the average resource occupation duration by weighting the occupation duration sequence with the time-series decay weight;

[0108] Receive a resource request containing the demand time and resource type, obtain the corresponding average resource occupancy time according to the resource type in the resource request, extract the access start time of the currently occupied resource instance, and add the access start time to the average resource occupancy time to obtain the resource release time;

[0109] Extract task priority from resource requests, calculate the time interval between resource release time and demand time, calculate reservation confidence based on time interval and task priority, bind resource instance identifier to resource request identifier when resource release time is earlier than demand time, and store reservation confidence in the establishment time reservation binding.

[0110] Resource access authorization for agents is based on a coordinated permission vector, a multi-dimensional data structure containing agent identifiers and permission dimension information. The agent identifier, such as "Agent-127," is extracted from the coordinated permission vector, along with permission dimension values, such as "Computing Resource: High," "Storage Resource: Medium," and "Network Resource: Low." Using a predefined mapping rule, the permission dimension values ​​are converted into specific accessible resource types; for example, "Computing Resource: High" is mapped to "GPU Server Type A, CPU Server Type B." Based on the mapping result, a resource access authorization token is generated, containing the resource type identifier and access validity information, such as "{Resource Type: 'GPU Server Type A', Access Validity: '2023-04-10 08:00:00 to 2023-04-10 20:00:00'}". Finally, this authorization token is sent to the corresponding agent.

[0111] After receiving resource access records generated by the agent under authorization, the system calculates the resource usage duration. Resource access records include information such as resource type, instance ID, access start time, and access end time, such as "{Resource type: 'GPU Server Type A', Instance ID: 'GPU-007', Start time: '2023-04-10 09:15:23', End time: '2023-04-10 11:45:56'}". When calculating the duration of a single access, the system extracts the access start time and end time and calculates the time difference, such as the example where the usage duration is 2 hours, 30 minutes, and 33 seconds. Multiple access records of the same resource type are arranged in chronological order to form a usage duration sequence, such as "[2.51 hours, 1.75 hours, 3.12 hours, 2.88 hours]".

[0112] When calculating the average resource usage time based on the usage duration sequence, a time-decaying weighted average method is used. The time distance between each usage duration and the current time is calculated. For example, if the current time is "2023-04-15 10:00:00" and the last access ended at "2023-04-14 16:30:00", the time distance is 17.5 hours. The time-decay weight is calculated based on the time distance using an exponential decay function: w = exp(-λ×d), where d is the time distance (in days) and λ is the decay coefficient (which can be set to 0.2). For the above usage duration sequence, if the corresponding time distances are 0.73 days, 1.25 days, 3.42 days, and 5.1 days, the corresponding weights are 0.864, 0.779, 0.505, and 0.359, respectively. The average resource occupancy time was calculated using a weighted average: (2.51×0.864 + 1.75×0.779 + 3.12×0.505 + 2.88×0.359) / (0.864 + 0.779 + 0.505 + 0.359) = 2.43 hours.

[0113] Upon receiving a resource request, a resource release time prediction is performed. The resource request includes the request time, resource type, and task priority information, such as "{Request Time: '2023-04-16 09:00:00', Resource Type: 'GPU Server Type A', Task Priority: 8}". Based on the resource type in the request, the average resource occupancy time is queried; for example, the average occupancy time for "GPU Server Type A" is 2.43 hours. The access start time of the currently occupied instance for this type of resource is checked; for example, the current access to "GPU-007" started at "2023-04-15 14:30:00". The access start time is added to the average resource occupancy time to obtain the predicted resource release time: "2023-04-15 14:30:00" + 2.43 hours = "2023-04-15 16:55:48".

[0114] Establish a time reservation binding, extract the task priority value from the resource request (e.g., "8"), and calculate the time interval between the resource release time and the request time, such as "2023-04-16 09:00:00" - "2023-04-15 16:55:48" = 16.07 hours. Calculate the reservation confidence score based on the time interval and task priority using the function: c = min(p / 10 × (1 - t / 48), 1), where p is the priority and t is the time interval (hours). In the example, the reservation confidence score is min(0.8 × (1 - 16.07 / 48), 1) = 0.53. When it is confirmed that the resource release time is earlier than the demand time, a time-reserved binding record is created, which includes the resource instance identifier, resource request identifier and reservation confidence, such as "{resource instance: 'GPU-007', request ID: 'Req-256', reservation confidence: 0.53}", and this binding record is stored in the reservation management database.

[0115] This embodiment can identify and reserve resources that are about to be released in advance, avoiding resource fragmentation and prolonged task waiting time. By introducing reservation confidence, the reserved resources can also be dynamically adjusted according to task importance and time urgency, further improving resource utilization efficiency.

[0116] like Figure 2 The diagram shows the flowchart of task priority calculation and dynamic scheduling execution in this embodiment.

[0117] In one optional implementation, receiving a task request, constructing a task dependency tree based on the data flow between operations in the task request, traversing the task dependency tree to decompose it into subtasks, and allocating execution time slots to the subtasks based on time reservation bindings include:

[0118] Receive task requests, extract operation sequences from task requests, identify data input ports and data output ports of each operation, determine the data flow between operations based on the connection relationship between data output ports and data input ports, and construct a task dependency tree based on the data flow between operations.

[0119] Extract the dependency path formed by the parent node and child node from the task dependency tree, calculate the matching degree between the output data of the parent node and the input data of the child node in the dependency path, assign path weight to each dependency path based on the matching degree, traverse the task dependency tree to decompose each node into subtasks, and establish the association between subtasks and dependency paths.

[0120] Extract the resource release time and reservation confidence from the time reservation binding, obtain the path weight of the subtask's associated dependency path, combine the path weight and reservation confidence to calculate the allocation priority, and allocate execution time slots to the subtasks according to the allocation priority order based on the time reservation binding;

[0121] Monitor the data transmission rate of the path that the subtask depends on during execution. When the data transmission rate deviates from the preset transmission rate by more than the preset rate threshold, adjust the path weight according to the rate deviation and recalculate the priority allocation based on the adjusted path weight.

[0122] It receives task requests containing multiple operations, each with specific data input and output ports. By analyzing the connections between these ports, it constructs a task dependency tree that reflects the dependencies between operations.

[0123] When a task request is received, it typically contains a sequence of operations, such as image acquisition, preprocessing, feature extraction, and classification in an image processing task. After extracting these operations, the data input and output ports for each operation are identified. For example, the input port of an image preprocessing operation receives the raw image data, while the output port provides the preprocessed image data. Based on the connection between the output port of the preprocessing operation and the input port of the feature extraction operation, the flow of data from preprocessing to feature extraction is determined, thus establishing a parent-child relationship between these two operation nodes in the task dependency tree.

[0124] After constructing the task dependency tree, extract all dependency paths formed by parent and child nodes in the tree. For each dependency path, calculate the matching degree between the amount of output data from the parent node and the amount of input data from the child node. The matching degree can be calculated by dividing the amount of output data from the parent node by the amount of input data required by the child node. When the matching degree is close to 1, it indicates that the data flow efficiency is the highest; if the matching degree is too high, it indicates that redundant data has been generated; if the matching degree is too low, it indicates that insufficient data may cause the child node to wait. Based on this matching degree, assign weights to each dependency path; the closer the matching degree is to 1, the higher the path weight.

[0125] When traversing the task dependency tree, each operation node is decomposed into independently schedulable subtasks. The decomposition process considers the computational complexity of the operation, data dependencies, and system resource availability. For example, large-scale matrix operations can be decomposed into multiple parallel small matrix operation subtasks. Simultaneously, an association is established between each subtask and its dependency path, recording the upstream data sources the subtask depends on and the downstream tasks that need to provide that data.

[0126] During the resource allocation phase, resource release time and reservation confidence information are extracted from the time reservation binding. The reservation confidence indicates the reliability of resource release at the expected time, ranging from 0 to 1, with higher values ​​indicating greater reliability. After obtaining the path weights of the dependent paths associated with each subtask, a weighted average of the path weights and reservation confidence is calculated to obtain the subtask allocation priority. The calculation formula can be designed as: Allocation Priority = Path Weight × 0.6 + Reservation Confidence × 0.4, where the weight coefficients can be adjusted according to the actual application scenario.

[0127] Execution time slots are assigned to subtasks in descending order of priority. Subtasks with higher priority can choose execution time slots with better resource conditions or earlier execution times. During the allocation process, it is ensured that the execution time slots of subtasks satisfy the constraint that the predecessor tasks on their dependency paths have been completed.

[0128] During task execution, the data transmission rate on the dependent path is continuously monitored. When the deviation between the actual transmission rate and the preset transmission rate exceeds a preset threshold, the path weight needs to be dynamically adjusted. For example, if the preset threshold is 20%, when the actual transmission rate is 30% lower than the preset rate, the path weight can be reduced by the corresponding percentage. The correction formula is: Corrected path weight = Original path weight × (1 - Rate deviation coefficient), where the rate deviation coefficient can be taken as (Actual deviation percentage - Preset threshold) / 100.

[0129] Priority allocation is recalculated based on the revised path weights, and the execution schedule of subsequent subtasks is adjusted as necessary. This dynamic adjustment mechanism enables task scheduling to adapt to real-time network conditions and changes in computing resources, thereby improving overall execution efficiency.

[0130] For example, after constructing the dependency tree, it was found that the output data volume of the parsing operation was much larger than the input volume required by the filtering operation, with a matching degree of 3.5, indicating that a large amount of redundant data was generated. Based on this, a lower path weight of 0.4 was assigned. During resource allocation, if the reserved confidence level of the parsing subtask associated with this path is 0.8, then its allocation priority is 0.4 × 0.6 + 0.8 × 0.4 = 0.56.

[0131] If, during execution, the actual data transmission rate is found to be 25% slower than expected, exceeding the preset threshold of 20%, the corrected path weight will be 0.4×(1-(25-20) / 100)=0.38, and the recalculated allocation priority will be reduced to 0.54, which may lead to adjustments in the execution time of subsequent related subtasks.

[0132] Through the above mechanisms, intelligent task scheduling based on data flow characteristics and resource status is achieved, thereby improving system resource utilization and task execution efficiency.

[0133] In one optional implementation, the dependency path consisting of parent and child nodes is extracted from the task dependency tree. The matching degree between the output data volume of the parent node and the input data volume of the child node in the dependency path is calculated. Path weights are assigned to each dependency path based on the matching degree. The task dependency tree is traversed to decompose each node into subtasks, and the association between subtasks and dependency paths is established, including:

[0134] Extract all directed connections between parent and child nodes from the task dependency tree to form a dependency path. Extract the output data volume of the operation corresponding to the parent node and the input data volume of the operation corresponding to the child node in the dependency path. Calculate the data flow saturation based on the output data volume and the input data volume. Calculate the matching degree based on the data flow saturation and the number of levels crossed between nodes in the dependency path.

[0135] Identify the convergence node where multiple dependency paths converge in the task dependency tree, count the number of incoming dependency paths in the convergence node, and extract the matching degree of each incoming dependency path to calculate the distribution dispersion.

[0136] The path competitiveness is calculated based on the number and distribution dispersion of the dependent paths, and the path weight is calculated based on the matching degree of the dependent paths and the path competitiveness.

[0137] Starting from the root node of the task dependency tree, traverse each node in terms of level depth, break down the operation corresponding to the traversed node into subtasks and record the level position of the subtasks.

[0138] Identify the incoming edge dependency path of the corresponding node of the subtask as the child node and the outgoing edge dependency path as the parent node, extract the path weight of the incoming edge dependency path and the path weight of the outgoing edge dependency path, calculate the path inheritance degree of the subtask, and bind the subtask identifier with the path inheritance degree to establish the association relationship between the subtask and the dependency path.

[0139] When extracting the dependency path formed by parent and child nodes from the task dependency tree, the agent cooperative scheduler parses the dependency tree into a directed graph structure, where each node corresponds to an agent operation and the edges correspond to the data flow relationship between operations. Taking an industrial equipment monitoring scenario as an example, the equipment data acquisition agent acts as the parent node, outputting equipment operating status data, and the fault diagnosis agent acts as the child node, receiving and analyzing this data, forming a dependency path. The coordination center extracts 120MB / hour of equipment operating data output by the parent node in this path, and the designed input processing capacity of the child node is 200MB / hour, resulting in a data flow saturation of 0.6. Considering that the nodes in this dependency path cross only one level, according to the matching degree calculation formula: matching degree = saturation degree × (1 - 0.1 × number of levels), the matching degree of this path is 0.54.

[0140] When identifying the convergence node of the task dependency tree, the collaborative scheduler detects that the fault diagnosis agent simultaneously receives two incoming edge dependency paths from both the device data acquisition agent and the historical data analysis agent, thus forming a convergence node. Statistics show that this convergence node has two incoming edge dependency paths, with matching degrees of 0.54 and 0.62 respectively. The distribution dispersion is calculated using the standard deviation method: Dispersion = sqrt(sum((matching degree - average matching degree)²) / number of paths), yielding a dispersion of 0.04. Based on the path competition formula: Competition = number of incoming edge paths × (1 + dispersion), the path competition is calculated to be 2.08.

[0141] Based on the above calculation results, the formula used to assign weights to dependency paths is: Path Weight = Matching Degree / Path Competition Degree. The resulting dependency path weight from device data acquisition to fault diagnosis is 0.26, and the dependency path weight from historical data analysis to fault diagnosis is 0.30. The collaborative scheduler performs a depth-first traversal starting from the root node of the task dependency tree, in the following order: Task Coordination Management Node (Level 0) → Device Data Acquisition Node (Level 1) → Historical Data Analysis Node (Level 1) → Fault Diagnosis Node (Level 2) → Fault Processing Node (Level 3). The device data acquisition node is broken down into a data acquisition subtask and a data preprocessing subtask, with the subtask level position recorded as 1.

[0142] For the data preprocessing subtask, its inbound dependency path is identified as task coordination and management to device data acquisition, with a path weight of 0.35; the outbound dependency path is device data acquisition to fault diagnosis, with a path weight of 0.26. Using the subtask path inheritance degree calculation formula: Inheritance degree = Inbound path weight × 0.4 + Outbound path weight × 0.6, the path inheritance degree of the data preprocessing subtask is obtained as 0.296. The subtask identifier "DATA_PREPROC_001" is bound to the inheritance degree of 0.296, establishing the association between the subtask and its dependency path, and stored in the collaborative scheduling table: {Task ID: "DATA_PREPROC_001", Inheritance degree: 0.296, Inbound path: "COORD_TO_DATA", Outbound path: "DATA_TO_DIAG"}.

[0143] When multiple agents collaborate to handle industrial equipment faults, the coordination center detects resource conflicts. The historical data analysis agent and the fault diagnosis agent simultaneously request access to the equipment's historical operation database. Based on a sub-task path inheritance priority scheduling strategy, the fault diagnosis sub-task has an inheritance degree of 0.296, while the historical analysis sub-task has an inheritance degree of 0.256. The scheduler prioritizes allocating resources to the fault diagnosis agent. The coordination center also automatically adjusts data transmission batches based on dependency path weights. The equipment data acquisition agent transmits 58MB of data to the fault diagnosis agent each time, with a batch interval of 30 minutes, ensuring smooth data transmission without causing processing congestion.

[0144] During collaborative execution, if the output data volume of the device data acquisition agent drops to 60MB / hour due to network jitter, the coordination center recalculates the path matching degree to 0.27 and the path weight to 0.13. Based on this change, the scheduler dynamically adjusts the resource allocation of the fault diagnosis agent, reducing its processing priority, and notifies the historical data analysis agent to increase the data replenishment frequency to ensure the smooth execution of the overall task. After the task is completed, the coordination center collects the actual execution status of each dependent path and records the deviation rate between the actual data traffic and the expected traffic as 8.3%, which serves as the basis for optimization in the dependency analysis of similar tasks in the future.

[0145] In this embodiment, by quantitatively calculating path matching degree and competition degree, reasonable weights are assigned to different collaborative paths, effectively solving the resource contention and scheduling conflict problems in multi-vendor intelligent agent collaboration. The sub-task association mechanism based on inheritance degree enhances the stability and adaptability of task execution, enabling the system to cope with changes in data flow and network fluctuations. In addition, by dynamically monitoring and adjusting dependent paths, the risk of blocking during collaboration is reduced, and the collaborative efficiency and fault recovery capability of cross-vendor intelligent agents are improved.

[0146] In one optional implementation, during the execution period, a subtask execution instruction is sent; the actual resource consumption is extracted based on the subtask execution result; the resource release time is corrected based on the deviation between the actual resource consumption and the average occupied time; the time reservation binding is updated based on the corrected resource release time; and subsequent subtask execution periods are reallocated, including:

[0147] Send subtask execution instructions during the execution period and monitor the subtask execution process;

[0148] Collect the start and end times of subtask execution to calculate the actual execution time, extract the resource instance identifiers used during the execution of the subtask, and calculate the actual resource consumption based on the resource instance identifiers and the actual execution time;

[0149] Extract historical resource consumption data of the same resource type from historical execution records to calculate the average usage time, calculate the consumption deviation between the actual resource consumption and the average usage time, extract the load fluctuation coefficient of the resource instance identifier, and calculate the deviation correction amount based on the consumption deviation and the load fluctuation coefficient.

[0150] Identify the path inheritance degree of the dependent paths corresponding to subtasks, determine the propagation range of the deviation correction amount based on the path inheritance degree, extract the resource instance identifiers associated with subsequent subtasks within the propagation range, and correct the resource release time corresponding to the resource instance identifiers within the propagation range based on the deviation correction amount.

[0151] Extract the time offset between the corrected resource release time and the original resource release time, and identify subsequent reserved records in the time reservation binding where the resource release time is later than the corrected resource release time;

[0152] Adjust the resource release time in the subsequent reserved records according to the time offset, update the time reservation binding according to the corrected resource release time, and reallocate the execution time of subsequent subtasks according to the allocation priority.

[0153] The collaboration and coordination center sends subtask execution instructions to relevant agents according to pre-defined execution time periods. Taking a cross-vendor device data analysis scenario as an example, the coordination center sends a data preprocessing subtask execution instruction to the data acquisition agent at 09:30:00. This instruction is sent through the A2A protocol instruction transmission channel and includes the task identifier "TASK_PREPROC_002", resource allocation information, and expected completion time. After the execution instruction is issued, the coordination center activates the task monitoring module, which collects the subtask execution status in real time through the status synchronization field of the MCP protocol, including indicators such as the amount of data processed, memory usage, and computing resource load. The sampling frequency is once every 5 seconds, forming an execution process monitoring data stream.

[0154] After the subtask was completed, the coordination center recorded the actual start time of the data preprocessing subtask as 09:30:05 and the end time as 09:45:32, calculating the actual execution time to be 15 minutes and 27 seconds. The resource instance identifiers used by this subtask were extracted from the task resource mapping table, including "RES_CPU_001" and "RES_MEM_003", corresponding to computing resources and memory resources respectively. According to resource monitoring data, the actual consumption of computing resource "RES_CPU_001" was 18 minutes of core time, and the actual consumption of memory resource "RES_MEM_003" was 1.2GB × 15.45 minutes. The coordination center retrieved historical resource consumption data for similar data preprocessing tasks from the historical execution record database, calculating the average usage time of computing resources to be 12 minutes and the average usage time of memory resources to be 14 minutes. The consumption deviation was calculated using the formula: Consumption Deviation = (Actual Consumption - Average Consumption) / Average Consumption, resulting in a computing resource consumption deviation of 0.5 and a memory resource consumption deviation of 0.1.

[0155] The load fluctuation coefficient of "RES_CPU_001" is extracted from the resource configuration library as 0.3, and the load fluctuation coefficient of "RES_MEM_003" is 0.15. Based on these parameters, the deviation correction amount is calculated using the formula: Deviation Correction Amount = Consumption Deviation × (1 + Load Fluctuation Coefficient). The calculated deviation correction amount for computing resources is 0.65, and the deviation correction amount for memory resources is 0.115. The propagation range of deviation correction is determined according to the dependency path inheritance degree associated with the subtasks. The path inheritance degree of the data preprocessing subtask is 0.75. According to the propagation rule: Propagation Range = Number of Downward Dependency Levels × Path Inheritance Degree, the propagation range is calculated to be 3 levels. The coordination center identifies subsequent subtasks within the propagation range from the task dependency graph, including three subtasks: feature extraction, model inference, and result aggregation. The resource instance identifiers "RES_CPU_002", "RES_GPU_001", and "RES_MEM_004" associated with these subtasks are extracted.

[0156] Based on the aforementioned deviation correction, the release time of resources within the propagation range is adjusted. The original planned resource release time for the feature extraction subtask was 10:15:00. Considering the deviation correction of 0.65 for the computational resource consumption of the preceding task, the correction formula is applied: Corrected release time = Original release time + Original planned duration × Deviation correction × Attenuation coefficient. The attenuation coefficient decreases with increasing level: 1.0 for the first level, 0.7 for the second level, and 0.4 for the third level. The corrected resource release time for the feature extraction subtask is calculated to be 10:24:45. Similarly, the corrected resource release times for the model inference and result aggregation subtasks are calculated to be 10:52:18 and 11:09:06, respectively.

[0157] The offsets of resource release times before and after the correction for each subtask were extracted. The offset for the feature extraction subtask was 9 minutes and 45 seconds, the offset for the model inference subtask was 7 minutes and 18 seconds, and the offset for the aggregated subtasks was 3 minutes and 6 seconds. The coordination center retrieved the time reservation binding table and identified subsequent reservation records where the resource release time was later than the corrected release time. It was found that the data visualization subtask was originally scheduled to start at 11:15:00, using the "RES_CPU_002" resource. Based on the previously calculated time offsets, the start time of the data visualization subtask was adjusted to 11:24:45. The coordination center updated the relevant records in the time reservation binding table and adjusted the execution time slots of all subsequent subtasks. After the update, the execution time slots were redistributed according to the allocation priority of the subtasks from high to low. The priority calculation formula is: Allocation Priority = Path Inheritance × 0.6 + Task Urgency × 0.4. The resulting aggregated subtask priority was 0.82, and the data visualization subtask priority was 0.64. The redistribution was completed in this order.

[0158] After the correction is completed, the coordination center sends the updated execution plan to each agent via the A2A protocol, including the adjusted time window and resource allocation information. Upon confirmation of receipt, each agent updates its local task queue and executes subsequent subtasks according to the new plan. Simultaneously, the coordination center records the resource consumption deviation data in the historical database for optimizing resource allocation predictions for future tasks. When the feature extraction subtask is executed, the agent reports the task execution status via the MCP protocol. The coordination center monitors the actual execution status and its conformity to the corrected expectations; if the deviation exceeds a threshold, a further correction is triggered. Throughout the process, agents exchange data through a secure communication tunnel to ensure the confidentiality and integrity of data transmission.

[0159] In this embodiment, by accurately monitoring the execution process of subtasks, calculating resource consumption deviations in real time, and performing reasonable propagation based on dependency path inheritance, intelligent correction of resource release timing is achieved. The introduction of a load fluctuation coefficient and a hierarchical decay mechanism improves correction accuracy and stability. A dynamically updated time reservation binding mechanism ensures that subsequent tasks can be flexibly adjusted according to actual conditions, avoiding resource conflicts and execution blockages. This improves resource utilization and task completion timeliness in cross-vendor agent collaboration, reduces the risk of collaboration interruptions due to inaccurate resource estimation, enhances the robustness and adaptability of the entire collaboration system, and provides reliable resource scheduling guarantees for agent collaboration in complex scenarios.

[0160] A second aspect of this invention provides a cross-vendor intelligent agent secure collaboration system based on a standardized protocol, the system comprising:

[0161] The protocol adaptation module is used to receive raw protocol data, extract the relationship between data fields to construct a dependency graph, determine the semantic level based on the in-degree and out-degree of the nodes in the dependency graph, and convert it into standard fields according to the semantic level to obtain adaptation data.

[0162] The permission coordination module is used to extract operation features from the adaptation data and encode them into permission vectors. It calculates the Euclidean distance between permission vectors as the conflict degree. When the conflict degree exceeds the preset conflict threshold, the conflict dimension is reduced in weight to obtain the coordinated permission vector.

[0163] The resource reservation module is used to send resource access authorization to the agent based on the coordination permission vector, calculate the average resource occupancy time based on the resource access record, predict the resource release time based on the average occupancy time, and establish time reservation binding when the resource release time is earlier than the demand time.

[0164] The task decomposition module is used to receive task requests, build a task dependency tree based on the data flow between operations in the task request, traverse the task dependency tree to decompose it into subtasks, and allocate execution time slots to subtasks based on time reservations.

[0165] The dynamic scheduling module is used to send subtask execution instructions within the execution period, extract the actual resource consumption based on the subtask execution results, correct the resource release time based on the deviation between the actual resource consumption and the average occupied time, update the time reservation binding based on the corrected resource release time, and reallocate the execution period of subsequent subtasks.

[0166] A third aspect of the present invention provides an electronic device, comprising:

[0167] processor;

[0168] Memory used to store processor-executable instructions;

[0169] The processor is configured to invoke instructions stored in the memory to execute the aforementioned method.

[0170] A fourth aspect of the present invention provides a computer-readable storage medium having stored thereon computer program instructions that, when executed by a processor, implement the aforementioned method.

[0171] This invention can be a method, apparatus, system, and / or computer program product. The computer program product may include a computer-readable storage medium having computer-readable program instructions loaded thereon for performing various aspects of the invention.

[0172] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, and not to limit them; although the present invention 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 or all of the technical features; and these modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the scope of the technical solutions of the embodiments of the present invention.

Claims

1. A cross-vendor intelligent agent secure cooperation method based on standardized protocols, characterized in that, include: Receive raw protocol data, extract the relationships between data fields to construct a dependency graph, determine the semantic level based on the in-degree and out-degree of nodes in the dependency graph, and convert it into standard fields according to the semantic level to obtain adapted data; Operational features are extracted from the adaptation data and encoded into permission vectors. The Euclidean distance between permission vectors is calculated as the conflict degree. When the conflict degree exceeds a preset conflict threshold, the conflict dimension is weighted down to obtain a coordinated permission vector. Resource access authorization is sent to the agent based on the coordination permission vector. The average resource occupancy time is calculated based on the resource access record. The resource release time is predicted based on the average occupancy time. When the resource release time is earlier than the demand time, a time reservation binding is established. Receive task requests, construct a task dependency tree based on the data flow between operations in the task request, traverse the task dependency tree to decompose it into subtasks, and allocate execution time slots to subtasks based on time reservations; During the execution period, send subtask execution instructions, extract the actual resource consumption based on the subtask execution results, correct the resource release time based on the deviation between the actual resource consumption and the average occupied time, update the time reservation binding based on the corrected resource release time, and reallocate the subsequent subtask execution period. The process involves receiving raw protocol data, extracting relationships between data fields to construct a dependency graph, determining the semantic level based on the in-degree and out-degree of nodes in the dependency graph, and converting the data into standard fields according to the semantic level to obtain adapted data, including: Receive raw protocol data, parse it to obtain a set of data fields, and generate a field mapping table containing data field identifier codes; Construct all data fields in the field mapping table into initial directed graph nodes, and record the field identifier code corresponding to each node; The temporal overlap between fields is calculated based on the state transition sequence of data fields. The temporal correlation strength between fields is obtained by calculating the temporal overlap and the state transition frequency, forming a temporal correlation strength matrix. Based on the temporal correlation strength matrix, directed edges are established between corresponding nodes, and the in-degree and out-degree values ​​of all nodes are counted to generate a node metric matrix. The in-degree and out-degree values ​​in the node metric matrix are weighted and fused, and a node comprehensive score matrix is ​​obtained through multi-level combination calculation. Based on the node comprehensive score matrix, semantic levels are divided and a hierarchical mapping table is generated. The hierarchical mapping table is used to traverse from the highest semantic level node to obtain the set of transmission paths. The path score value is calculated based on the number of transmission steps between nodes and the node comprehensive score matrix. The transmission path with the highest score value is taken as the main transmission path, and a path connection table is generated. Reconstruct the dependency graph based on the path connection table, and convert the data fields into standard fields according to the semantic hierarchy order using the hierarchical mapping table to obtain adapted data.

2. The method according to claim 1, characterized in that, Operational features are extracted from the adaptation data and encoded into permission vectors. The Euclidean distance between permission vectors is calculated as the conflict degree. When the conflict degree exceeds a preset conflict threshold, the conflict dimension is weighted down to obtain a coordinated permission vector, including: Extract resource access operation sequences from the adaptation data, identify operation types and operation timestamps, generate an operation record table and establish an operation type index; Calculate the operation time interval matrix based on the timestamps in the operation record table, construct the time feature matrix by combining the operation type index, and map the operation type to the feature code to generate the operation feature matrix; The temporal feature matrix is ​​normalized to generate a temporal weight matrix. The temporal weight matrix and the operation feature matrix are weighted to obtain a weighted feature matrix. The weighted feature matrix is ​​then converted into a permission vector through feature space mapping. Calculate the Euclidean distance between permission vectors as the conflict degree, extract the dimensions that exceed the preset conflict threshold from the conflict degree, and generate a set of conflict dimensions; Calculate the correlation coefficient matrix between each dimension in the conflict dimension set, group and cluster the conflict dimensions based on the correlation coefficient matrix, allocate the weight reduction ratio according to the number of dimensions in the group, perform differentiated weight reduction on each group dimension until the conflict degree of all dimensions meets the preset conflict threshold constraint, and obtain the coordination permission vector.

3. The method according to claim 1, characterized in that, Resource access authorization is sent to the agent based on the coordinated permission vector. The average resource occupancy time is calculated based on the resource access records. The resource release time is predicted based on the average occupancy time. When the resource release time is earlier than the demand time, a time reservation binding is established, including: Based on the coordinated permission vector, the agent identifier and permission dimension are extracted, the permission dimension is mapped to the accessible resource type, and a resource access authorization containing the resource type and access time limit is sent to the agent. Receive resource access records generated by intelligent agents under resource access authorization, calculate the time difference between the start time and end time of resource access as the single occupancy duration, and generate an occupancy duration sequence according to resource type; Calculate the time distance between the time corresponding to each single time of occupation in the occupation duration sequence and the current time, calculate the time-series decay weight based on the time distance, and calculate the average resource occupation duration by weighting the occupation duration sequence with the time-series decay weight; Receive a resource request containing the demand time and resource type, obtain the corresponding average resource occupancy time according to the resource type in the resource request, extract the access start time of the currently occupied resource instance, and add the access start time to the average resource occupancy time to obtain the resource release time; Extract task priority from resource requests, calculate the time interval between resource release time and demand time, calculate reservation confidence based on time interval and task priority, bind resource instance identifier to resource request identifier when resource release time is earlier than demand time, and store reservation confidence in the establishment time reservation binding.

4. The method according to claim 1, characterized in that, Upon receiving a task request, a task dependency tree is constructed based on the data flow between operations within the task request. The task dependency tree is traversed to decompose the task into subtasks. Execution time slots are allocated to the subtasks based on time reservations, including: Receive task requests, extract operation sequences from task requests, identify data input ports and data output ports of each operation, determine the data flow between operations based on the connection relationship between data output ports and data input ports, and construct a task dependency tree based on the data flow between operations. Extract the dependency path formed by the parent node and child node from the task dependency tree, calculate the matching degree between the output data of the parent node and the input data of the child node in the dependency path, assign path weight to each dependency path based on the matching degree, traverse the task dependency tree to decompose each node into subtasks, and establish the association between subtasks and dependency paths. Extract the resource release time and reservation confidence from the time reservation binding, obtain the path weight of the subtask's associated dependency path, combine the path weight and reservation confidence to calculate the allocation priority, and allocate execution time slots to the subtasks according to the allocation priority order based on the time reservation binding; Monitor the data transmission rate of the path that the subtask depends on during execution. When the data transmission rate deviates from the preset transmission rate by more than the preset rate threshold, adjust the path weight according to the rate deviation and recalculate the priority allocation based on the adjusted path weight.

5. The method according to claim 4, characterized in that, Extract dependency paths consisting of parent and child nodes from the task dependency tree, calculate the matching degree between the output data volume of the parent node and the input data volume of the child node in the dependency path, assign path weights to each dependency path based on the matching degree, traverse the task dependency tree to decompose each node into subtasks, and establish the association between subtasks and dependency paths, including: Extract all directed connections between parent and child nodes from the task dependency tree to form a dependency path. Extract the output data volume of the operation corresponding to the parent node and the input data volume of the operation corresponding to the child node in the dependency path. Calculate the data flow saturation based on the output data volume and the input data volume. Calculate the matching degree based on the data flow saturation and the number of levels crossed between nodes in the dependency path. Identify the convergence node where multiple dependency paths converge in the task dependency tree, count the number of incoming dependency paths in the convergence node, and extract the matching degree of each incoming dependency path to calculate the distribution dispersion. The path competitiveness is calculated based on the number and distribution dispersion of the dependent paths, and the path weight is calculated based on the matching degree of the dependent paths and the path competitiveness. Starting from the root node of the task dependency tree, traverse each node in terms of level depth, break down the operation corresponding to the traversed node into subtasks and record the level position of the subtasks. Identify the incoming edge dependency path of the corresponding node of the subtask as the child node and the outgoing edge dependency path as the parent node, extract the path weight of the incoming edge dependency path and the path weight of the outgoing edge dependency path, calculate the path inheritance degree of the subtask, and bind the subtask identifier with the path inheritance degree to establish the association relationship between the subtask and the dependency path.

6. The method according to claim 1, characterized in that, During the execution period, subtask execution instructions are sent. Based on the subtask execution results, the actual resource consumption is extracted. The resource release time is adjusted based on the deviation between the actual resource consumption and the average usage time. The time reservation binding is updated based on the adjusted resource release time, and subsequent subtask execution periods are reallocated, including: Send subtask execution instructions during the execution period and monitor the subtask execution process; Collect the start and end times of subtask execution to calculate the actual execution time, extract the resource instance identifiers used during the execution of the subtask, and calculate the actual resource consumption based on the resource instance identifiers and the actual execution time; Extract historical resource consumption data of the same resource type from historical execution records to calculate the average usage time, calculate the consumption deviation between the actual resource consumption and the average usage time, extract the load fluctuation coefficient of the resource instance identifier, and calculate the deviation correction amount based on the consumption deviation and the load fluctuation coefficient. Identify the path inheritance degree of the dependent paths corresponding to subtasks, determine the propagation range of the deviation correction amount based on the path inheritance degree, extract the resource instance identifiers associated with subsequent subtasks within the propagation range, and correct the resource release time corresponding to the resource instance identifiers within the propagation range based on the deviation correction amount. Extract the time offset between the corrected resource release time and the original resource release time, and identify subsequent reserved records in the time reservation binding where the resource release time is later than the corrected resource release time; Adjust the resource release time in the subsequent reserved records according to the time offset, update the time reservation binding according to the corrected resource release time, and reallocate the execution time of subsequent subtasks according to the allocation priority.

7. A cross-vendor intelligent agent secure collaboration system based on standardized protocols, used to implement the method of any one of claims 1-6, characterized in that, include: The protocol adaptation module is used to receive raw protocol data, extract the relationship between data fields to construct a dependency graph, determine the semantic level based on the in-degree and out-degree of the nodes in the dependency graph, and convert it into standard fields according to the semantic level to obtain adaptation data. The permission coordination module is used to extract operation features from the adaptation data and encode them into permission vectors. It calculates the Euclidean distance between permission vectors as the conflict degree. When the conflict degree exceeds the preset conflict threshold, the conflict dimension is reduced in weight to obtain the coordinated permission vector. The resource reservation module is used to send resource access authorization to the agent based on the coordination permission vector, calculate the average resource occupancy time based on the resource access record, predict the resource release time based on the average occupancy time, and establish time reservation binding when the resource release time is earlier than the demand time. The task decomposition module is used to receive task requests, build a task dependency tree based on the data flow between operations in the task request, traverse the task dependency tree to decompose it into subtasks, and allocate execution time slots to subtasks based on time reservations. The dynamic scheduling module is used to send subtask execution instructions within the execution period, extract the actual resource consumption based on the subtask execution results, correct the resource release time based on the deviation between the actual resource consumption and the average occupied time, update the time reservation binding based on the corrected resource release time, and reallocate the execution period of subsequent subtasks.

8. An electronic device, characterized in that, include: processor; Memory used to store processor-executable instructions; The processor is configured to invoke instructions stored in the memory to execute the method according to any one of claims 1 to 6.

9. A computer-readable storage medium having computer program instructions stored thereon, characterized in that, When the computer program instructions are executed by the processor, they implement the method described in any one of claims 1 to 6.

Images