Parallel intelligent agent multi-task resource allocation conflict resolution method

Abstract

The application discloses a parallel intelligent agent multi-task resource allocation conflict resolution method, and particularly relates to the technical field of computers, and comprises resource semantic analysis and dependency graph construction: a plurality of parallel digital intelligent agents are acquired, each of which has a task set to be executed, at least one resource access descriptor contained in each task is analyzed, and the resource access descriptor at least comprises a target shared application resource identifier, an access mode and a predicted occupation time window. The application embeds RPA workflow data stream semantics into a resource conflict resolution strategy, constructs a data stream dependency graph to quantize cascading influence, realizes workflow instance splitting and isolation, adopts a three-layer adaptive index dynamic switching and visual state anchoring mechanism to balance conflict detection efficiency and UI operation reversibility, manages token life cycle in a global lease epoch, guarantees resource allocation state self-consistency in an engine failure scenario, and improves the throughput resilience and execution reliability of an RPA process in a high concurrency scenario.

Description

Technical Field

[0001] This invention relates to the field of computer technology, and more specifically, to a method for resolving conflicts in the allocation of multi-task resources in parallel intelligent agents. Background Technology

[0002] With the large-scale deployment of Robotic Process Automation (RPA) technology in finance, manufacturing, government, and other fields, a single RPA robot can no longer meet the needs of high-throughput business, and the collaborative execution of parallel digital intelligent agents has become an inevitable trend. However, the concurrent access of multiple digital intelligent agents to shared application resources such as enterprise resource planning system interfaces, database clients, and office suites inevitably leads to resource allocation conflicts, becoming a key bottleneck restricting the overall efficiency of RPA engines.

[0003] Existing resource conflict resolution schemes for parallel digital agents in RPA scenarios lack data flow semantic awareness in conflict resolution decisions. Existing schemes treat resource conflicts as simple time window overlaps and arbitrate through first-come-first-served or fixed-priority methods, without considering the variable input-output dependencies between tasks in the RPA workflow. This may lead to a chain of blockages in downstream links caused by the yield decision. Lacking a reversible recovery mechanism for UI-oriented operations, the actual operations performed by RPA agents on external applications through the user interface cannot be recovered through traditional database transaction rollback. After a conflict is resolved, the already executed operations can usually only be discarded and the process completely retried, resulting in wasted resources and execution uncertainty. When switching over an engine failure, it is difficult to guarantee the consistency of the token state. During the primary / standby switch or execution context reconstruction, the state synchronization of the pre-occupied token and the effective token is delayed, which can easily lead to ghost occupation or duplicate allocation, resulting in misjudgment of the conflict resolution strategy in the new era. Summary of the Invention

[0004] To overcome the aforementioned deficiencies of the prior art, this invention provides a method for resolving conflicts in the allocation of multi-task resources by parallel intelligent agents, thereby addressing the problems mentioned in the background art.

