One-stop intelligent software development system based on multi-agent

Abstract

The application discloses a one-stop intelligent software development system based on multiple agents, which comprises a one-stop DevOps research and development cooperation platform and a multiple-agent scheduling and cooperation engine. The multiple-agent scheduling and cooperation engine is connected with each sub-module in the one-stop DevOps research and development cooperation platform, including a demand management module, a code library management module, a document management module, a pipeline module, a product library module, a code scanning module, a test management module and a measurement management module. The multiple-agent scheduling and cooperation engine comprises a task analysis and distributor, a multi-role virtual employee intelligent agent pool, a large model calling adapter, a delivery material archiving and integration controller and an artificial confirmation node manager, realizes end-to-end automation from demand description to software delivery, and only needs to fill in a natural language demand description or a prompt word in a task card, so that the system can automatically drive a whole-process task such as prototype generation, code writing, test case generation and construction deployment, and the software delivery cycle is greatly shortened.

Description

Technical Field

[0001] This invention relates to the field of software engineering technology, specifically to a one-stop intelligent software development system based on multi-agent systems. Background Technology

[0002] Software development engineering has undergone a continuous evolution from manual workshop-style development to tool-based, platform-based, and intelligent development. Early software development relied heavily on individual experience, with deliverables at each stage being manually transferred between teams. As software scale and complexity increased, version control systems, defect tracking tools, and automated build tools emerged and were widely used, initially improving efficiency at each stage. However, these tools remained independent, and data and process integration still required significant manual coordination. With the advent of DevOps, practices such as continuous integration, continuous delivery, and continuous deployment have matured. One-stop DevOps platforms integrate capabilities such as requirements management, code hosting, pipeline orchestration, artifact repository, and test management into a unified platform, significantly reducing the cost of switching and integrating multiple tools. This allows development teams to manage the entire software delivery lifecycle within a single platform. In recent years, with the rapid development of large language models and artificial intelligence technologies, AI-assisted functions, such as code completion, code generation, and code review suggestions, have begun to penetrate integrated development environments and DevOps platforms, providing efficiency improvements for developers in certain aspects. At the same time, the rise of intelligent agent technology has enabled AI to evolve from passive, responsive auxiliary tools to intelligent agents with autonomous planning and task execution capabilities. Research and practice on multi-agent collaboration have also received increasing attention, providing a new technical path for exploring how AI agents can replace or assist humans in completing more comprehensive software development tasks.

[0003] Currently, the industry has seen the emergence of various one-stop DevOps platform products, such as GitLab (which integrates code hosting, continuous integration and deployment, artifact repository, and project management functions), GitHub (which provides code hosting, Actions automated pipelines, and project management capabilities), and the Atlassian toolchain (a combination of Jira requirements management and Bitbucket code hosting) both internationally, and SimpleCloud ezOne, Huawei Cloud CodeArts, and Alibaba Cloud Cloud Effects among domestic one-stop DevOps platforms. These platforms integrate requirements management, code hosting, pipeline orchestration, test management, artifact repository, and deployment and release throughout the software development lifecycle into a unified interface, allowing development teams to manage the entire process from requirements creation to application deployment within a single platform. Meanwhile, AI-assisted programming tools are also rapidly developing, with the industry launching various AI IDEs and programming assistant products, such as Cursor and Claude Code internationally, and ByteDance Trae, Alibaba Tongyi Lingma, Baidu Comate, and Tencent CodeBuddy domestically. These tools primarily assist developers in improving coding efficiency in their local integrated development environments through code completion, code generation, and code explanation. Some DevOps platforms have also begun to embed AI capabilities into their platform processes, such as providing AI-assisted review suggestions during code reviews and offering exploratory functions for generating test cases using AI during testing. Furthermore, agent technology has developed rapidly in recent years, with both academia and industry exploring multi-agent collaborative architectures based on large language models, attempting to enable multiple AI agents with different roles to collaborate in completing complex tasks.

[0004] Although one-stop DevOps platforms have emerged, integrating capabilities such as requirements management, code hosting, continuous integration and deployment, and test management into a unified toolchain, which alleviates the problem of fragmented multiple tools to some extent, there are still significant shortcomings in achieving requirements-driven, end-to-end intelligent processes. The specific shortcomings are as follows: The core of existing one-stop DevOps platforms is still to provide process management and collaboration frameworks for human developers. The actual execution of tasks at each stage—including requirements analysis, architecture design, prototype design, code writing, test case writing, test execution, etc.—still relies heavily on manual labor. The platform itself does not have the ability to automatically generate multiple types of deliverables based on requirements descriptions. Essentially, it "manages processes" rather than "does things." Existing platforms lack a mechanism to directly drive deliverable production using natural language or prompts. The descriptive information in the requirement card is only used as a reference for human reading and understanding and cannot be automatically parsed by the system and transformed into deliverables such as interface prototypes, source code, test cases, and automated test scripts. The transformation from requirement text to executable deliverables still requires a lengthy process of human understanding, creation, and input. Existing platforms lack the ability to collaborate among multiple intelligent agents, and cannot simulate the parallel execution of tasks by multiple professional roles such as product managers, architects, development engineers, test engineers, operations engineers, and interaction designers. When a project has multiple parallel work items, it is still limited by the bottleneck of human resource scheduling, making it difficult to effectively compress the overall delivery cycle through the concurrent execution of virtual roles. While existing platforms support setting approval access controls at fixed stages such as building or deployment, they lack a mechanism to systematically embed manual confirmation nodes into automated execution processes for more upfront and granular decision points such as requirement understanding and confirmation, prototype solution review, generated code review, and test strategy verification. This makes it difficult to achieve a flexible and controllable balance between intelligent automated execution and manual quality control. Even if existing platforms integrate some AI-assisted functions, their output is usually limited to code snippet suggestions or simple auto-completion. The generated results cannot be automatically saved to the project document library or associated with the attachments of the corresponding requirement cards, nor can they be automatically submitted to the specified branch of the code repository and trigger subsequent code reviews, build and deployment processes. Deep integration between AI capabilities and the DevOps engineering system is still lacking. Existing platforms lack intelligent support in the user interface and user experience design stages. Tasks such as interface layout design, interaction flow planning, and visual style specification formulation still rely entirely on manual work by human designers. There is a lack of automated conversion mechanism between requirement description and usable interaction design solutions. Design deliverables cannot be automatically connected with the subsequent front-end code generation stage, resulting in information transmission loss and repeated rework between design and development. Summary of the Invention

