Agile development task dynamic allocation method based on multi-agent cooperation

Abstract

The present application relates to the technical field of task allocation, in particular to a dynamic agile development task allocation method based on multi-agent cooperation, which establishes a task chain for a development task through multi-agents, sets a boundary node, maintains a load snapshot of the task chain corresponding to each agent to record task allocation information, and real-time monitors task changes and makes hierarchical determination, when a single point changes, only the load snapshot of the task chain is updated locally, when a structure changes, associated tasks are traced bidirectionally along the task chain, a minimum affected task set is generated by combining cumulative fuse verification, the allocation association between the head and tail nodes of the task set and the original task chain is cut off, and the task set is redistributed, bidirectional dependency verification is completed and the load snapshot is updated after redistribution. Through task chain boundary isolation, change hierarchical processing and redistribution, the present application blocks change cascade diffusion, discards global redistribution, and effectively improves the multi-agent cooperation efficiency and the stability of task allocation.

Description

Technical Field

[0001] This invention relates to the field of task allocation technology, and in particular to a method for dynamic allocation of agile development tasks based on multi-agent collaboration. Background Technology

[0002] Agile development is a mainstream R&D model centered on short iteration cycles, rapid response to requirements, and dynamic task adjustment. In a multi-agent collaborative architecture, agents act as independent units for task execution, load maintenance, and scheduling decisions, achieving decentralized management and improving system collaboration efficiency. However, in agile development, task dependencies are prone to large-scale changes. A change in the allocation of a single subtask can easily lead to cascading failures—that is, local task reassignment can cause the allocation, load, and dependencies of dozens of related tasks to fail. Therefore, in existing agile task allocation methods, even a small change in the allocation of a single task by multiple agents can render a large number of task allocations invalid. Agents need to re-plan and reassign the entire task allocation, and given the extremely short iteration cycles in agile development, the computational overhead and consistency synchronization costs of task reassignment far exceed the capacity of existing agents.

[0003] Therefore, it is necessary to propose a dynamic task allocation method for agile development based on multi-agent collaboration to solve the above problems. Summary of the Invention

[0004] The purpose of this invention is to provide a dynamic task allocation method for agile development based on multi-agent collaboration, so as to solve the problem that task reassignment will cause the allocation, load and dependencies of dozens of related tasks to fail.

[0005] To achieve the above objectives, the present invention provides the following technical solution: A method for dynamically allocating agile development tasks based on multi-agent collaboration includes the following steps: When defining agile development tasks, and when multiple agents initially allocate tasks, they establish dependency nodes and influencing nodes for each task to generate task chains, and set task boundary nodes for each task chain; wherein, the dependency nodes are preceding tasks, and the influencing nodes are subsequent tasks. After the initial task allocation is completed, for each agent, a load snapshot of the current task chain of each agent is maintained. The load snapshot is used to record the task information allocated to the agent. When the agent detects a task change, it extracts the task change information to determine the type of task change. If the task change is a single point change, it updates the load snapshot based on the tasks in the task chain. If the task change is a structural change, it traces back the previous task and the subsequent task based on the task chain and task boundary nodes, and performs cumulative circuit breaker verification based on the number of traced tasks to generate the minimum affected task set. Based on the task chain in which the task set is located, the agent uses the head and tail task nodes of the task set to sever the allocation association between the task set and the task chain. The agent then redistributes the task sets that have been cut off from the task chain.

[0006] Preferably, the step of determining agile development tasks and initially assigning tasks to multiple agents, establishing dependency nodes and influencing nodes for each task to generate task chains, and setting task boundary nodes for each task chain, includes: The multi-agent system extracts all agile development tasks that need to be executed in this iteration from the product backlog list. For each current task, the multi-agent retrieves and marks tasks that must be completed before the current task is executed, based on the business execution logic and development process, to obtain the preceding tasks; and retrieves and marks tasks that depend on the completion of the current task before they can be executed, to obtain the subsequent tasks. A task chain is obtained by connecting the preceding, current, and subsequent tasks according to their directed dependency order. The multi-agent traverses each task chain, marking the current task without a preceding task as the starting boundary node and the current task without a following task as the ending boundary node, in order to generate the task boundary nodes of the task chain.