[0005] To achieve the above objectives, the present invention provides the following technical solution: a method for resolving conflicts in the allocation of multi-task resources for parallel intelligent agents, applied to an RPA process automation engine based on directed acyclic graph orchestration, wherein the engine maintains an execution context for each running parallel digital intelligent agent, and all accesses to shared application resources are arbitrated through a resource access mediation layer, the method comprising the following steps: S1. Resource Semantic Parsing and Dependency Graph Construction: Obtain the task sets to be executed by multiple parallel digital agents, parse at least one resource access descriptor contained in each task, the resource access descriptor includes at least: target shared application resource identifier, access mode, expected time window, and downstream data consumption node identifier of the task in its RPA workflow orchestration link; based on the downstream data consumption node identifier, construct a cross-agent data flow dependency graph, the data flow dependency graph is with each agent as a node, and the data flow transmission relationship represented by the downstream data consumption node identifier is a directed edge, the weight of the directed edge is jointly determined by the data field sensitivity and transmission frequency in the data flow transmission relationship; S2. Three-layer adaptive index structure deployment: Deploy a resource occupancy status tracking layer. The tracking layer maintains a Bloom filter layer, a skip table layer, and a segment tree layer. The Bloom filter layer performs coarse-grained conflict pre-detection using resource identifiers as keys. The skip table layer stores medium-grained occupancy records using <resource identifier, time slice interval> as ordered keys. The segment tree layer organizes the Boolean aggregation of occupancy status using the resource time axis as the interval field. When the number of conflict detections corresponding to a certain resource identifier in the skip table layer exceeds a preset threshold within the sliding window and the proportion of external irreversible calls to that resource exceeds a preset ratio, the index of that resource identifier is automatically migrated to the segment tree layer. S3. Semantic Aware Pre-declaration and Token Issuance: For each resource request, a pre-declaration phase is performed: the target shared application resource identifier corresponding to the resource request is inserted into the Bloom filter layer, a candidate occupancy record is inserted into the skip list layer with the expected occupancy time window of the resource request as the interval, and the data flow propagation influence factor of the agent is calculated based on the data flow dependency graph. A semantically weighted temporary pre-occupancy token carrying the data flow propagation influence factor, the current global lease epoch identifier, and the local logical timestamp is issued to the agent. S4. Dual Conflict Detection and Concession Sequence Determination: Based on the skip surface layer or segment tree layer, time window overlap conflict detection is performed. When time window overlap is detected, the target shared application resources and competing agent sets involved in the conflict are extracted. Based on the data flow dependency graph, a semantic causal dependency graph increment is constructed. Topological sorting is performed on the semantic causal dependency graph increment to determine the concession sequence. The priority rule of the topological sorting is: the larger the data flow propagation influence factor, the higher the priority. S5. Cascade Impact Assessment and Reversible Execution Frame Anchoring: After the concession sequence is determined, the following actions are performed on the agent determined to be the conceding party: (a) Monitor the data flow propagation impact factor of the agent determined to be the conceding party to assess the cascade impact range; (b) When the data flow propagation impact factor exceeds a preset cascade threshold, trigger workflow instance splitting: In the workflow orchestrator of the RPA process automation engine, identify the downstream task subgraph affected by the conceding party based on the task dependency matrix, clone the downstream task subgraph into a new workflow instance and allocate it to a spare. The digital intelligent agent executes, and the original workflow instance continues to execute the upstream tasks without being affected; when both the original workflow instance and the new workflow instance execute to the termination node, the output variables are reconciled according to the distributed transaction identifier to maintain eventual consistency; (c) for the conceding party that has not triggered a split, its semantically weighted temporary pre-occupancy token is downgraded, the expected time window is compressed into a micro-slice-level reversible execution frame, and before the reversible execution frame is executed, the interface state of the target shared application resources is snapshotted by the visual capture driver in the sandbox to generate visual state anchor points; S6. Formal Commit and Smart Reclamation: For semantically weighted temporary pre-occupied tokens that pass conflict detection and are not downgraded to the conceding party, a formal commit is performed, converting them into effective occupied tokens and writing them into the occupied record of the jump table layer or segment tree layer, and registering the unlocking callback of the corresponding target shared application resource to the execution context destruction hook of the agent.

[0006] Preferably, the construction of the data flow dependency graph in step S1 specifically includes: Iterate through the task sets of each agent and extract the input variable set and output variable set for each task; When the set of output variables of the first agent intersects with the set of input variables of the second agent, a directed edge from the first agent to the second agent is established in the data flow dependency graph; Calculate the weight of the directed edge: ,in The sensitivity level of the data fields in the intersection. The frequency of cross-agent transmission of the data field within a preset historical period. The length in bytes of the data field.

[0007] Preferably, the calculation of the data stream propagation impact factor in step S3 includes: Based on the data flow dependency graph, a breadth-first traversal is performed with the current agent as the root node to calculate the set of downstream reachable agents of the agent. The data stream propagation influencing factors ,in For the current intelligent agent up to the first The shortest path length that can be reached by a downstream agent. It is the product of the weights of all directed edges on the corresponding path; when When the preset impact threshold is exceeded, the agent is marked as a key propagation node in the semantically weighted temporary pre-occupied token, so that it can obtain an additional priority bonus in the topology sorting.

[0008] Preferably, the construction and topological sorting of the semantic causal dependency graph increment in step S4 specifically includes: Using each competing agent as a node, query the process instance traceability information associated with each resource access descriptor in the agent's task set, and extract the upstream dependency identifier of each task in its respective RPA workflow orchestration link. If the upstream dependency identifier of the first agent appears in the executed trajectory of the second agent, then a reverse dependency edge is drawn from the first agent to the second agent in the semantic causal dependency graph, and the edge weight is assigned as the inverse of the length of the dependency chain multiplied by the data flow propagation influence factor of the second agent. The semantic causal dependency graph is incrementally traversed using a depth-first search to detect the existence of a cycle structure. If a cycle exists, it indicates that a cross-waiting deadlock precursor has occurred. At this time, a random offset based on the variance of the data flow propagation influence factor is introduced to break the symmetry, and the agent corresponding to the node with the smallest variance of the data flow propagation influence factor in the cycle is forcibly marked as the conceding party.

[0009] Preferably, the generation and consistency verification of visual state anchor points in step S5 specifically includes: Intercept interface operation calls to the target shared application resources within the sandbox, capture a snapshot of the target window's interface state before the operation is executed, and extract the control hierarchy tree fingerprint or set of automation identifiers of the window as an interface feature vector, which is then stored in the visual state anchor point. Before re-execution after triggering a rollback to the handover point, the interface feature vector of the current window is recaptured and compared with the visual state anchor point. If the similarity is lower than a preset threshold, an abnormal alarm is triggered and the agent is paused. The orchestrator decides whether to roll back to the nearest checkpoint for re-running or to allow manual intervention.