[0005] The purpose of this invention is to provide a one-stop intelligent software development system based on multiple agents. This system aims to automatically complete the entire process of task execution, from requirements analysis, architecture design, interaction design, prototype generation, code writing and submission, code review, test case and automated test script generation, build deployment, to testing and verification, driven by natural language descriptions or prompts in requirement cards and through the collaborative work of multiple virtual employee agents. Furthermore, it flexibly embeds manual confirmation mechanisms at key decision-making nodes, significantly improving software delivery efficiency while ensuring controllable delivery quality, thereby solving the problems mentioned in the background art.

[0006] The key technical points and protection points of this invention are as follows: 1. Integration architecture of multi-agent scheduling and collaboration engine with one-stop DevOps platform Building upon the one-stop DevOps collaborative development platform (which includes functional modules such as requirements management, code repository management, document management, pipeline, artifact repository, code scanning, test management, and metrics management), a new multi-agent scheduling and collaboration engine has been added. This engine is deeply integrated with various sub-modules of the platform and the large model platform, forming an end-to-end automated architecture of "task card input → multi-agent collaborative execution → automatic archiving of multiple types of deliverables → manual confirmation and closed-loop iteration." The key technical point is that the multi-agent engine simultaneously reads task data from the requirements management module, schedules multiple roles of intelligent agents to execute in parallel, and automatically writes the outputs of each agent into the corresponding module through the platform interface, achieving seamless integration of AI capabilities with the DevOps engineering system.

[0007] 2. A multi-type deliverable generation method driven by natural language / prompt words based on task cards. Using the natural language requirement descriptions or prompts in the task cards as driving input, each role's virtual employee intelligence agent parses and generates corresponding types of deliverables (interface prototypes, source code, test cases, automated test scripts, etc.), realizing the automated transformation from a requirement text to multiple deliverables, breaking through the limitation of existing platforms that only "manage processes" but cannot "do things".

[0008] 3. Parallel collaborative working mechanism of multiple virtual employee intelligent agent roles By using a virtual employee intelligent agent pool, multiple professional roles such as product manager, architect, development engineer, test engineer, operations engineer, and interaction designer are simulated. Each role's intelligent agent can advance its respective task phase in parallel, breaking through the human resource scheduling bottleneck in traditional development models. The task parser and dispatcher intelligently allocates work based on task type and dependencies, supporting the concurrent execution of multiple tasks and effectively compressing the overall delivery cycle.

[0009] 4. Manual confirmation mechanism for key decision-making nodes Human confirmation nodes are systematically embedded at key decision points in the automated execution process (requirement understanding and confirmation, prototype solution review, code review and confirmation, test strategy verification, final acceptance, etc.). The process can be paused and resumed through a human confirmation node manager. When the human review fails, the modification suggestions can be fed back to the corresponding intelligent agent for automatic correction, forming a closed-loop iterative mechanism of "intelligent agent execution → human review → feedback correction", which ensures both automation efficiency and controllable delivery quality.

[0010] 5. Deep integration methods of intelligent agent deliverables and DevOps engineering system The deliverables produced by each virtual employee intelligent agent are automatically archived to the corresponding module of the DevOps platform through the deliverable archiving and integration controller: prototype documents and solution documents are stored in the document library and associated with task card attachments; source code is pushed to the designated branch of the code repository in an atomic submission manner and a code review form is automatically created; test cases and automated test scripts are stored in the test management module; and the build and deployment pipeline is automatically triggered after the code is submitted. This realizes the full-link automatic integration of AI-generated deliverables and the project engineering system, eliminating the links of manual sorting and manual integration.

[0011] To achieve the above objectives, the present invention provides the following technical solution: A one-stop intelligent software development system based on multi-agent systems includes users, a one-stop DevOps collaborative development platform, a multi-agent scheduling and collaboration engine, and a large model platform. The multi-agent scheduling and collaboration engine and the various sub-modules in the one-stop DevOps collaborative development platform include a requirements management module, a code repository management module, a document management module, a pipeline module, an artifact repository module, a code scanning module, a test management module, and a metrics management module. The multi-agent scheduling and collaboration engine includes a task parser and dispatcher, a multi-role virtual employee agent pool, a large model invocation adapter, a deliverable archiving and integration controller, and a manual confirmation node manager.

[0012] As a further aspect of this invention: the requirement management module handles the creation of task cards, status transitions, and structured storage of requirement descriptions; the code repository management module provides structured records of code hosting, branch management, code review creation, and review comments; the document management module is responsible for versioned storage of deliverable documents at each stage and their association with task cards; the pipeline module is responsible for the orchestration and execution of continuous integration and continuous delivery processes such as building, deployment, and automated testing; the artifact repository module is responsible for versioned archiving and distribution management of build artifacts; the code scanning module provides capabilities for static code analysis, security vulnerability detection, and coding standard checks; the test management module handles test case management, test execution records, and the summary display of test reports; and the metrics management module collects and visualizes the efficiency and quality indicators of each stage.