[0007] Preferably, after the initial task allocation is completed, the step of maintaining a load snapshot of the current task chain for each agent includes: After the task allocation is completed, each agent is assigned to a task in the current task chain to obtain the task allocation information. The agent encapsulates the task allocation information to obtain a load snapshot of the agent's current task chain.

[0008] Preferably, the step of extracting task change information to determine the type of task change when the intelligent agent detects a task change includes: The intelligent agent continuously monitors the attributes, status, and relationships of all tasks in the task chain to capture sudden events of task changes. The task change information includes attribute modification, dependency adjustment, task addition / deletion, and task splitting / merging. After detecting a task change, the task change information is extracted, and the type of task change is determined based on the extraction results: If the task change information is an attribute modification, it is determined to be a single point change; If the task change information is any one of dependency adjustment, task addition / deletion, or task splitting / merging, it is determined to be a structural change.

[0009] Preferably, the step of updating the load snapshot based on tasks in the task chain if the task change type is a single point change includes: Based on the task change information, the target task to be maintained is identified, and the corresponding intelligent agent and the task in the task chain are located. Retrieve the load snapshot of the responsible agent and update the load snapshot based on the tasks in the located task chain.

[0010] Preferably, the step of, if the task change type is a structural change, tracing back to the previous task and tracing back to the subsequent task based on the task chain and task boundary nodes, and performing cumulative circuit breaker verification based on the number of traced tasks to generate the minimum affected task set, includes: Based on the task change information, identify the source task that triggered the structural change, and determine the task chain to which the source task belongs and the task boundary node. Centered on the source task, the agent traces forward along the dependent nodes to find the preceding tasks and backward along the influencing nodes to find the following tasks. All the traced preceding and following tasks are merged with the source task to obtain a set of candidate tasks. The number of tasks in the candidate task set is counted and compared with the preset task set size threshold for this structural change. If the number of tasks does not exceed the size threshold, the candidate task set is taken as the least affected task set. If the number of tasks exceeds the size threshold, the agent stops tracing, retains the source task and its predecessor and successor tasks to obtain the task set.

[0011] Preferably, the preset of the scale threshold includes: Get the number of tasks in the corresponding task chain during this structural change; Determine the circuit breaker ratio coefficient based on the agile iteration cycle; The scale threshold is calculated based on the circuit breaker ratio coefficient and the number of tasks.

[0012] Preferably, the step of severing the allocation association between the task set and the task chain based on the head and tail task nodes of the task set, and then reallocating the task set severed from the task chain by the agent, includes: Based on the task chain in which the task set is located, determine the head task node and the tail task node of the task set. In a task chain, disconnect the head task node from its preceding task and disconnect the tail task node from its following task. Based on the cut-off task set, the agent redistributes the task set separately.

[0013] Preferably, the method further includes: After the task set is redistributed, a two-way verification is performed on the task set and the task chain, and the agent updates the data after the verification.

[0014] Preferably, after the task set is redistributed, the step of performing bidirectional verification on the task set and task chain, followed by updating by the intelligent agent, includes: By determining the head and tail task nodes after the task set is redistributed, the preceding and following tasks of the task chain are obtained respectively, and the dependency relationships are verified respectively. If the verification passes, the task set is reconnected to the task chain, the load snapshot of the task chain is read, and the agent updates it. If the verification fails, adjust the tasks within the task set and re-verify until it passes.

[0015] The technical effects and advantages of the present invention in the above technical solution are as follows: This invention establishes task chains for tasks and sets task boundaries, enabling each task chain to have an independent execution scope. This isolates task changes and avoids situations where a single task change necessitates the reallocation of all tasks. Based on the established task chains, task changes are categorized into single-point changes and structural changes through hierarchical judgment. Single-point changes adapt to local task changes, requiring only the reallocation of tasks in the relevant task chains without complex scheduling and allocation processes. For structural changes, bidirectional tracing is performed along the task chains, and circuit breaker checks are executed to obtain the least affected task set. The agent then reallocates the task set to prevent the cascading spread of changes. This method achieves both the effect of avoiding the omission of affected task allocation during task reallocation and the reduction of computational overhead during reallocation. Attached Figure Description