[0010] Preferably, the workflow instance splitting in step S5 further includes: A synchronization barrier is set at the split point of the original workflow instance, and the new workflow instance starts execution on the standby agent from the entry task of the downstream task subgraph. The output variables of the new workflow instance carry the distributed transaction identifier when written to the shared variable pool at the termination node. The original workflow instance performs overwriting and aggregation of the corresponding keys in the shared variable pool based on the distributed transaction identifier at the termination node to ensure eventual consistency.

[0011] Preferably, it also includes steps for adaptive backoff of conflict hot zones and dynamic index tuning: Maintain a conflict frequency counter with resource identifier as the key. When the number of conflict detections triggered by a target shared application resource within the sliding window exceeds a preset threshold, mark the resource as a conflict hotspot. For new resource requests subsequently arriving in the conflict hotspot, an exponential backoff delay is enforced, wherein the delay base is inversely proportional to the data stream propagation impact factor. Meanwhile, the index structure of the conflict hot zone is dynamically optimized: the time micro-slice granularity of the segment tree layer is increased to reduce space overhead, or parallel segment trees are enabled to support multi-way interval queries.

[0012] Preferably, the priority rule for topological sorting in step S4 further includes a dynamic priority decay mechanism: In the topological sorting process of the semantic causal dependency graph increment, a dynamic priority value is maintained for each competing agent, with the initial value being the data flow propagation influence factor of that agent; After each preset sorting round, the priority of agents that have not received resource allocation is reduced: , It is positively correlated with the resource waiting time of the agent in the previous round; When the dynamic priority value decays to below the preset lower threshold, the agent is included in the concession sequence, and its downstream task subgraph is triggered to split the workflow instance according to step S5 to avoid the overall RPA process timeout.

[0013] Preferably, the collaborative query mechanism between the jump table layer and the segment tree layer includes: When a resource conflict query request is received, the Bloom filter layer is first queried for coarse-grained pre-determination. If a conflict is suspected, the query path is selected based on the current index level of the resource identifier: If the resource identifier is in the skip list level, then perform a skip list range query; If the resource identifier is in the segment tree layer, the Boolean aggregation value maintained by the internal nodes of the segment tree is queried to determine the interval coverage conflict. The internal nodes of the segment tree store the occupancy status of each time microslice in their subtree interval in a bitmap compression manner. The query results return a Boolean value indicating the conflict status and a list of identifiers of competing intelligent agents involved in the conflict.

[0014] Preferably, the validity period of the semantically weighted temporary pre-hold token is bound to the global lease epoch of the RPA workflow; When the execution engine undergoes a primary / backup switch or execution context reconstruction, all semantically weighted temporary pre-occupancy tokens and effective occupancy tokens issued under the old epoch automatically become invalid. In response to the epoch change event, the resource occupancy status tracking layer clears the occupancy record of the corresponding epoch and forces all affected agents to re-initiate the pre-declaration phase based on the current global lease epoch. When the pre-declaration phase is restarted, the data flow propagation influence factor of each agent in the set of competing agents is recalculated based on the current data flow dependency graph, and the reconstruction of the semantic causal dependency graph increment is triggered to avoid misjudgment of resource allocation conflict caused by token expiration.

[0015] The technical effects and advantages of this invention are as follows: By constructing a cross-agent data flow dependency graph, the variable input-output relationship between tasks is explicitly represented as a graph structure, and the data flow propagation impact factor is calculated accordingly. This allows conflict resolution decisions to no longer consider a single resource request in isolation, but to comprehensively assess the cascading impact of the request in the entire workflow chain. When the data flow propagation impact factor of the concessionary party exceeds the cascading threshold, the workflow instance is automatically split, and the downstream task subgraph is migrated to the backup agent for execution. This reduces the negative impact of resource conflicts from global blocking to local isolation, significantly improving the throughput resilience of the RPA process in high-concurrency scenarios. Through a three-layer adaptive index structure, the skip list and segment tree index levels are dynamically switched based on the frequency of resource conflicts and the proportion of irreversible calls. When conflicts are sparse, the efficient range query capability of the skip list is maintained, and when conflicts are dense, the bitmap compression of the segment tree is used to achieve fast coverage determination. At the same time, in response to the problem that the RPA robot's operation of the external application UI cannot be recovered through traditional database transaction rollback, a visual state anchoring mechanism is introduced. Before the execution of the reversible execution frame, a snapshot of the interface state is captured and the control hierarchy tree fingerprint is extracted. During rollback, the consistency is verified by comparing the interface feature vectors. This fills the technical gap in the RPA field of lacking UI-level rollback methods, and makes the recovery operation after resource conflict concessions have verifiable and compensable deterministic guarantees. By binding the validity period of semantically weighted temporary pre-occupied tokens to the global lease epoch of the RPA workflow, all tokens under the old epoch automatically expire when the engine recovers from a failure. The resource occupancy state tracking layer responds to the epoch change event by clearing the historical records and forcing all affected agents to re-initiate the pre-declaration phase based on the current epoch. This fundamentally cuts off the possibility of cross-contamination of states before and after a failure, ensuring the eventual consistency of resource allocation in abnormal scenarios. It provides reliable support at the underlying resource arbitration level for the high availability deployment of the RPA process automation engine. Attached Figure Description