[0013] As a further aspect of the present invention: the requirement management module, code repository management module, document management module, pipeline module, artifact repository module, code scanning module, test management module, and measurement management module expose standardized data access capabilities to the outside world through a unified platform interface layer, providing an integrated foundation for data reading and writing for multi-agent scheduling and collaborative engines.

[0014] As a further aspect of this invention, the interfaces of the platform interface layer include, but are not limited to: the requirement management module providing interfaces for creating, querying, status transitioning, and associating attachments for task cards; the code repository management module providing interfaces for querying repository directory trees, reading file content, creating and managing branches, creating commits, creating merge requests, and reading and writing review comments; the document management module providing interfaces for creating documents, versioned storage, and reading content; the pipeline module providing interfaces for pipeline triggering, querying execution status, and obtaining logs; and the test management module providing interfaces for batch importing test cases, writing execution records, and querying reports. All interfaces employ a unified identity authentication and permission verification mechanism to ensure that each agent can only access platform resources within its role's permission scope.

[0015] As a further aspect of the present invention: the task parser and dispatcher is used to read the structured requirement description or prompt words in the task card, perform task type identification and stage decomposition, and distribute the decomposed sub-tasks to the virtual employee intelligent agents of the corresponding roles.

[0016] As a further aspect of the present invention: the multi-role virtual employee intelligent agent pool includes product manager intelligent agents, architect intelligent agents, development engineer intelligent agents, test engineer intelligent agents, operations engineer intelligent agents, and interaction designer intelligent agents.

[0017] As a further aspect of the present invention: the large model call adapter connects to the enterprise's privately deployed large model service or third-party large model application interface through a unified interface, thus shielding the interface differences between different large model platforms.

[0018] As a further aspect of the present invention: the deliverable archiving and integration controller is used to automatically archive the deliverables produced by each agent to the corresponding document library or task card attachment, push the generated code to the specified branch of the code repository in an atomic commit manner, automatically create code reviews and trigger the subsequent build and deployment pipeline.

[0019] As a further aspect of the present invention: the manual confirmation node manager is used to insert a manual confirmation step at the key decision point of the task flow, pausing the automated process and waiting for manual review and approval before continuing to execute subsequent steps.

[0020] A one-stop intelligent software development method based on multi-agent systems, the steps of which are as follows: Step 1: Users access the requirements management module through the system's web interface and create task cards; Step 2: After receiving the task, the multi-agent scheduling and collaboration engine reads the requirement description or prompt words in the card, identifies the task type and decomposes it into stages, generates an execution plan containing sub-tasks for each stage, and distributes the sub-tasks to the virtual employee agents with the corresponding roles. Step 3: The product manager agent and the interaction designer agent collaborate based on the confirmed requirements description. Specifically, the product manager agent generates product solution documents, and the interaction designer agent generates interface prototypes. Step 4: The development engineer's intelligent agent receives the confirmed prototype solution, architecture design document, and requirements description, and calls the large language model to generate source code files that meet the requirements; Step 5: After the code review is passed, the test engineer's intelligent agent, based on the requirements description and the reviewed source code, calls the large language model to generate test case documents and automated test scripts; Step Six: After all automated tests pass, the system inserts the fifth manual confirmation node – final acceptance confirmation. Specifically, the system pushes an acceptance notification to the project manager through a web interface. The project manager can view all deliverables associated with this task on the task card details page, including product solution documents, interaction design solutions, architecture design documents, source code submission records, test cases, and test reports.

[0021] Compared with the prior art, the beneficial effects of the present invention are: This invention achieves end-to-end automation from requirements description to software delivery. Users only need to fill in natural language requirements descriptions or prompts in the task card, and the system can automatically drive the entire process of tasks such as prototype generation, code writing, test case generation, and build deployment, which greatly shortens the software delivery cycle. This invention breaks through the bottleneck of human resource scheduling in the traditional development model by enabling parallel collaboration of multiple virtual employee intelligent agents. Multiple tasks can be carried out simultaneously by intelligent agents with different roles, effectively compressing the overall delivery time. This invention systematically embeds a manual confirmation mechanism at key decision-making nodes in automated processes, which not only retains the high efficiency of automated execution, but also ensures that key quality indicators such as the accuracy of requirement understanding, code quality, and test coverage are within the range of human control, thus achieving a balance between intelligence and quality control. The deliverables produced by each intelligent agent in this invention are automatically archived to the corresponding modules of the platform (document library, code repository, test management, etc.), eliminating the need for manual sorting and integration. The AI ​​capabilities are deeply integrated with the DevOps engineering system, eliminating the integration gap between traditional AI-assisted tools and project engineering systems. This invention achieves automated transformation from requirement description to interface design scheme through an interaction designer intelligent agent. It incorporates tasks that originally relied entirely on manual work by human designers, such as user interface layout, interaction flow planning, and visual style specification formulation, into the scope of automatic execution by the intelligent agent. The design deliverables can be directly connected to the subsequent front-end code generation stage, eliminating information transmission loss and repeated rework between design and development. Attached Figure Description

[0022] Figure 1 This is a schematic diagram of the structure of a one-stop intelligent software development system based on multiple agents.

[0023] Figure 2 This is a flowchart of a one-stop intelligent software development method based on multiple agents.

[0024] Figure 3 This is a module diagram of a one-stop DevOps collaborative development platform in a one-stop intelligent software development system based on multiple agents.

[0025] Figure 4 This is a module diagram of the multi-agent scheduling and collaboration engine in a one-stop intelligent software development system based on multi-agents. Detailed Implementation

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