[0016] Figure 1 This is a flowchart of the agile development task dynamic allocation method based on multi-agent collaboration of the present invention. Detailed Implementation

[0017] 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.

[0018] like Figure 1 As shown, this embodiment provides a method for dynamically allocating agile development tasks based on multi-agent collaboration, including the following steps: S1: When determining agile development tasks, during the initial allocation of tasks by multiple agents, dependent nodes and influencing nodes are established for each task to generate a task chain, and task boundary nodes are set for each task chain; wherein, the dependent nodes are the preceding tasks, and the influencing nodes are the following tasks. S2: After the initial task allocation is completed, for each agent, maintain a load snapshot of the current task chain of each agent. The load snapshot is used to record the task information allocated to the agent. S3: When the agent detects a task change, it extracts the task change information to determine the type of task change. If the task change is a single point change, it updates the load snapshot based on the tasks in the task chain. If the task change is a structural change, it traces the preceding tasks forward and the following tasks backward based on the task chain and task boundary nodes. It also performs cumulative circuit breaker verification based on the number of traced tasks to generate the minimum set of tasks affected. S4: Based on the task chain in which the task set is located, the agent uses the head and tail task nodes of the task set to sever the allocation association between the task set and the task chain. The agent then redistributes the task sets that have been cut off from the task chain.

[0019] In one embodiment of the present invention, the step of determining agile development tasks and initially allocating tasks among multiple agents, establishing dependency nodes and influencing nodes for each task to generate task chains, and setting task boundary nodes for each task chain, includes: S11: The multi-agent extracts all agile development tasks that need to be executed in this iteration from the product backlog list; S12: For each current task, the multi-agent retrieves and marks the tasks that must be completed before the current task is executed, based on the business execution logic and development process, to obtain the preceding tasks; and retrieves and marks the tasks that depend on the completion of the current task before they can be executed, to obtain the subsequent tasks. S13: Based on the directed dependency order of the preceding task, the current task, and the following task, a task chain is obtained by connecting them together; S14: The multi-agent traverses each task chain, marking the current task without a preceding task as the starting boundary node and the current task without a following task as the ending boundary node, in order to generate the task boundary nodes of the task chain.

[0020] In this embodiment of the invention, in agile development tasks, there are task dependencies among the structured tasks built by multiple agents. To prevent agents from needing to reallocate all tasks due to task changes, the following method is provided, as shown in steps S11-S14 above: Multiple agents select and extract all valid tasks belonging to the current iteration from the product backlog list, based on the development goals and requirements of the current iteration cycle. Specifically, the selection and extraction of valid tasks is based on iteration delivery goals, requirement priority, and requirement completeness. For iteration delivery goals, only tasks related to the iteration launch goal are selected. For requirement priority, development tasks derived from high-priority requirement decomposition are extracted first. For requirement completeness, the selection criteria are whether the requirement review has been completed and whether the business rules have been finalized. This is how valid tasks belonging to the current iteration are selected and extracted. Effective tasks include executable development tasks such as interface development, page coding, functional logic implementation, unit testing, and interface integration debugging. Irrelevant, unplanned, and delayed tasks are excluded, such as pending tasks with unclear requirements and no review, delayed tasks planned to be postponed to subsequent iterations, and cross-iteration irrelevant tasks that are beyond the scope of the current iteration. Taking a single task as the unit of analysis, and combining the execution order of business functions and the conventional process of software development, such as interface development taking precedence over page development and functional development taking precedence over testing and verification, the dependency nodes and influencing nodes of each task are defined. Among them, the dependency nodes are used to constrain the starting prerequisites of the task, and the influencing nodes are used to identify the transmission effect of the task, thereby clarifying the execution constraint relationship between tasks. While defining the dependency nodes and influencing nodes of each task, the scattered tasks are arranged into a linear, acyclic, and logically coherent task chain according to the order of the preceding tasks, the current tasks, and the subsequent tasks. To determine the independent execution scope and logical boundaries of each task chain and achieve mutual isolation between different task chains, it is necessary to set boundaries for the task chains. By traversing the beginning and end endpoints of the task chain and using the start and end boundary nodes, the scope of the task chain is obtained. The beginning and end endpoints are determined by the following: in the dependency topology of the current task chain, if the current task has no dependent nodes, it means that it does not need to wait for the completion of any other task in the task chain, and thus the task can be started as the first task in the task chain. As for the end boundary node, if no other task in the task chain depends on the execution of this task to start, then this task is the final execution node of the task chain and there are no subsequent transitive tasks.