[0016] Figure 1 This is a schematic diagram of the method flow structure of the present invention. Detailed Implementation

[0017] The technical solutions of the present invention will be clearly and completely described below with reference to the embodiments of the present invention. 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 of ordinary skill in the art without creative effort are within the scope of protection of the present invention.

[0018] As attached Figure 1 The method for resolving resource allocation conflicts in parallel intelligent agents is applied to an RPA process automation engine based on directed acyclic graph orchestration. The engine maintains an execution context for each running parallel digital agent, and all access to shared application resources is arbitrated through a resource access mediation layer. In one embodiment, this method can be deployed in a distributed computing environment, with the RPA process automation engine running on server nodes, the resource access mediation layer deployed on near-end agent nodes, and multiple digital agents running in a sandbox environment on edge execution units, achieving state synchronization through a deterministic network. The method includes the following steps: S1. Resource Semantic Parsing and Dependency Graph Construction: Obtain the task sets to be executed by multiple parallel digital agents, and parse at least one resource access descriptor contained in each task. The resource access descriptor includes at least: the target shared application resource identifier, access mode, expected time window, and the downstream data consumption node identifier in the RPA workflow orchestration link of the task. Based on the downstream data consumption node identifier, construct a cross-agent data flow dependency graph. The data flow dependency graph uses each agent as a node, and the data flow transmission relationship represented by the downstream data consumption node identifier is the directed edge. The weight of the directed edge is jointly determined by the data field sensitivity and transmission frequency in the data flow transmission relationship. Among them, the data field sensitivity can be preset to an integer level from 1 to 5, corresponding to five levels: public, internal, restricted, confidential, and top secret.

[0019] S2. Three-layer adaptive index structure deployment: Deploy a resource occupancy status tracking layer. The tracking layer maintains a Bloom filter layer, a skip list layer, and a segment tree layer. The Bloom filter layer uses resource identifiers as keys for coarse-grained conflict pre-detection. The skip list layer stores medium-granularity occupancy records using <resource identifier, time slice interval> as ordered keys. The segment tree layer organizes Boolean aggregation of occupancy status using the resource time axis as the interval field. When the number of conflict detections corresponding to a resource identifier in the skip list layer exceeds a preset threshold within the sliding window, and the proportion of external irreversible calls to that resource exceeds a preset ratio, the index of that resource identifier is automatically migrated to the segment tree layer. The Bloom filter layer uses three independent hash functions and maintains a bit array of length m in memory, with its false positive probability controlled below 1%. The skip list layer is implemented based on a skip list and supports... Complexity of range query and insertion; leaf nodes of the segment tree layer correspond to micro-time slices of preset granularity, and internal nodes store the occupancy status of each time slice in their subtree interval using bitmap compression.

[0020] S3. Semantic Aware Pre-declaration and Token Issuance: For each resource request, a pre-declaration phase is performed: the target shared application resource identifier corresponding to the resource request is inserted into the Bloom filter layer, a candidate occupancy record is inserted in the skip list layer with the expected occupancy time window of the resource request as the interval, and the data flow propagation impact factor of the agent is calculated based on the data flow dependency graph. A semantically weighted temporary pre-occupancy token carrying the data flow propagation impact factor, the current global lease epoch identifier, and the local logical timestamp is issued to the agent; the local logical timestamp is provided by the agent's local monotonically increasing counter to ensure the partial order relationship of tokens within the same agent.

[0021] S4. Dual Conflict Detection and Concession Sequence Determination: Time window overlap conflict detection is performed based on the skip surface layer or segment tree layer. When time window overlap is detected, the target shared application resources and competing intelligent agents involved in the conflict are extracted. A semantic causal dependency graph increment is constructed based on the data flow dependency graph. Topological sorting is performed on the semantic causal dependency graph increment to determine the concession sequence. The priority rule of topological sorting is: the larger the data flow propagation influence factor, the higher the priority. S5, Cascaded Impact Assessment and Reversible Execution Frame Anchoring: After the concession sequence is determined, execute the following on the agent determined to be the conceding party: Monitor the data flow propagation impact factor of the agent determined to be the conceding party to assess the scope of cascading impact; When the data flow propagation impact factor exceeds a preset cascading threshold, a workflow instance split is triggered: In the workflow orchestrator of the RPA process automation engine, the downstream task subgraph affected by the concession is identified based on the task dependency matrix. The downstream task subgraph is cloned into a new workflow instance and assigned to a standby digital agent for execution. The original workflow instance continues to execute unaffected upstream tasks. When both the original workflow instance and the new workflow instance reach the termination node, the output variables are reconciled based on the distributed transaction identifier to maintain eventual consistency. The task dependency matrix is ​​a Boolean matrix, where rows and columns correspond to task nodes in the workflow. The output is the task. The input is the matrix element. Otherwise, it is 0. The downstream task subgraph is determined by traversing the row and column connectivity of the matrix.