[0027] Please see Figures 1-4 In this embodiment of the invention, a one-stop intelligent software development system based on multi-agent systems includes a user interface (Web interface), a one-stop DevOps collaborative development platform, a multi-agent scheduling and collaboration engine, and a large model platform. The multi-agent scheduling and collaboration engine and the various sub-modules in the one-stop DevOps collaborative development platform include core functional modules such as a requirements management module, a code repository management module, a document management module, a pipeline module, an artifact repository module, a code scanning module, a test management module, and a metrics management module. The multi-agent scheduling and collaboration engine includes a task parser and dispatcher, a multi-role virtual employee agent pool, a large model calling adapter, a deliverable archiving and integration controller, and a manual confirmation node manager. The requirement management module handles the creation of task cards, status transitions, and structured storage of requirement descriptions. The code repository management module provides structured records of code hosting, branch management, code review creation, and review comments (each review comment is persistently stored as an object, recording the comment text, file path, precise line number, difference context snapshot, and unique identifier of the review form, forming a standardized data interface layer that can be directly read by agents). The document management module is responsible for the versioned storage of deliverable documents (product solutions, architecture designs, interaction design solutions, etc.) at each stage and their association with task cards. The pipeline module is responsible for the orchestration and execution of continuous integration and continuous delivery processes such as building, deployment, and automated testing. The artifact repository module is responsible for the versioned archiving and distribution management of build artifacts. The code scanning module provides static code analysis, security vulnerability detection, and coding standard inspection capabilities. The test management module handles test case management, test execution records, and the summary display of test reports. The metrics management module collects and visualizes efficiency and quality indicators for each stage. All the above sub-modules expose standardized data access capabilities through a unified platform interface layer, providing an integrated foundation for data reading and writing for multi-agent scheduling and collaboration engines. The platform interface layer includes, but is not limited to: the requirements management module, which provides interfaces for creating, querying, status transitioning, and associating attachments for task cards; the code repository management module, which provides interfaces for querying the repository directory tree, reading file content, creating and managing branches, creating commits, creating merge requests, and reading and writing review comments; the document management module, which provides interfaces for creating documents, storing versions, and reading content; the pipeline module, which provides interfaces for triggering pipelines, querying execution status, and obtaining logs; and the test management module, which provides interfaces for batch importing test cases, writing execution records, and querying reports. All interfaces adopt a unified identity authentication and permission verification mechanism to ensure that each agent can only access platform resources within the scope of its role's permissions. The task parser and dispatcher is used to read the structured requirement description or prompts in the task card, identify the task type and decompose it into stages, and distribute the decomposed subtasks to the corresponding virtual employee agents. Technically, after receiving the original content of the task card, the task parser and dispatcher first transforms the natural language requirement description into a structured task object using a large language model. This object is represented using a predefined data pattern, with core fields including: task type identifier (enumerated values ​​such as front-end page development, back-end interface development, database design, full-stack function development, etc.), functional requirement list (each item includes function name, description, and priority), interface element list (page name, input field definition, interaction behavior description), and interface requirement list (interface path, etc.). The system retrieves the method, parameter structure, response structure, acceptance criteria list (verification conditions and expected results), target code repository address, and target branch name. The large language model outputs these objects in a strict data format using a pre-set structured extraction prompt word template. The system performs data pattern verification on the output results and automatically retryes if the verification fails. After obtaining the structured task object, the dispatcher executes a phase decomposition algorithm to split the overall task into multiple sub-task nodes according to the task type and functional requirements. Each node contains a sub-task identifier, a responsible agent role, an input dependency list, and an expected output type. The dependencies between sub-task nodes form a directed acyclic graph. The system determines the execution order using a topological sorting algorithm. Sub-tasks at the same topological level and without mutual dependencies can be scheduled and executed in parallel. The multi-role virtual employee intelligence agent pool includes a product manager intelligence agent (responsible for requirements analysis and product solution document generation), an architect intelligence agent (responsible for system architecture design, technology selection and module division, outputting architecture design documents and technical solutions for subsequent development intelligence agents to follow), a development engineer intelligence agent (responsible for code generation and submission), a test engineer intelligence agent (responsible for test case and automated test script generation), an operations engineer intelligence agent (responsible for build deployment and environment configuration), and an interaction designer intelligence agent (responsible for user interface design, user experience design and interaction flow design, outputting interface layout schemes, interaction flowcharts, visual style specifications, etc. based on requirements descriptions and product prototypes). The system comprises multiple professional roles, including those responsible for ensuring the final software product has a good user experience and consistent interface. Each agent performs tasks within its respective domain based on the capabilities of a large language model. The internal architecture of each virtual employee agent adopts a unified three-layer structure: a prompt word engineering layer, a context injection layer, and a tool invocation layer. The prompt word engineering layer maintains a unique system prompt word template for each role (defining role identity, professional capability boundaries, output format requirements, and quality constraints). The context injection layer reads the required deliverables and reference information for the current subtask from the task context pool and assembles them into the large language model input context. The tool invocation layer configures callable platform interface tools for each role. The system is designed to enable data interaction with various sub-modules of the platform. The implementation methods for each role are as follows: The Product Manager agent's input context includes the original requirement description, structured task objects, and a summary of historical requirement documents; the output is a product solution document containing a functional scope description, a list of user stories, and detailed acceptance criteria. The Architect agent's input context includes the product solution document and the existing project structure of the target repository (obtained through the code repository management interface); the output is an architecture design document containing technology selection instructions, module division, inter-module interface definitions, and data model design. The Development Engineer agent's input context includes the architecture design document, interaction design scheme, and existing key... The code file content (read via the code repository management interface) is constrained by prompts to ensure that the generated code follows a specified framework structure, naming conventions, and comment requirements. Available tools include interfaces for branch creation, file writing, and commit creation. The input context for the test engineer agent includes requirements description, source code, and acceptance criteria. The output is structured test cases containing test case numbers, test scenarios, preconditions, test steps, and expected results, as well as executable automated test scripts. The input context for the interaction designer agent includes product solutions and interface element information. The output is an interaction design solution document containing page wireframe descriptions, component layout definitions, interaction state transition descriptions, and visual style parameters.The collaborative communication between the agents is achieved through a "task context pool + event-driven mechanism". The task context pool stores the outputs and execution metadata of each stage with the task card identifier as the isolation key. The event-driven mechanism is based on an asynchronous message queue to publish and subscribe to sub-task state changes. The scheduling engine determines whether the downstream sub-task meets the start conditions based on the dependency relationship of the directed acyclic graph and then automatically schedules and executes it. The large model invocation adapter connects to enterprise-privately deployed large model services or third-party large model application interfaces through a unified interface, shielding the interface differences between different large model platforms. At the implementation level, the large model invocation adapter defines a unified model invocation abstract interface. Input parameters include system prompts, user prompts, context message lists, output format constraints (free text or structured data format), and model configuration parameters (temperature coefficient, maximum number of generated tokens, stopping sequence, etc.). The adapter internally maintains a model routing strategy configuration table, which routes requests to the most suitable model instance based on task type (code generation tasks are routed to code-specific large models, and document generation tasks are routed to general dialogue large models). It also implements a context truncation strategy when input tokens exceed the limit (preserving core context by priority), an exponential backoff retry mechanism when the call fails, and model degradation switching logic when consecutive failures exceed the threshold. The input, output, and token consumption of each call are recorded in the measurement management module for cost accounting and effect analysis. The deliverable archiving and integration controller automatically archives the deliverables (prototype documents, architecture design documents, interaction design schemes, source code, test cases, test scripts, etc.) produced by each agent to the corresponding document library or task card attachments. It then pushes the generated code to the specified branch of the code repository using atomic commits, automatically creating code reviews and triggering subsequent build and deployment pipelines. Taking code-type deliverables as an example, the deliverable archiving and integration controller executes the following atomic commit process: First, it checks whether the target development branch exists through the code repository management interface. If it does not exist, it creates a new branch based on the main branch (naming rule: "ai / task-{task card identifier}-{timestamp}"). Then, it writes all generated code files to the target branch in a single commit transaction through the batch file writing interface (commit information format: "[Agent automatically generated"). Based on the task card #{card identifier} requirement, a {feature summary} is generated. After submission, the merge request creation interface is automatically called to create a merge request from the development branch to the trunk branch and specify the reviewers. Finally, the pipeline execution interface is triggered to start the continuous integration pipeline. For document-type deliverables, the deliverable archiving and integration controller calls the document management module's creation interface to store the document in a versioned manner into the document library, and writes the document identifier into the task card's attachment field through the attachment association interface to establish a two-way association. For test-type deliverables, the deliverable archiving and integration controller stores test cases through the test management module's batch import interface and associates them with task cards, and stores automated test scripts in the repository's test directory as code submissions. The manual confirmation node manager is used to insert manual confirmation steps at key decision points in the task flow (requirement understanding confirmation, prototype solution review, code review confirmation, test strategy verification, deployment approval, etc.), pausing the automated process and waiting for manual review approval before continuing to execute subsequent steps. In terms of implementation mechanism, the manual confirmation node manager maintains a state machine model for each confirmation node, including three states: waiting, passed, and rejected. When the process reaches the confirmation node, a confirmation record is created and downstream subtask scheduling is paused. Notifications are pushed to pre-configured reviewers through the platform message notification service (supporting both in-site messages and email). When the reviewer submits a "pass" result, the state transitions to passed and a review pass event is published to resume downstream scheduling. When a "reject" result is submitted, the state transitions to rejected. The manager writes the structured modification comments filled in by the reviewer (including comment text, associated deliverable identifiers, and location information) into the task context pool and publishes a review rejection event. The corresponding agent reads the modification comments, re-executes the generated task, and resubmits it for review. The confirmation record state is reset to waiting, forming a closed-loop iteration. The manager also implements a timeout reminder mechanism. When the confirmation record is in the waiting state for more than the pre-configured time threshold, an expedite notification is automatically sent. If there is still no response after the timeout, the superior reviewer can be notified according to the escalation strategy.