[0021] In one embodiment of the present invention, after the initial task allocation is completed, the step of maintaining a load snapshot of the current task chain for each agent includes: S21: After the task allocation is completed, each agent is responsible for the task in the current task chain to obtain the task allocation information; S22: The agent encapsulates the task allocation information to obtain a snapshot of the agent's current task chain load.

[0022] In this embodiment of the invention, as shown in steps S21-S22 above, the intelligent agent, as the smallest unit of task execution and scheduling, is responsible for the corresponding task in the task chain. After the task allocation is completed, each intelligent agent determines the task in its corresponding task chain and maintains the task allocation information. The task allocation information is the basis for the execution between the intelligent agent and the task, as well as between the intelligent agent and the task chain. It mainly includes the task chain to which the task belongs, the intelligent agent to which the task belongs, the amount of task, the execution order, dependent nodes, and influencing nodes, etc. The agent encapsulates the allocation information and generates a load snapshot. By formatting and organizing the task allocation information of the same agent that belongs to the same task chain, the organized task ownership relationship, task chain binding relationship and other data are encapsulated into a static data structure to form a load snapshot of the agent in the current task chain. The load snapshot is uniquely bound to the agent and the corresponding task chain. When the agent updates a task, the load snapshot corresponding to the task chain is updated.

[0023] In one embodiment of the present invention, the step of extracting task change information to determine the type of task change when the intelligent agent detects a task change includes: S31: The intelligent agent continuously monitors the attributes, status, and relationships of all tasks in the task chain to capture sudden events of task changes. The task change information includes attribute modification, dependency adjustment, task addition / deletion, and task splitting / merging. S32: After detecting a task change, extract the task change information and determine the type of task change based on the extraction results. If the task change information is an attribute modification, it is determined to be a single point change; If the task change information is any one of dependency adjustment, task addition / deletion, or task splitting / merging, it is determined to be a structural change.

[0024] If the task change type is a single point change, the step of updating the load snapshot based on the tasks in the task chain includes: S33: Based on the task change information, locate the target task to be maintained, and identify the agent to which the target task belongs and the tasks in the task chain. S34: Retrieve the load snapshot of the owner agent and update the load snapshot based on the tasks in the located task chain.

[0025] If the task change type is a structural change, the steps of tracing back to the previous task and tracing back to the subsequent task based on the task chain and task boundary nodes, and performing cumulative circuit breaker verification based on the number of traced tasks to generate the minimum affected task set include: S35: Based on the task change information, locate the source task that triggered the structural change, and determine the task chain to which the source task belongs and the task boundary node; S36: Centered on the source task, the agent traces forward along the dependent nodes to find the preceding tasks and backward along the influencing nodes to find the following tasks. All the traced preceding and following tasks are merged with the source task to obtain a set of candidate tasks. S37: Count the number of tasks in the candidate task set and perform cumulative circuit breaking verification with the preset task set size threshold for this structural change. If the number of tasks does not exceed the size threshold, the candidate task set is taken as the smallest affected task set; if the number of tasks exceeds the size threshold, the agent stops tracing, retains the source task and the preceding and following tasks of the source task to obtain the task set.

[0026] The preset settings for the scale threshold include: S371: Get the number of tasks in the corresponding task chain during this structural change; S372: Determine the circuit breaker ratio coefficient based on the agile iteration cycle; S373: The scale threshold is calculated based on the circuit breaker ratio coefficient and the number of tasks.