[0022] (c) For the conceding party that has not triggered a split, its semantically weighted temporary pre-occupancy token is downgraded, the expected time window is compressed into a reversible execution frame with a micro-slice granularity, and before the execution of the reversible execution frame, the interface state of the target shared application resources is snapshotted by the visual capture driver in the sandbox to generate visual state anchors. S6. Formal Commit and Smart Reclamation: For semantically weighted temporary pre-occupied tokens that pass conflict detection and are not downgraded to a conceding party, a formal commit is performed, converting them into effective occupied tokens and writing them into the occupied record of the skip table or segment tree layer. The unlock callback of the corresponding target shared application resource is registered to the execution context destruction hook of the agent. The unlock callback is automatically triggered when the agent's execution context is destroyed, the task is completed, or abnormal termination occurs. It is responsible for clearing the corresponding occupied record in the skip table or segment tree layer and resetting the corresponding bit in the Bloom filter.

[0023] The construction of the data flow dependency graph in step S1 specifically includes: Iterate through the task sets of each agent and extract the input variable set and output variable set for each task; When the set of output variables of the first agent intersects with the set of input variables of the second agent, a directed edge from the first agent to the second agent is established in the data flow dependency graph; Calculate the weight of the directed edge: ,in The sensitivity level of the data fields in the intersection. The frequency of data field transmission across agents within a preset historical period. The length of the data field in bytes is specified. The preset historical period can be the statistical data of the most recent 30 minutes to dynamically reflect the characteristics of the current data stream.

[0024] The calculation of the data flow propagation impact factor in step S3 includes: Based on the data flow dependency graph, a breadth-first traversal is performed with the current agent as the root node to calculate the set of downstream reachable agents of the agent. Data flow propagation influencing factors ,in For the current intelligent agent up to the first The shortest path length that can be reached by a downstream agent. It is the product of the weights of all directed edges on the corresponding path; when When the preset impact threshold is exceeded, the agent is marked as a key propagation node in the semantically weighted temporary pre-occupied token, so that it can obtain an additional priority bonus in the topology sorting; the additional priority bonus can be achieved by multiplying its dynamic priority value by a constant greater than 1, such as a constant in the range of 1.2 to 2.0.

[0025] Step S4, specifically the construction and topological sorting of the semantic causal dependency graph increment, includes: Using each competing agent as a node, query the process instance traceability information associated with each resource access descriptor in the agent's task set, and extract the upstream dependency identifier of each task in its respective RPA workflow orchestration link. If the upstream dependency identifier of the first agent appears in the executed trajectory of the second agent, then a reverse dependency edge is drawn from the first agent to the second agent in the semantic causal dependency graph, and the edge weight is assigned as the inverse of the length of the dependency chain multiplied by the data flow propagation influence factor of the second agent. Incrementally perform a depth-first traversal on the semantic causal dependency graph to check for the existence of a cycle structure. If a cycle exists, it indicates that a cross-waiting deadlock precursor has occurred. At this time, a random offset based on the variance of the data flow propagation influence factor is introduced to break the symmetry, and the agent corresponding to the node with the smallest variance of the data flow propagation influence factor in the cycle is forcibly marked as the conceding party.

[0026] Step S5, the generation and consistency verification of visual state anchor points, specifically includes: Intercept UI operation calls to the target shared application resources within the sandbox, capture a snapshot of the target window's interface state before the operation is executed, and extract the control hierarchy tree fingerprint or automation identifier set of the window as an interface feature vector, which is then stored in the visual state anchor point; the control hierarchy tree fingerprint can be obtained by traversing the window handle and its child control's class name, automation ID, and coordinate attributes and calculating a hash.

[0027] Before re-execution after triggering a rollback to the handover point, the interface feature vector of the current window is recaptured and compared with the visual state anchor point. If the similarity is lower than the preset threshold, an anomaly alarm is triggered and the agent is paused. The orchestrator decides whether to roll back to the most recent checkpoint for re-running or to allow manual intervention. The similarity threshold can be adjusted according to the application scenario. For example, it can be set to 0.95 in a high reliability scenario and 0.85 in a general scenario, which means that the current interface state and the interface recorded by the anchor point have a corresponding proportion or more of the same controls and attributes.