[0028] The multi-agent scheduling and large model platform and collaboration engine are deeply integrated with the various sub-modules of the one-stop DevOps R&D collaboration platform, such as the requirement management module, code repository management module, document management module, pipeline module, artifact repository module, code scanning module, test management module, and metric management module. The outputs of each virtual employee agent are directly written into the corresponding sub-module of the one-stop DevOps R&D collaboration platform, realizing the seamless connection between AI capabilities and the DevOps engineering system. The multi-agent scheduling and collaboration engine is deeply integrated with the various sub-modules of the one-stop DevOps R&D collaboration platform through a unified platform interface layer. The platform interface layer adopts an application programming interface design with a descriptive state transition style, exposing core interface categories such as requirement management interface (task card creation, query, status change, attachment management), code repository management interface (repository information query, branch management, file content reading and writing, commit creation, merge request management, review comments reading and writing), document management interface (document creation, version query, content reading), pipeline interface (pipeline triggering, status query, log acquisition), test management interface (batch import of test cases, execution record writing, report query), and metric management interface (metric reporting, statistical query). Each interface request must carry the caller's identity token. The platform interface layer verifies the caller's permissions through a unified identity authentication and permission verification mechanism to ensure that each agent can only access platform resources within its role's permission scope. The interface response adopts a unified data encapsulation format that includes status codes, business data, and error information. A one-stop intelligent software development method based on multi-agent systems, the steps of which are as follows: Step 1: Users (project managers, product managers, or developers) access the requirements management module through the system's web interface and create task cards; Users fill in a natural language description of their requirements in the task description field, or directly write structured prompts, clearly specifying the functional requirements, acceptance criteria, target code repository, and branches for this task. Task cards support two input modes: free text mode, where users describe their requirements in natural language; and prompt template mode, where users select a template from a pre-built prompt template library and fill in variable parameters. The system then merges the template and parameters to generate the final execution prompt. After the card is created, the user clicks the "Start Intelligent Development" button, triggering the multi-agent scheduling and collaboration engine. The prompt word template is stored as a structured data object, which includes template identifier, name, applicable task type, version number, template body (including variable placeholders), variable definition list (each variable includes name, type, whether it is required and default value) and role prompt word mapping table (defining the prompt word fragments used by each intelligent agent role). When the system renders, it iterates through the placeholders and replaces them one by one with the actual values ​​filled in by the user. Non-required variables that are not filled in use default values. The role mapping table allows the same template to provide differentiated prompt word instructions for different roles. The template supports version management, and the version number is automatically incremented each time it is modified and the history is retained. Step 2: After receiving the task, the multi-agent scheduling and collaboration engine reads the requirement description or prompt words in the card, identifies the task type and decomposes it into stages, generates an execution plan containing sub-tasks for each stage, and distributes the sub-tasks to the virtual employee agents with the corresponding roles. The system first presents the execution plan in a visual format on the task card's details page, inserting the first manual confirmation node—requirement understanding confirmation. Specifically, the system pushes a notification to the task creator via a web interface, displaying the agent's summary of the requirements and the proposed execution plan. After review, the user can select "Confirm" to continue execution, or fill in corrections on the interface and click "Reject Modification." The corrections will be fed back to the task parser and dispatcher to regenerate the execution plan. After manual confirmation, the process proceeds to the next stage. The execution plan is presented in a directed acyclic graph (DAG) visualization. Each node displays the subtask name, responsible role, and current status (pending execution, in progress, pending review, completed). Connections between nodes represent dependencies, allowing users to intuitively understand the overall task decomposition structure and expected execution order. Step 3: The product manager agent and the interaction designer agent collaborate based on the confirmed requirements description. Specifically, the product manager agent generates product solution documents, and the interaction designer agent generates interface prototypes (including page layout schemes, interaction flowcharts, visual style specifications, etc.). The architect agent simultaneously generates system architecture design documents based on the requirements description, including technology selection suggestions, module partitioning schemes, and interface definitions. These deliverables are automatically stored in the document library via the deliverable archiving and integration controller and associated as attachments to the corresponding task cards. At this point, the system inserts a second manual confirmation node—prototype and architecture scheme review: the system pushes notifications to relevant reviewers via a web interface, allowing reviewers to view the prototype and architecture design documents online and annotate their comments item by item. If the review is passed, the reviewer clicks the "Confirm" button, and the process continues; if the review fails, the reviewer fills in modification comments, and the corresponding agent automatically regenerates the deliverables based on the comments and resubmits them for review, forming a closed-loop iteration of "agent generation → manual review → feedback correction" until the review is passed. Step 4: The development engineer's intelligent agent receives the confirmed prototype solution, architecture design document, and requirements description, and calls the large language model to generate source code files that meet the requirements; The generated code is pushed to the development branch of the code repository atomically via the deliverables archive and integration controller. The commit message is automatically generated in a standard format (e.g., "[Automatic Agent Generation] Generate user registration page code based on task card #1234 requirement"). After code submission, the system automatically creates a code review form in the code hosting module and inserts a third manual confirmation node—code review confirmation: the system pushes a review notification to the designated reviewer via a web interface. The reviewer can view the code differences online and annotate their review comments line by line. If the review passes, the reviewer clicks the "Pass" button, and the process continues to the next stage; if the review fails, the reviewer's submitted review comments (each comment is stored as a structured data object, including a unique identifier, comment text, target file path, target start and end line numbers, corresponding code difference context snapshot, and comment severity level) are automatically passed to the development engineer's agent. This agent automatically modifies the code based on the review comments and resubmits it to the development branch. The review form automatically refreshes the difference view, and the reviewer reviews it again, repeating this cycle until the review passes. The specific method by which the development engineer's intelligent agent consumes review comments is as follows: It reads the complete list of unresolved review comments from the task context pool, and then combines the comment list with the original source code and difference views. Figure 1 The input context of the large language model is injected into the prompt word template. The prompt word template requires the model to output a modification plan and a complete modified code file for each comment. The modified code is added to the same development branch in an incremental manner. The submission information format is "[Agent Modification] Modified according to the review comments #{Review Form Identifier}"; Step 5: After the code review is passed, the test engineer's intelligent agent, based on the requirements description and the reviewed source code, calls the large language model to generate test case documents and automated test scripts; Test cases are automatically stored in the test management module and associated with task cards. Automated test scripts are stored in the test directory of the code repository. The system inserts a fourth manual confirmation node here—test strategy verification: the test manager reviews the coverage of test cases and the rationality of test scripts via a web interface. Once confirmed, the process continues. Subsequently, the operations engineer's intelligent agent triggers the build and deployment pipeline: the system automatically compiles, builds, and packages the code, deploys the build artifacts to the test environment, and automatically executes all automated test scripts after deployment. Test execution results are automatically written back to the test management module and task cards, and test reports are available in real-time on the web interface. Step Six: After all automated tests pass, the system inserts the fifth manual confirmation node – final acceptance confirmation. Specifically, the system pushes an acceptance notification to the project manager through the web interface. The project manager can view all deliverables associated with this task on the task card details page, including product solution documents, interaction design solutions, architecture design documents, source code submission records, test cases, test reports, etc. After the project manager confirms that the delivered quality meets the acceptance criteria, they click the "Acceptance Passed" button. The code management subsystem automatically merges the code from the development branch into the target main branch. If any automated tests fail, the system automatically sends the failure information to the test engineer agent and the development engineer agent. The agents collaboratively analyze the reasons for the failure, modify the code or test scripts, and resubmit, triggering the build, deployment, and test execution process again until all tests pass. If the review fails at any manual confirmation stage, the reviewer can fill in modification comments on the web interface. The system automatically routes the comments to the corresponding agent for correction and resubmission for review.