[0027] In this embodiment of the invention, as shown in steps S31-S32 above, the agent monitors the task chain. If the detected task change is an attribute modification, it is determined to be a single-point change. Attribute modifications include non-structural adjustments such as task owner, working hours, and priority. Since this type of change does not change the dependency relationship of the task chain, does not add or delete tasks, does not adjust the execution order of tasks, and does not destroy the structure of the task chain, the scope of its impact is limited to the current task itself and the corresponding owner agent. Therefore, it is a single-point change with the smallest impact range that can be processed quickly. If the detected task changes involve task dependency adjustments, task additions / deletions, and task splitting / merging, they are judged as structural changes. Unlike attribute modifications, dependency adjustments, task additions / deletions, and task splitting / merging directly change the structure of the task chain. Dependency adjustments disrupt the execution constraints between tasks, task additions / deletions change the length of the task chain and the number of tasks, and task splitting / merging changes the composition and execution path of the task chain. By determining the type of task change, using the results of single-point change determination, local updates are performed based on load snapshots. Using the results of structural change determination, related task chains are processed, blocking the cascading spread of changes while minimizing the computational and synchronization costs of multi-agent scheduling. If the determination result is a single point change, as shown in steps S33-S34 above, based on the extracted task change information, locate the target task whose attribute has been modified, determine the agent and task chain to which the task belongs, retrieve only the load snapshot of the target task in the agent, and based on the task allocation information of the load snapshot and the attribute modification content, perform a local incremental update on the load data. The updated content is only related to the target task. If the determination result is a structural change, as shown in steps S35-S37 above, based on the information of the structural change, locate the initial source task that caused the change in the task chain structure, determine which task chain the source task belongs to, and the boundary node of the task chain. With the source task as the center, according to the directed order of the preceding task, current task and subsequent task of the task chain, search forward for the preceding task corresponding to all dependent nodes, and search backward for the subsequent task of all affected nodes to obtain a candidate task set. To avoid the problem of an excessive number of tasks in a task set, which could easily trigger a wide-ranging cascading effect, and to adhere to the requirements of short-cycle agile development, rapid response to changes in requirements, and low cost, the task set is divided by statistically analyzing the number of tasks in the task set, so as to obtain a task set with the smallest impact range. By using the number of tasks in the statistical task set and comparing it with the preset threshold for the size of the task set for this structural change, a circuit breaker check is performed. If the number of tasks does not exceed the threshold, the candidate task set is taken as the least affected task set. If the number of tasks exceeds the threshold, the agent stops tracing, retains the source task and its predecessor and successor tasks to obtain the task set. The definition of the least affected scope needs to simultaneously satisfy the following conditions: minimization of the association boundary, the most direct association relationship, minimization of the number of tasks, and necessity of change. Among them, minimization of the association boundary is limited to within the task chain, constrained by the task boundary nodes, and does not spread to other task chains. The most direct association relationship means including the source task, predecessor task, and successor task, and retaining the nodes directly affected by the change. Minimization of the number of tasks means that the number of tasks does not exceed 15%-25% of the total number of tasks in the task chain. Necessity of change means that only tasks that need to be adjusted due to the structural change are retained, thus obtaining the least affected task set. In this embodiment, all preceding and subsequent tasks associated with the source task tracing structure change are used to avoid missing affected tasks. The cumulative circuit breaker verification controls the size of the task set and blocks the cascading spread of changes. Through the above method, the effect of avoiding missing affected task allocation is achieved during task redistribution, and the computing power overhead during redistribution is reduced. For the pre-setting of the scale threshold, as shown in steps S371-S373 above, the circuit breaker ratio coefficient is determined by the agile iteration cycle. Specifically, the ratio coefficient is determined based on the length of the iteration cycle, the scale of the task chain, and the minimum affected scope and cost. For example, if the iteration cycle is two weeks, the task volume is small, and the change response requirements are high, the circuit breaker ratio coefficient can be selected as 20%-25%. If the iteration cycle is four weeks, the task volume is medium, and the circuit breaker ratio coefficient can be selected as 15%-20%. In order to simplify the calculation and reduce the computing power overhead of the agent, the middle value is selected, that is, 20% can be selected as the fixed circuit breaker ratio coefficient. After determining the number of tasks in the task chain, the scale threshold is calculated by multiplying the number of tasks by the circuit breaker ratio coefficient, and the calculated scale threshold is rounded to complete the setting of the scale threshold for this structural change. The magnitude of the circuit breaker ratio coefficient is a specific value obtained by quantifying each parameter to facilitate subsequent comparison. The magnitude of the circuit breaker ratio coefficient depends on the amount of sample data and the preset circuit breaker ratio coefficient initially set by those skilled in the art for each set of sample data, as long as it does not affect the proportional relationship between the parameter and the quantified value.