[0028] Step S5, workflow instance splitting, also includes: Set a synchronization barrier at the split point of the original workflow instance, and the new workflow instance starts execution on the standby agent from the entry task of the downstream task subgraph; When the output variables of the new workflow instance are written to the shared variable pool at the termination node, they carry a distributed transaction identifier. The original workflow instance overwrites and aggregates the corresponding keys in the shared variable pool at the termination node based on the distributed transaction identifier to ensure eventual consistency. The shared variable pool can be implemented based on Redis or a distributed key-value store to support efficient variable sharing and aggregation across agents.

[0029] It also includes adaptive backoff of conflict hot zones and dynamic index tuning steps: Maintain a conflict frequency counter with resource identifier as the key. When the number of conflict detections triggered by a target shared application resource within the sliding window exceeds a preset threshold, mark the resource as a conflict hotspot. For new resource requests arriving subsequently from conflict hotspots, an exponential backoff delay is enforced, with the delay base inversely proportional to the data stream propagation impact factor. Meanwhile, the index structure of the conflict hot zone is dynamically optimized: the time micro-slice granularity of the segment tree layer is increased to reduce space overhead, or parallel segment trees are enabled to support multi-way interval queries.

[0030] The priority rules for topological sorting in step S4 also include a dynamic priority decay mechanism: In the topological sorting process of the semantic causal dependency graph increment, a dynamic priority value is maintained for each competing agent, with the initial value being the data flow propagation influence factor of that agent; After each preset sorting round, the priority of agents that have not received resource allocation is reduced: , It is positively correlated with the resource waiting time of the agent in the previous round; When the dynamic priority value decays to below the preset lower threshold, the agent is included in the concession sequence, and its downstream task subgraph is triggered to split the workflow instance according to step S5 to avoid the overall RPA process timeout.

[0031] The collaborative query mechanism between the skip table level and the segment tree level includes: When a resource conflict query request is received, the Bloom filter layer is first queried for coarse-grained pre-determination. If a conflict is suspected, the query path is selected based on the current index level of the resource identifier: If the resource identifier is in the skip list level, then perform a skip list range query; If the resource identifier is in the segment tree level, the Boolean aggregation value maintained by the internal nodes of the segment tree is queried to determine the interval coverage conflict. The internal nodes of the segment tree store the occupancy status of each time microslice in their subtree interval in a bitmap compression manner. The query results return a Boolean value indicating the conflict status and a list of identifiers of competing intelligent agents involved in the conflict.

[0032] The validity period of the semantically weighted temporary pre-held token is bound to the global lease epoch of the RPA workflow; When the execution engine undergoes a primary / backup switch or execution context reconstruction, all semantically weighted temporary pre-occupancy tokens and effective occupancy tokens issued under the old epoch automatically become invalid. In response to the epoch change event, the resource occupancy status tracking layer clears the occupancy record of the corresponding epoch and forces all affected agents to re-initiate the pre-declaration phase based on the current global lease epoch. During the re-initiation of the pre-declaration phase, the data flow propagation impact factor of each agent in the competing agent set is recalculated based on the current data flow dependency graph, and the reconstruction of the semantic causal dependency graph is triggered incrementally to avoid misjudgment of resource allocation conflicts caused by token expiration. The global lease epoch is maintained by the engine's main coordinating node, and it monotonically increases each time the master and backup switch occurs. The old epoch identifier is marked as abandoned to ensure that expired tokens are not misused in the new epoch.

[0033] The above steps can be executed by software modules deployed on general-purpose computing devices. These software modules include a resource semantic parser, a three-layer adaptive index manager, a token issuer, a conflict arbitrator, and a visual state capture driver. The modules work together through API interfaces to implement a method for resolving conflicts in the allocation of multi-task resources for parallel intelligent agents.

[0034] In conclusion, the above description is only a preferred embodiment of the present invention and is not intended to limit the present invention. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.

Claims