[0029] Steps one, two, and three complete the preliminary process from requirement input to prototype and architecture solution confirmation. Steps four, five, and six are the core processes of multi-agent collaborative execution of code development, code review, test generation, build deployment, and automated test verification. The overall working path of this invention is as follows: ① (Create task cards and input requirements) → ② (Task parsing, execution plan generation and requirement understanding confirmation) → ③ (Prototype generation, architecture design and solution review confirmation) → ④ (Code generation, automatic submission and code review confirmation) → ⑤ (Test case and script generation, test strategy verification, build deployment and automated test execution) → ⑥ (Final acceptance confirmation and code merging into the main branch).

[0030] The entire process systematically embeds five manual confirmation nodes (requirement understanding confirmation, prototype and architecture scheme review, code review confirmation, test strategy verification, and final acceptance confirmation). Users complete the review and feedback operations through the system's web interface throughout the process. Each confirmation node supports two operations: "confirmation passed" and "rejection for modification". When a modification is rejected, the manually entered modification opinions are automatically routed to the corresponding intelligent agent for correction, forming a closed-loop collaborative mechanism of "automatic execution by intelligent agent → manual review and control → feedback-driven correction". This ensures high efficiency and automation throughout the entire process while keeping the delivery quality at each stage within the range of human control.

[0031] Taking a company's self-developed one-stop DevOps collaborative development platform as an example, this platform integrates functional modules such as requirements management, code repository management, document management, pipeline, artifact repository, code scanning, test management, and metrics management. It also incorporates a multi-agent scheduling and collaboration engine and large language model capabilities to achieve intelligent end-to-end software development. The specific implementation steps are as follows: Step 1: Task Card Creation and Structured Parsing. The product manager creates a task card in the requirements management module of the DevOps platform, filling in a natural language description of the requirements in the card description field, for example: "Develop a user registration page with three input fields: username, password, and email, supporting form validation, and calling the backend registration interface after submission." The system parses the card content into a structured task object, extracting information such as functional requirements, interface elements, and interface requirements, which serve as input data for subsequent intelligent agent execution.