[0028] In one embodiment of the present invention, the step of severing the allocation association between the task set and the task chain based on the head and tail task nodes of the task set, and then reallocating the task set severed from the task chain by the intelligent agent, includes: S41: Determine the head and tail task nodes of the task set based on the task chain in which the task set is located. S42: In a task chain, disconnect the head task node from its predecessor task and disconnect the tail task node from its successor task. S43: Based on the cut-off task set, the agent redistributes the task set separately.

[0029] The method also includes: After the task set is redistributed, a two-way verification is performed on the task set and the task chain, and the agent updates the data after the verification.

[0030] After the task set is redistributed, the steps of performing bidirectional verification on the task set and task chain, followed by updates by the intelligent agent, include: By determining the head and tail task nodes after the task set is redistributed, the preceding and following tasks of the task chain are obtained respectively, and the dependency relationships are verified respectively. If the verification passes, the task set is reconnected to the task chain, the load snapshot of the task chain is read, and the agent updates it. If the verification fails, adjust the tasks within the task set and re-verify until it passes.

[0031] In this embodiment of the invention, as shown in steps S41-S43 above, after the task set is redistributed, the head and tail task nodes are identified. The head task node refers to the first task in the execution order within the task set, while the tail task node refers to the last task in the execution order within the task set. Both the head and tail task nodes belong to the internal tasks of the least affected task set. Only their allocation binding with external tasks in the original task chain is disconnected. Both task nodes retain their dependencies on preceding or following tasks in the original task chain, thereby locating the preceding and following tasks in the original task chain. The task allocation process involves two-way verification: firstly, confirming that the head task requires the completion of the preceding task as a prerequisite for execution, and secondly, requiring the completion of the tail task as a prerequisite for execution. If the verification passes, the task set is reconnected to the original task chain's cutoff point. The load snapshots of the agents involved in the task set are read and partially updated, synchronizing the assigned task affiliation and load status. The load snapshots of agents and tasks not involved in the original task chain remain unchanged. If the verification fails, the agents fine-tune the task execution order, dependencies, or allocation affiliation within the task set, correct logical errors, and then perform verification again until the verification passes, ensuring the stability of the agile development task allocation process.

[0032] The foregoing has shown and described the basic principles, main features, and advantages of the present invention. Those skilled in the art should understand that the present invention is not limited to the above embodiments. The embodiments and descriptions in the specification are merely principles of the invention. Various changes and modifications can be made to the invention without departing from its spirit and scope, and all such changes and modifications fall within the scope of the claimed invention.

Claims

1. A method for dynamic allocation of agile development tasks based on multi-agent collaboration, characterized in that, Includes the following steps: When defining agile development tasks, and when multiple agents initially allocate tasks, they establish dependency nodes and influencing nodes for each task to generate task chains, and set task boundary nodes for each task chain; wherein, the dependency nodes are preceding tasks, and the influencing nodes are subsequent tasks. After the initial task allocation is completed, for each agent, a load snapshot of the current task chain of each agent is maintained. The load snapshot is used to record the task information allocated to the agent. When the agent detects a task change, it extracts the task change information to determine the type of task change. If the task change is a single point change, it updates the load snapshot based on the tasks in the task chain. If the task change is a structural change, it traces back the previous task and the subsequent task based on the task chain and task boundary nodes, and performs cumulative circuit breaker verification based on the number of traced tasks to generate the minimum affected task set. Based on the task chain in which the task set is located, the allocation association between the task set and the task chain is severed using the head and tail task nodes of the task set. The agent then redistributes the task sets that have been severed from the task chain. The step of extracting task change information to determine the type of task change when the intelligent agent detects a task change includes: The intelligent agent continuously monitors the attributes, status, and relationships of all tasks in the task chain to capture sudden events of task changes. The task change information includes attribute modification, dependency adjustment, task addition / deletion, and task splitting / merging. After detecting a task change, the task change information is extracted, and the type of task change is determined based on the extraction results: If the task change information is an attribute modification, it is determined to be a single point change; If the task change information is any one of dependency adjustment, task addition / deletion, or task splitting / merging, it is determined to be a structural change. If the task change type is a structural change, the steps of tracing back to the previous task and tracing back to the subsequent task based on the task chain and task boundary nodes, and performing cumulative circuit breaker verification based on the number of traced tasks to generate the minimum affected task set include: Based on the task change information, identify the source task that triggered the structural change, and determine the task chain to which the source task belongs and the task boundary node. Centered on the source task, the agent traces forward along the dependent nodes to find the preceding tasks and backward along the influencing nodes to find the following tasks. All the traced preceding and following tasks are merged with the source task to obtain a set of candidate tasks. The number of tasks in the candidate task set is counted and compared with the preset task set size threshold for this structural change. If the number of tasks does not exceed the size threshold, the candidate task set is taken as the smallest affected task set. If the number of tasks exceeds the size threshold, the agent stops tracing, retains the source task and its predecessor and successor tasks to obtain the task set. The preset settings for the scale threshold include: Get the number of tasks in the corresponding task chain during this structural change; Determine the circuit breaker ratio coefficient based on the agile iteration cycle; The scale threshold is calculated based on the circuit breaker ratio coefficient and the number of tasks.