1. A method for resolving conflicts in resource allocation across multiple tasks using parallel intelligent agents, characterized in that, An RPA process automation engine based on directed acyclic graph orchestration is applied, wherein the engine maintains an execution context for each running parallel digital agent, and all access to shared application resources is arbitrated through a resource access mediation layer. The method includes the following steps: S1. Resource Semantic Parsing and Dependency Graph Construction: Obtain the task sets to be executed by multiple parallel digital agents, parse at least one resource access descriptor contained in each task, the resource access descriptor includes at least: target shared application resource identifier, access mode, expected time window, and downstream data consumption node identifier of the task in its RPA workflow orchestration link; based on the downstream data consumption node identifier, construct a cross-agent data flow dependency graph, the data flow dependency graph is with each agent as a node, and the data flow transmission relationship represented by the downstream data consumption node identifier is a directed edge, the weight of the directed edge is jointly determined by the data field sensitivity and transmission frequency in the data flow transmission relationship; S2. Three-layer adaptive index structure deployment: Deploy a resource occupancy status tracking layer. The tracking layer maintains a Bloom filter layer, a skip table layer, and a segment tree layer. The Bloom filter layer performs coarse-grained conflict pre-detection using resource identifiers as keys. The skip table layer stores medium-grained occupancy records using <resource identifier, time slice interval> as ordered keys. The segment tree layer organizes the Boolean aggregation of occupancy status using the resource time axis as the interval field. When the number of conflict detections corresponding to a certain resource identifier in the skip table layer exceeds a preset threshold within the sliding window and the proportion of external irreversible calls to that resource exceeds a preset ratio, the index of that resource identifier is automatically migrated to the segment tree layer. S3. Semantic Aware Pre-declaration and Token Issuance: For each resource request, a pre-declaration phase is performed: the target shared application resource identifier corresponding to the resource request is inserted into the Bloom filter layer, a candidate occupancy record is inserted into the skip list layer with the expected occupancy time window of the resource request as the interval, and the data flow propagation influence factor of the agent is calculated based on the data flow dependency graph. A semantically weighted temporary pre-occupancy token carrying the data flow propagation influence factor, the current global lease epoch identifier, and the local logical timestamp is issued to the agent. S4. Dual Conflict Detection and Concession Sequence Determination: Based on the skip surface layer or segment tree layer, time window overlap conflict detection is performed. When time window overlap is detected, the target shared application resources and competing agent sets involved in the conflict are extracted. Based on the data flow dependency graph, a semantic causal dependency graph increment is constructed. Topological sorting is performed on the semantic causal dependency graph increment to determine the concession sequence. The priority rule of the topological sorting is: the larger the data flow propagation influence factor, the higher the priority. S5. Cascade Impact Assessment and Reversible Execution Frame Anchoring: After the concession sequence is determined, the following actions are performed on the agent determined to be the conceding party: (a) Monitor the data flow propagation impact factor of the agent determined to be the conceding party to assess the cascade impact range; (b) When the data flow propagation impact factor exceeds a preset cascade threshold, trigger workflow instance splitting: In the workflow orchestrator of the RPA process automation engine, identify the downstream task subgraph affected by the conceding party based on the task dependency matrix, clone the downstream task subgraph into a new workflow instance and allocate it to a spare. The digital intelligent agent executes, and the original workflow instance continues to execute the upstream tasks without being affected; when both the original workflow instance and the new workflow instance execute to the termination node, the output variables are reconciled according to the distributed transaction identifier to maintain eventual consistency; (c) for the conceding party that has not triggered a split, its semantically weighted temporary pre-occupancy token is downgraded, the expected time window is compressed into a micro-slice-level reversible execution frame, and before the reversible execution frame is executed, the interface state of the target shared application resources is snapshotted by the visual capture driver in the sandbox to generate visual state anchor points; S6. Formal Commit and Smart Reclamation: For semantically weighted temporary pre-occupied tokens that pass conflict detection and are not downgraded to the conceding party, a formal commit is performed, converting them into effective occupied tokens and writing them into the occupied record of the jump table layer or segment tree layer, and registering the unlocking callback of the corresponding target shared application resource to the execution context destruction hook of the agent.

2. The method for resolving conflicts in resource allocation for parallel intelligent agents according to claim 1, characterized in that: The construction of the data flow dependency graph in step S1 specifically includes: Iterate through the task sets of each agent and extract the input variable set and output variable set for each task; When the set of output variables of the first agent intersects with the set of input variables of the second agent, a directed edge from the first agent to the second agent is established in the data flow dependency graph; Calculate the weight of the directed edge: ,in The sensitivity level of the data fields in the intersection. The frequency of cross-agent transmission of the data field within a preset historical period. The length in bytes of the data field.

3. The method for resolving conflicts in resource allocation for parallel intelligent agents according to claim 1, characterized in that: The calculation of the data stream propagation impact factor in step S3 includes: Based on the data flow dependency graph, a breadth-first traversal is performed with the current agent as the root node to calculate the set of downstream reachable agents of the agent. The data stream propagation influencing factors ,in For the current intelligent agent up to the first The shortest path length that can be reached by a downstream agent. It is the product of the weights of all directed edges on the corresponding path; when When the preset impact threshold is exceeded, the agent is marked as a key propagation node in the semantically weighted temporary pre-occupied token, so that it can obtain an additional priority bonus in the topology sorting.

4. The method for resolving conflicts in resource allocation for parallel intelligent agents according to claim 1, characterized in that: The construction and topological sorting of the semantic causal dependency graph increment in step S4 specifically includes: Using each competing agent as a node, query the process instance traceability information associated with each resource access descriptor in the agent's task set, and extract the upstream dependency identifier of each task in its respective RPA workflow orchestration link. If the upstream dependency identifier of the first agent appears in the executed trajectory of the second agent, then a reverse dependency edge is drawn from the first agent to the second agent in the semantic causal dependency graph, and the edge weight is assigned as the inverse of the length of the dependency chain multiplied by the data flow propagation influence factor of the second agent. The semantic causal dependency graph is incrementally traversed using a depth-first search to detect the existence of a cycle structure. If a cycle exists, it indicates that a cross-waiting deadlock precursor has occurred. At this time, a random offset based on the variance of the data flow propagation influence factor is introduced to break the symmetry, and the agent corresponding to the node with the smallest variance of the data flow propagation influence factor in the cycle is forcibly marked as the conceding party.