[0032] Step Two: Multi-Agent Task Distribution and Solution Generation. The task parser and distributor distributes structured tasks to the product manager agent, interaction designer agent, and architect agent. The product manager agent generates a product solution document based on the requirements description and calls the large language model; the interaction designer agent generates an interaction design solution (including page layout schemes, interaction flowcharts, visual style specifications, etc.); the architect agent generates a system architecture design document (including technology selection suggestions, module division schemes, and interface definitions). These deliverables are automatically stored in the document library and associated with the task card as attachments. The system sends a review notification to the relevant reviewers, initiating the manual confirmation process. Reviewers review the product solution, interaction design solution, and architecture design document on the platform interface. If approved, they click the "Confirm" button, and the process continues. If the review fails, the reviewers fill in modification comments, and the corresponding agent automatically regenerates the deliverables based on the comments and resubmits them for review.

[0033] Step 3: Code Generation and Automatic Submission. The development engineer's agent receives the confirmed prototype design and requirements description, and uses the large language model to generate source code files that meet the requirements. The generated code is pushed to the development branch of the code repository via the deliverable archiving and integration controller using an atomic submission method. The submission message is automatically generated, with an example format: "[Agent Automatic Generation] Automatically generate user registration page code based on task card #1234 requirements". After the code is submitted, the system automatically creates a code review form and notifies the reviewers, initiating the manual confirmation stage of the code review.

[0034] Step Four: Test Generation and Automated Verification. After code review and approval, the test engineer agent generates test case documents and automated test scripts based on the requirements description and source code, using the large language model. Test cases are stored in the test management module, and automated test scripts are stored in the test directory of the code repository. The system inserts a manual confirmation node for test strategy verification here: the test manager reviews the coverage of the test cases and the rationality of the test scripts through the platform interface; once confirmed, the process continues. Subsequently, the operations engineer agent triggers the build and deployment pipeline, building, packaging, and deploying the code to the test environment, automatically executing the test scripts. Test results are automatically written back to the test management module and task cards.

[0035] Step 5: Acceptance Confirmation and Code Merging. After all automated tests pass, the system notifies the project manager to conduct final acceptance. The project manager views all deliverables associated with the task card (prototype documents, source code, test cases, test reports) on the platform interface. After confirming the delivery quality, the project manager clicks "Acceptance Passed," and the code is automatically merged into the main branch. If the review fails at any stage, the reviewer can fill in modification comments on the platform. The system will then provide feedback to the corresponding agent, which will automatically modify the deliverables and resubmit them for review.

[0036] In real-world software development projects, multiple tasks often need to be performed in parallel. Processing them sequentially one by one fails to fully leverage the concurrent execution advantages of the agent. This embodiment describes a specific implementation method for multi-task parallel processing: When project managers create or select multiple task cards in batches within the requirements management module and click "Batch Start Intelligent Development," the multi-agent scheduling and collaboration engine analyzes the dependencies of all task cards. Tasks without dependencies are assigned to multiple groups of virtual employee agents for parallel execution. Each agent independently completes the prototype generation, code writing, and test generation for its respective task card. The code produced by each group is submitted to its respective development branch to avoid code conflicts during parallel development. For tasks with dependencies, the system arranges the execution order according to the dependency sequence. Subsequent tasks are started only after the preceding tasks are completed and manually confirmed. After all parallel tasks are completed, the system summarizes the execution status and test results of each task and displays the progress uniformly on the project dashboard.