2. The method for dynamic allocation of agile development tasks based on multi-agent collaboration according to claim 1, characterized in that, The steps of determining agile development tasks, and when multiple agents initially allocate tasks, include establishing dependency nodes and influencing nodes for each task to generate task chains, and setting task boundary nodes for each task chain. The multi-agent system extracts all agile development tasks that need to be executed in this iteration from the product backlog list. For each current task, the multi-agent retrieves and marks tasks that must be completed before the current task is executed, based on the business execution logic and development process, to obtain the preceding tasks; and retrieves and marks tasks that depend on the completion of the current task before they can be executed, to obtain the subsequent tasks. A task chain is obtained by connecting the preceding, current, and subsequent tasks according to their directed dependency order. The multi-agent traverses each task chain, marking the current task without a preceding task as the starting boundary node and the current task without a following task as the ending boundary node, in order to generate the task boundary nodes of the task chain.

3. The method for dynamic allocation of agile development tasks based on multi-agent collaboration according to claim 1, characterized in that, After the initial task allocation is completed, the step of maintaining a load snapshot of the current task chain for each agent includes: After the task allocation is completed, each agent is assigned to a task in the current task chain to obtain the task allocation information. The agent encapsulates the task allocation information to obtain a load snapshot of the agent's current task chain.

4. The method for dynamic allocation of agile development tasks based on multi-agent collaboration according to claim 1, characterized in that, If the task change type is a single point change, the step of updating the load snapshot based on the tasks in the task chain includes: Based on the task change information, the target task to be maintained is identified, and the corresponding intelligent agent and the task in the task chain are located. Retrieve the load snapshot of the responsible agent and update the load snapshot based on the tasks in the located task chain.

5. The method for dynamic allocation of agile development tasks based on multi-agent collaboration according to claim 1, characterized in that, The step of severing the allocation association between the task set and its task chain based on the head and tail task nodes of the task set, and then reallocating the task sets severed from the task chain by the agent, includes: Based on the task chain in which the task set is located, determine the head task node and the tail task node of the task set. In a task chain, disconnect the head task node from its preceding task and disconnect the tail task node from its following task. Based on the cut-off task set, the agent redistributes the task set separately.

6. The method for dynamic allocation of agile development tasks based on multi-agent collaboration according to claim 1, characterized in that, The method also includes: After the task set is redistributed, a two-way verification is performed on the task set and the task chain, and the agent updates the data after the verification.

7. The method for dynamic allocation of agile development tasks based on multi-agent collaboration according to claim 6, characterized in that, After the task set is redistributed, the steps of performing bidirectional verification on the task set and task chain, followed by updates by the intelligent agent, include: By determining the head and tail task nodes after the task set is redistributed, the preceding and following tasks of the task chain are obtained respectively, and the dependency relationships are verified respectively. If the verification passes, the task set is reconnected to the task chain, the load snapshot of the task chain is read, and the agent updates it. If the verification fails, adjust the tasks within the task set and re-verify until it passes.

Images