5. The method for resolving conflicts in resource allocation for parallel intelligent agents according to claim 1, characterized in that: The generation and consistency verification of visual state anchor points in step S5 specifically includes: Intercept interface operation calls to the target shared application resources within the sandbox, capture a snapshot of the target window's interface state before the operation is executed, and extract the control hierarchy tree fingerprint or set of automation identifiers of the window as an interface feature vector, which is then stored in the visual state anchor point. Before re-execution after triggering a rollback to the handover point, the interface feature vector of the current window is recaptured and compared with the visual state anchor point. If the similarity is lower than a preset threshold, an abnormal alarm is triggered and the agent is paused. The orchestrator decides whether to roll back to the nearest checkpoint for re-running or to allow manual intervention.

6. The method for resolving conflicts in resource allocation for parallel intelligent agents according to claim 1, characterized in that: The workflow instance splitting in step S5 also includes: A synchronization barrier is set at the split point of the original workflow instance, and the new workflow instance starts execution on the standby agent from the entry task of the downstream task subgraph. The output variables of the new workflow instance carry the distributed transaction identifier when written to the shared variable pool at the termination node. The original workflow instance performs overwriting and aggregation of the corresponding keys in the shared variable pool based on the distributed transaction identifier at the termination node to ensure eventual consistency.

7. The method for resolving conflicts in resource allocation for parallel intelligent agents according to claim 1, characterized in that: It also includes adaptive backoff of conflict hot zones and dynamic index tuning steps: Maintain a conflict frequency counter with resource identifier as the key. When the number of conflict detections triggered by a target shared application resource within the sliding window exceeds a preset threshold, mark the resource as a conflict hotspot. For new resource requests subsequently arriving in the conflict hotspot, an exponential backoff delay is enforced, wherein the delay base is inversely proportional to the data stream propagation impact factor. Meanwhile, the index structure of the conflict hot zone is dynamically optimized: the time micro-slice granularity of the segment tree layer is increased to reduce space overhead, or parallel segment trees are enabled to support multi-way interval queries.

8. The method for resolving conflicts in resource allocation for parallel intelligent agents according to claim 1, characterized in that: The priority rules for topological sorting in step S4 also include a dynamic priority decay mechanism: In the topological sorting process of the semantic causal dependency graph increment, a dynamic priority value is maintained for each competing agent, with the initial value being the data flow propagation influence factor of that agent; After each preset sorting round, the priority of agents that have not received resource allocation is reduced: , It is positively correlated with the resource waiting time of the agent in the previous round; When the dynamic priority value decays to below the preset lower threshold, the agent is included in the concession sequence, and its downstream task subgraph is triggered to split the workflow instance according to step S5 to avoid the overall RPA process timeout.

9. The method for resolving conflicts in resource allocation for parallel intelligent agents according to claim 1, characterized in that: The collaborative query mechanism between the skip table layer and the segment tree layer includes: When a resource conflict query request is received, the Bloom filter layer is first queried for coarse-grained pre-determination. If a conflict is suspected, the query path is selected based on the current index level of the resource identifier: If the resource identifier is in the skip list level, then perform a skip list range query; If the resource identifier is in the segment tree layer, the Boolean aggregation value maintained by the internal nodes of the segment tree is queried to determine the interval coverage conflict. The internal nodes of the segment tree store the occupancy status of each time microslice in their subtree interval in a bitmap compression manner. The query results return a Boolean value indicating the conflict status and a list of identifiers of competing intelligent agents involved in the conflict.

10. The method for resolving conflicts in resource allocation for parallel intelligent agents according to claim 1, characterized in that: The validity period of the semantically weighted temporary pre-hold token is bound to the global lease epoch of the RPA workflow; When the execution engine undergoes a primary / backup switch or execution context reconstruction, all semantically weighted temporary pre-occupancy tokens and effective occupancy tokens issued under the old epoch automatically become invalid. In response to the epoch change event, the resource occupancy status tracking layer clears the occupancy record of the corresponding epoch and forces all affected agents to re-initiate the pre-declaration phase based on the current global lease epoch. When the pre-declaration phase is restarted, the data flow propagation influence factor of each agent in the set of competing agents is recalculated based on the current data flow dependency graph, and the reconstruction of the semantic causal dependency graph increment is triggered to avoid misjudgment of resource allocation conflict caused by token expiration.

Images