[0037] Building upon Embodiments 1 and 2, this system also supports customized intelligent development processes through prompt word templates. The specific implementation is as follows: Platform administrators can pre-configure a set of prompt word templates, providing specialized prompt word templates for different types of development tasks (such as front-end page development, back-end interface development, database table design, interface documentation generation, etc.). When a user creates a task card, they can select the corresponding prompt word template. The system merges the variable placeholders in the template with the specific requirement description in the card to generate the final execution prompt word. Each virtual employee agent executes the task according to the customized prompt word, producing deliverables that better conform to enterprise technical specifications and coding standards. Furthermore, the prompt word templates support version management and continuous optimization. Teams can continuously adjust the template content based on the execution results of each task, gradually improving the quality and applicability of the agent's deliverables.

[0038] Although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art can still modify the technical solutions described in the foregoing embodiments or make equivalent substitutions for some of the technical features. 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 one-stop intelligent software development system based on multi-agent systems, comprising users, a one-stop DevOps collaborative development platform, a multi-agent scheduling and collaboration engine, and a large model platform, characterized by: The multi-agent scheduling and collaboration engine and the one-stop DevOps R&D collaboration platform include the following sub-modules: requirement management module, code repository management module, document management module, pipeline module, artifact repository module, code scanning module, test management module, and metric management module. The multi-agent scheduling and collaboration engine includes a task parser and dispatcher, a multi-role virtual employee agent pool, a large model calling adapter, a deliverable archiving and integration controller, and a manual confirmation node manager.

2. The one-stop intelligent software development system based on multi-agent technology according to claim 1, characterized in that: The requirement management module is responsible for the creation of task cards, status transitions, and structured storage of requirement descriptions; The code repository management module provides code hosting, branch management, code review creation, and structured records of review comments; The document management module is responsible for the versioned storage of deliverables documents at each stage and their association with task cards; The pipeline module is responsible for the orchestration and execution of the building, deployment, automated testing, continuous integration, and continuous delivery processes. The artifact repository module is responsible for the versioned archiving and distribution management of artifacts; the code scanning module provides static code analysis, security vulnerability detection, and coding standard inspection capabilities; the test management module is responsible for test case management, test execution records, and the summary display of test reports; and the metrics management module collects and visualizes the efficiency and quality indicators of each stage.

3. The one-stop intelligent software development system based on multi-agent technology according to claim 1, characterized in that: The requirement management module, code repository management module, document management module, pipeline module, artifact repository module, code scanning module, test management module, and measurement management module expose standardized data access capabilities to the outside world through a unified platform interface layer, providing an integrated foundation for data reading and writing for multi-agent scheduling and collaborative engines.

4. The one-stop intelligent software development system based on multi-agent technology according to claim 1, characterized in that: The platform interface layer includes, but is not limited to: the requirements management module provides interfaces for creating, querying, status transitioning, and associating attachments for task cards; the code repository management module provides interfaces for querying the repository directory tree, reading file content, creating and managing branches, creating commits, creating merge requests, and reading and writing review comments; the document management module provides interfaces for creating documents, versioned storage, and reading content; the pipeline module provides interfaces for triggering pipelines, querying execution status, and obtaining logs; and the test management module provides interfaces for batch importing test cases, writing execution records, and querying reports. All interfaces adopt a unified identity authentication and permission verification mechanism to ensure that each agent can only access platform resources within the scope of its role's permissions.

5. The one-stop intelligent software development system based on multi-agent technology according to claim 1, characterized in that: The task parser and dispatcher is used to read the structured requirement description or prompt words in the task card, identify the task type and decompose the stage, and distribute the decomposed sub-tasks to the virtual employee intelligent agents with corresponding roles.

6. The one-stop intelligent software development system based on multi-agent technology according to claim 1, characterized in that: The multi-role virtual employee intelligent agent pool includes product manager intelligent agents, architect intelligent agents, development engineer intelligent agents, test engineer intelligent agents, operations engineer intelligent agents, and interaction designer intelligent agents.

7. The one-stop intelligent software development system based on multi-agent technology according to claim 1, characterized in that: The large model call adapter connects to enterprise-privately deployed large model services or third-party large model application interfaces through a unified interface, shielding the interface differences between different large model platforms.

8. The one-stop intelligent software development system based on multi-agent technology according to claim 1, characterized in that: The deliverable archiving and integration controller is used to automatically archive the deliverables produced by each agent to the corresponding document library or task card attachment, push the generated code to the specified branch of the code repository in an atomic commit manner, automatically create code reviews and trigger the subsequent build and deployment pipeline.

9. The one-stop intelligent software development system based on multi-agent technology according to claim 1, characterized in that: The manual confirmation node manager is used to insert a manual confirmation step at key decision points in the task flow, pausing the automated process and waiting for manual review and approval before continuing to execute subsequent steps.

10. The one-stop intelligent software development method based on multi-agent systems according to claim 1, characterized in that: The method and steps are as follows: Step 1: Users access the requirements management module through the system's web interface and create task cards; Step 2: After receiving the task, the multi-agent scheduling and collaboration engine reads the requirement description or prompt words in the card, identifies the task type and decomposes it into stages, generates an execution plan containing sub-tasks for each stage, and distributes the sub-tasks to the virtual employee agents with the corresponding roles. Step 3: The product manager agent and the interaction designer agent collaborate based on the confirmed requirements description. Specifically, the product manager agent generates product solution documents, and the interaction designer agent generates interface prototypes. Step 4: The development engineer's intelligent agent receives the confirmed prototype solution, architecture design document, and requirements description, and calls the large language model to generate source code files that meet the requirements; Step 5: After the code review is passed, the test engineer's intelligent agent, based on the requirements description and the reviewed source code, calls the large language model to generate test case documents and automated test scripts; Step Six: After all automated tests pass, the system inserts the fifth manual confirmation node – final acceptance confirmation. Specifically, the system pushes an acceptance notification to the project manager through a web interface. The project manager can view all deliverables associated with this task on the task card details page, including product solution documents, interaction design solutions, architecture design documents, source code submission records, test cases, and test reports.

Images