Multi-agent coding cooperation method and system

Abstract

The invention discloses a coding collaboration method and system based on multiple agents. The method comprises the following steps: constructing a demand relation structure model containing trunk or branch nodes; establishing a code architecture characteristic information model covering six definitions of a coding structure, coding elements, coding specifications, capability service, multiplexing capability and a calling link; mapping and associating the two models on the basis of demand semantics, and generating a fusion structure information topology model which takes a function demand as a main body and takes a calling link as a DAG (Directed Acyclic Graph) dependency graph; a context information packet including a demand description, a rule subset, a code symbol set, and the like is generated and arranged by a context information processing device. According to the method, structural constraints of requirements and architectures are realized, Token resource waste is reduced, multi-agent cooperation efficiency and project development stability are improved, and the method is suitable for software development scenes of different scales and different stages.

Description

Technical Field

[0001] This invention belongs to the field of artificial intelligence technology, specifically, it relates to a multi-agent coding collaboration method and system. Background Technology

[0002] With the development of artificial intelligence technology, ambient programming and assisted programming based on natural language descriptions have been widely implemented in the software development field, and coding agents have played a significant role in improving the work efficiency of individual program developers. However, at the current stage of model capabilities and technological development, coding agents still face many challenges in large-scale project development and multi-team collaborative scenarios:

[0003] Existing applications and client development of coded agents primarily rely on prompt word control and project rule control. During multiple iterations of requirement implementation and the development of multiple client requirements, factors such as the limitation on the number of natural language interaction rounds in agent coding and the differences in client requirement descriptions easily lead to varying degrees of lack of context constraints. This further triggers a series of problems: poor code logic encapsulation and high redundancy in large-scale projects; significant differences in coding styles among different agents or developers, making uniformity difficult; weak control over architectural constraints, easily leading to deviations from the overall project architecture; and the context understanding and problem localization processes consume significant token resources, resulting in low resource utilization efficiency.

[0004] In view of this, the present invention is proposed. Summary of the Invention

[0005] To solve the above-mentioned technical problems, the basic concept of the technical solution adopted by the present invention is as follows:

[0006] A multi-agent coding cooperative method includes the following steps:

[0007] Step S1: Construct a structural model of the requirement relationship. The structural model is a requirement trunk tree, which includes trunk nodes and branch nodes. The node information covers the requirement description information, and clarifies the structural relationship between functional requirements and the main body of the project, as well as the attribution of sub-requirements.

[0008] Step S2: Establish an information model of code architecture characteristics. The information model includes definitions of coding structure, coding elements, coding specifications, capability services, reusability capabilities, and call chains.

[0009] Step S3: Based on the semantic information of the requirements, map and associate the structural model of the requirement relationship with the information model of the code architecture characteristics to construct a fusion structural information topology model with functional requirements as the main body and the call chain as a DAG dependency graph;

[0010] Step S4: Generate a context information package through the context information processing device. The context information package includes a requirement description information body, a subset of requirement rule domains, a target code symbol set, a change list, citation information fragments, and acceptance task points, and perform information orchestration.

[0011] Step S5: Based on the iteratively enhanced index feedback system, the model and index are iterated after the requirements change through client status flags and difference submissions, and server incremental updates;

[0012] Step S6: Based on the above steps, perform the collection and maintenance of the main body of the requirement information, the design and arrangement of the information fusion subset context, and the iterative update and enhancement of information maintenance to complete the collaborative coding of multi-coding intelligent agents.

[0013] As a preferred embodiment of the present invention, the construction of the structural model of the requirement relationship includes: decomposing and constructing a requirement trunk tree based on the overall project architecture and core functions, with trunk nodes containing project-level requirement descriptions; generating a trunk tree branch structure based on the decomposition of sub-requirements, with branch nodes containing the functional affiliation and implementation content description of the subdivided requirements; the structural model is used to realize the compression and integration of context package information, the expression of dependency relationships, the definition of requirement scope, and the optimization of retrieval scope.

[0014] In a preferred embodiment of the present invention, the information model of the code architecture characteristics includes: the coding structure is defined as a directory tree structure, which includes directory identifiers and requirement implementation location information; the coding elements are defined as baseline technical architecture information such as development languages, frameworks, and dependency libraries; the coding specifications are defined as unified coding styles, technical specifications, and design patterns; the capability services are defined as interactive information of modules such as service registration and access routing; the reusable capabilities are defined as reusable content of stateless logic symbols; and the call chain is defined as the decomposition of call paths and aspect annotation coverage of the modular service layer.

[0015] As a preferred embodiment of the present invention, the core process of the context information processing device includes: demand index establishment, information trimming and fusion, information compression, preprocessing symbol planning, and context information arrangement.

[0016] The core process of the context information processing device includes: demand index establishment: based on the demand backbone tree T req Building an inverted index I req , making I req (keyword)→{v r ∈V R Information trimming and fusion: using the relevance scoring function Relevance(v) r ,v c )=f(Desc(v r ), CodeDesc(v c)) Filter code nodes with high relevance > θ c The fusion is performed, where θ is the relevance threshold; keyword is the input demand-related keywords; v r This is a requirement node in the main requirement tree; v c A code node in the code architecture model; Desc(v r ) is the demand node v r Requirements description information; CodeDesc(v c Code node v c The code description information.

[0017] As a preferred embodiment of the present invention, the workflow of the iteratively enhanced index feedback system includes: the client receiving the requirement task and obtaining context information, and performing requirement change processing; after the coding agent completes the acceptance task point, the client marks the task status and extracts the change difference content, and submits it to the server; the server incrementally updates the requirement structure model, code architecture information model, and mapping index according to the original requirement description; after the coding agent completes the acceptance task point, the client marks the task status and extracts the change difference content, and submits it to the server; the server updates the requirement structure model, code architecture information model, and mapping index according to the original requirement description through the incremental update function u; wherein, the update of the mapping index follows: M t+1 (v r )=u map (M t (v r ), Δ), to ensure that the mapping relationship is synchronized with the latest code; where M t (v r ) represents the demand node v at the t-th iteration. r Corresponding mapping index; M t+1 (v r ) represents the demand node v after the t-th iteration and the 1st iteration. r Updated mapping index; u map It is the incremental update function of the mapping index, which adjusts the association between the requirement node and the code node according to the changes; Δ is the change difference content submitted by the client. The order module has added points distribution logic and called the points service interface.

[0018] In a preferred embodiment of the present invention, the multi-coding agent collaboration supports both top-down and bottom-up strategies. The top-down strategy is suitable for demand-driven initial project coding construction, while the bottom-up strategy is suitable for iterative updates of existing projects.

[0019] As a preferred embodiment of the present invention, the present invention also discloses a multi-agent coding cooperative system, comprising:

[0020] The module comprises four parts: a requirement structure modeling module for constructing a structure tree of requirement relationships, enabling requirement decomposition and boundary definition; a code architecture information modeling module for establishing a code architecture characteristic information model containing six core definitions; a mapping index construction module for generating a DAG dependency graph mapping index based on the requirement structure model and code architecture information model, which are semantically related to requirements; a context processing module for generating context information packages and performing information trimming, fusion, compression, and orchestration; an iterative feedback module for implementing client status flags, difference submissions, and server incremental updates; and a collaborative control module for scheduling the above modules to perform requirement information collection and maintenance, context orchestration, and iterative updates, enabling collaborative coding by multiple coding agents.

[0021] In a preferred embodiment of the present invention, the context information package generated by the context processing module includes an acceptance task point used to guide the coding agent to generate unit test instructions, and a citation information fragment used to map a subset of requirement rules and guide information supplementation and confirmation.

[0022] In a preferred embodiment of the present invention, the iterative feedback module supports progressive iterative enhancements for multiple changes in requirements, maintaining the effectiveness of the server-side information model and index.

[0023] As a preferred embodiment of the present invention, the collaborative control module supports switching between top-down and bottom-up implementation strategies to adapt to different project development scenarios.

[0024] Compared with the prior art, the present invention has the following advantages:

[0025] This invention achieves a structured association between requirements and architecture by constructing a requirement trunk tree (requirement relationship structure model) and a code architecture characteristic information model containing six core definitions. Compared to the loose constraints of existing technologies that rely on prompts and project rules, the fusion of structured information topology model provides unified requirement boundaries, architectural standards, and calling logic for multiple agents, effectively solving the problem of missing context constraints in multiple iterations and multi-client development, and avoiding problems such as poor code logic encapsulation, high redundancy, and deviation from the overall architecture.

[0026] The context information processing device of this invention generates a concise context information package by screening highly relevant information through processes such as demand index establishment, information trimming and fusion, and compression, which greatly reduces the invalid occupation of token resources. The iteratively enhanced index feedback system adopts an incremental update mechanism to avoid redundant operations of rebuilding the model and index after demand changes, which significantly improves resource utilization efficiency and demand response speed.

[0027] It supports two collaboration strategies: top-down (initial project building) and bottom-up (existing project iteration), which can adapt to development needs of different scales and stages. The multi-agent collaboration mode, combined with the scheduling capability of the collaboration control module, can effectively deal with complex scenarios such as team collaboration and cross-client development, solve the problem of large differences in coding styles among different agents or developers, and improve the efficiency of team development collaboration.

[0028] The iteratively enhanced index feedback system ensures that the model and index remain synchronized with the latest requirements and code after requirement changes through a closed-loop mechanism of client-side status marking, difference submission, and server-side incremental updates. This progressive iterative enhancement model enables the system to adapt to the long-term evolution of the project, avoiding the information lag problem that easily occurs in traditional coding agents during requirement iterations, and ensuring the long-term stability of project development.

[0029] The specific embodiments of the present invention will now be described in further detail with reference to the accompanying drawings. Attached Figure Description

[0030] In the attached diagram:

[0031] Figure 1 This is a diagram of a multi-agent coding collaborative system architecture.

[0032] Figure 2 This is a flowchart of a multi-agent coding collaborative method. Detailed Implementation

[0033] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions in the embodiments will be clearly and completely described below with reference to the accompanying drawings. The following embodiments are used to illustrate the present invention.

[0034] Example 1: Top-down strategy – Initial coding construction of a new e-commerce app

[0035] Application Scenario: An internet company is launching the development of a brand new e-commerce app. The requirements are clear and there is no existing code. The company needs to quickly build core functional modules with a unified architecture (user registration and login, product display, and order submission). Three coding agents are responsible for their respective modules, and the consistency of the architecture and the synergy of the functions must be ensured.

[0036] Implementation steps:

[0037] Step S1 (Requirement Structure Modeling): Based on the overall architecture and core functions of the e-commerce APP, construct the requirement trunk tree. The trunk node is the "core transaction process of the e-commerce APP", and the branch nodes are broken down into "user module (registration / login / personal center)", "product module (list / details / search)" and "order module (place order / payment / cancellation)". Each branch node clearly defines the function belonging to (e.g., "registration function" belongs to the user module) and the implementation content (mobile phone number verification, password encrypted storage).

[0038] Step S2 (Code Architecture Modeling): Establish a code architecture characteristic information model:

[0039] Encoding structure definition: directory tree structure ( / src / user / src / product / src / order), clearly defining the location of each requirement;

[0040] Encoding element definition: Development language Python, framework Django, dependency library requests / MySQLdb;

[0041] Coding standards are defined as follows: consistent PEP8 style, MVC design pattern, and RESTful API specifications.

[0042] Capability service definition: Service registration is implemented using Nacos, and access routing is implemented through Gateway;

[0043] Reusability definition: Extract stateless "data validation logic" and "log printing tool" as reuse symbols;

[0044] Call chain definition: The order module calls the "inventory query interface" of the product module and the "authentication interface" of the user module, and the aspect annotation covers the interface permission verification.

[0045] Step S3 (Mapping Index Construction): Based on the requirement semantics, map the requirement trunk tree to the code architecture model to generate a DAG dependency graph (e.g., "order placement function" depends on "inventory query" and "authentication", forming a dependency link of "order placement → inventory query → product module" and "order placement → authentication → user module").

[0046] Step S4 (Context Processing): The context information processing device generates a context information packet, which includes:

[0047] The requirement description body ("User registration should support login using mobile phone number and verification code, and password should be stored in encrypted form");

[0048] Subset of the requirement rule domain ("Password length ≥ 8 characters, containing letters and numbers");

[0049] Target code symbol set (UserModelProductServiceOrderDAO);

[0050] Acceptance task points ("Generate user registration unit test cases, covering scenarios such as incorrect mobile phone number format and insufficient password length");

[0051] Cited information fragment ("Referring to Article 3.2 of the E-commerce Security Specification, the password must be encrypted using BCrypt").

[0052] Step S5 (Iterative Feedback): During development, the product team adds a "registration bonus points" requirement. The client marks the task status as "requirement change" and extracts the differences ("adding a points distribution interface call") and submits it to the server. The server incrementally updates the requirement trunk tree (adding a "points distribution" branch node to the user module), the code architecture model (reusing the "points service" call logic), and the mapping index (adding a "points record" dependency to the order function).

[0053] Step S6 (Collaborative Coding): The collaborative control module schedules three coding agents to develop the code of each module synchronously according to a top-down strategy based on a unified context package and DAG dependency graph. The code automatically follows coding standards and call chain constraints, and finally generates an initial version of code with a unified architecture and no redundancy.

[0054] Implementation results: The coding styles of the three agents are completely consistent, with no architectural deviation issues; changes in requirements are only updated incrementally, without consuming additional token resources; the development cycle of the initial version is shortened by 40%, and the code reusability rate is increased by 35%.

[0055] Example 2: Bottom-up strategy – Iterating on existing CRM system requirements (adding customer profiling functionality)

[0056] Application scenario: An enterprise's existing Java-developed CRM system (including customer management and sales follow-up modules) needs to be iterated to add a "customer profile analysis" function (generating consumption preferences and intention level tags based on historical follow-up data). Existing code logic needs to be reused to avoid affecting the stability of the original functions.

[0057] Implementation steps:

[0058] Step S1 (Requirement Structure Modeling): Based on the existing CRM system architecture, add a branch node "Customer Profile Module" to the original main requirement tree ("Core Functions of Customer Management System"), and subdivide the sub-requirements into "Data Collection (Extracting Historical Follow-up Records)", "Tag Generation (Consumer Preferences / Intention Levels)" and "Profile Display (Visual Charts)", and clarify that the sub-requirements depend on the existing "Customer Data Query" function.

[0059] Step S2 (Code Architecture Modeling): Supplement and improve the existing code architecture information model:

[0060] Encoding structure definition: Create a new directory / src / customer / portrait, associated with the existing / src / customer / query directory;

[0061] Encoding element definition: Reuse the original Java and Spring Boot frameworks, and add new dependency libraries EasyExcel (data export) and ECharts (visualization);

[0062] Reusability definition: Directly reuse existing stateless "customer ID verification logic" and "database connection pool utility class";

[0063] Call chain definition: The profiling module calls the existing "customer follow-up record query interface", and the aspect annotation covers data permission verification (only querying customer data under the user's responsibility).

[0064] Step S3 (Mapping Index Construction): Based on the semantics of requirements, establish a mapping between the "Customer Profile Module" and the existing code architecture, and generate a DAG dependency graph ("Label Generation" depends on "Customer Follow-up Record Query" and "Data Collection" depends on "Customer Basic Information Query").

[0065] Step S4 (Context Processing): The context information package includes a change list ("Add a new customer profile module, reuse the customer query interface, and do not modify the original data table structure") and an acceptance task point ("Generate profile data accuracy test cases and compare them with the results of manual annotation").

[0066] Step S5 (Iterative Feedback): After the first iteration, the business side requested the addition of a "customer churn risk tag". The client submitted the difference ("Added churn risk algorithm call, dependent on sales follow-up frequency data"); the server incrementally updated the mapping index ("Tag generation" added a dependency on "sales follow-up frequency statistics interface"), without modifying the original customer management and sales follow-up module code.

[0067] Step S6 (Collaborative Coding): The collaborative control module adopts a bottom-up strategy, scheduling the coding agent to reuse existing code logic, focusing on the development of new functions, and automatically adapting to the original coding specifications and call chain.

[0068] Implementation results: The new features are seamlessly compatible with the original system, with no failures in the original features; 60% of the existing code logic is reused, and the iteration cycle is shortened by 50%; changes in requirements do not trigger a full code refactoring, and system stability is improved.

[0069] Example 3: Multi-client Collaboration – Cross-module Development of Enterprise-level ERP Systems

[0070] Application scenario: A group-level ERP system development project with 5 clients responsible for the finance, inventory, human resources, procurement, and production modules respectively. Cross-module data interaction is required (e.g., the finance module needs to obtain material cost data from the inventory module, and the production module needs to call the material arrival information from the procurement module). The project needs to solve the problems of inconsistent requirements from multiple clients and confusing cross-module dependencies.

[0071] Implementation steps:

[0072] Step S1 (Requirement Structure Modeling): Construct a unified requirement trunk tree, with the trunk node being the "core business process of the enterprise-level ERP system" and the branch nodes being the core requirements of the 5 modules. Clarify the cross-module dependencies (such as "financial settlement" depending on "inventory material cost" and "human resource payroll calculation" depending on "employee attendance data").

[0073] Step S2 (Code Architecture Modeling): Establish a globally unified code architecture information model:

[0074] Coding standards definition: unified microservice architecture, Java coding standards, API version control;

[0075] Capability service definition: Cross-module routing is implemented using Spring Cloud Gateway, and Consul is used for service registration and discovery;

[0076] Call chain definition: Clearly define the cross-module call path (finance module → inventory module → material cost interface), and aspect annotations cover cross-module log tracking.

[0077] Step S3 (Mapping Index Construction): Based on the semantics of requirements, generate a cross-module DAG dependency graph and mark the interface call relationships and data transmission formats of each module (e.g., the finance module needs to receive JSON format material cost data returned by the inventory module).

[0078] Step S4 (Context Processing): Generate a unique context information package for each client, which includes cross-module call rules ("Calling the inventory module interface requires token verification, and the timeout is set to 3 seconds") and citation information fragments ("Refer to Article 5.1 of the ERP Cross-Module Data Interaction Specification, data transmission must be encrypted").

[0079] Step S5 (Iterative Feedback): The inventory module client modifies the "material cost calculation logic", resulting in the addition of "cost including tax" to the interface return field; the client marks the status as "interface change" and submits the difference to the server; the server incrementally updates the mapping index and synchronously notifies clients such as finance and production that depend on this interface to automatically adapt to the field change.

[0080] Step S6 (Collaborative Coding): The collaborative control module schedules the coding agents of 5 clients, following the unified architecture specifications and cross-module dependency constraints to achieve synchronous development; when the module interface changes, it automatically triggers the adaptation and adjustment of the relevant modules to avoid cross-module call failures.

[0081] Implementation results: Differences in client requirements are resolved by a unified structural model, and cross-module dependencies are clear and traceable; interface change adaptation efficiency is improved by 70%, and there are no cross-module call failures; the overall coding style is unified, and the later maintenance cost is reduced by 50%.

[0082] II. Comparative Example

[0083] Comparative Example: Development of Traditional Encoded Agents (Relying on Prompts Combined with Item Rules)

[0084] Application scenario: Using existing technology (unstructured model, no iterative feedback mechanism), and the same three coded agents as in Example 1, develop the same initial e-commerce APP project. Only prompts are given that "it is developed using Python / Django and follows RESTful specifications", without a unified requirement structure or architecture model constraint.

[0085] Implementation process and problems:

[0086] There is no structured relationship between requirements and architecture: there is no main requirement tree, and the agent only relies on vague prompts to understand requirements, resulting in significant differences in coding styles between the user module and the order module (the user module uses the MVC pattern, and the order module uses the MVP pattern). When the order module calls the user module's interface, it throws an error due to inconsistent format.

[0087] Lack of contextual constraints: The reusability definition in the no-code architecture information model is redundant, with three agents repeatedly developing "data validation logic" and "log utility class", resulting in a code redundancy rate of 45%; some code deviates from Django framework best practices (such as hard-coding database connection information), indicating weak architectural control.

[0088] Inefficient handling of requirement changes: When adding a new "register to receive points" requirement, there is no incremental update mechanism, and the code index needs to be completely rebuilt, which consumes a large amount of token resources (60% more tokens than in Example 1). In addition, the association logic between the order module and the user module needs to be manually modified, which can easily cause the original function to malfunction.

[0089] Low resource utilization and collaboration efficiency: Without the clipping and compression function of the context information processing device, the agent needs to process a large amount of irrelevant information, and the response speed is 30% slower than that of Example 1; there is no unified scheduling for multiple agents, and manual coordination of cross-module dependencies is required, which extends the development cycle by 50%.

[0090] Table 1 shows a comparison of the core differences between the invention and the prior art.

[0091]

[0092] As can be seen from the table, this invention solves the problems of missing context constraints, code redundancy, architectural deviation, and inefficient resource utilization in the prior art by constructing a structured model, mapping index association, iterative feedback and collaborative control. It shows significant advantages in scenarios such as initial project construction, existing project iteration and multi-client collaboration.

Claims

1. A multi-agent coding cooperative method, characterized in that, Includes the following steps: Step S1: Construct a structural model of the requirement relationship. The structural model is a requirement trunk tree, which includes trunk nodes and branch nodes. The node information covers the requirement description information, and clarifies the structural relationship between functional requirements and the main body of the project, as well as the attribution of sub-requirements. Step S2: Establish an information model of code architecture characteristics. The information model includes definitions of coding structure, coding elements, coding specifications, capability services, reusability capabilities, and call chains. Step S3: Based on the semantic information of the requirements, map and associate the structural model of the requirement relationship with the information model of the code architecture characteristics to construct a fusion structural information topology model with functional requirements as the main body and the call chain as a DAG dependency graph; Step S4: Generate a context information package through the context information processing device. The context information package includes a requirement description information body, a subset of requirement rule domains, a target code symbol set, a change list, citation information fragments, and acceptance task points, and perform information orchestration. Step S5: Based on the iteratively enhanced index feedback system, the model and index are iterated after the requirements change through client status flags and difference submissions, and server incremental updates; Step S6: Based on the above steps, perform the collection and maintenance of the main body of the requirement information, the design and arrangement of the information fusion subset context, and the iterative update and enhancement of information maintenance to complete the collaborative coding of multi-coding intelligent agents.

2. The multi-agent coding and cooperative method according to claim 1, characterized in that, The construction of the structural model of the requirement relationship includes: decomposing and constructing a requirement trunk tree based on the overall project architecture and core functions, with trunk nodes containing project-level requirement descriptions; generating a trunk tree branch structure based on the decomposition of sub-requirements, with branch nodes containing the functional affiliation and implementation content description of the subdivided requirements; the structural model is used to realize the compression and integration of context package information, the expression of dependency relationships, the definition of requirement scope, and the optimization of retrieval scope.

3. The multi-agent coding and cooperative method according to claim 1, characterized in that, In the information model of the code architecture characteristics: the coding structure is defined as a directory tree structure, including directory identifiers and requirement implementation location information; the coding elements are defined as basic technical architecture information such as development language, framework, and dependency libraries; the coding specifications are defined as a unified coding style, technical specifications, and design patterns; and the capability services are defined as interactive information of modules such as service registration and access routing. Reusability is defined as the reusability of stateless logic symbols; The call chain is defined as the modular service layer's breakdown of call paths and aspect annotation coverage.

4. The multi-agent coding and cooperative method according to claim 1, characterized in that, The core processes of the context information processing device include: demand index establishment, information trimming and fusion, information compression, preprocessing symbol planning, and context information arrangement.

5. The multi-agent coding and cooperative method according to claim 1, characterized in that, The workflow of the iteratively enhanced index feedback system includes: the client receives the requirement task and obtains the context information, and performs requirement change processing; after the coding agent completes the acceptance task point, the client marks the task status and extracts the change difference content, and submits it to the server; the server compares with the original requirement description and incrementally updates the requirement structure model, code architecture information model and mapping index.

6. The multi-agent coding cooperative method according to claim 1, characterized in that, The multi-coder intelligence collaboration supports both top-down and bottom-up strategies. The top-down strategy is suitable for demand-driven initial project coding construction, while the bottom-up strategy is suitable for iterative updates of existing projects.

7. A multi-agent coding cooperative system, applied to the multi-agent coding cooperative method according to any one of claims 1-6, characterized in that, include: The requirement structure modeling module is used to construct a tree structure of requirement relationships, enabling requirement decomposition and boundary definition; the code architecture information modeling module is used to establish a code architecture characteristic information model containing six core definitions; the mapping index construction module is used to generate a DAG dependency graph mapping index based on the requirement semantic association between the requirement structure model and the code architecture information model; and the context processing module is used to generate context information packages and perform information trimming, fusion, compression, and orchestration. The iterative feedback module is used to implement client status flags, difference submissions, and server-side incremental updates. The collaborative control module is used to schedule the above modules to perform requirement information collection and maintenance, context orchestration, and iterative updates, so as to realize collaborative coding of multiple coding agents.

8. The multi-agent coding cooperative system according to claim 7, characterized in that, In the context information package generated by the context processing module, the acceptance task point is used to guide the coding agent to generate unit test instructions, and the citation information fragment is used to map the subset of requirement rules and guide information supplementation and confirmation.

9. The multi-agent coding cooperative system according to claim 7, characterized in that, The iterative feedback module supports progressive iterative enhancements for multiple requirement changes, maintaining the effectiveness of the server-side information model and index.

10. The multi-agent coding cooperative system according to claim 7, characterized in that, The collaborative control module supports switching between top-down and bottom-up implementation strategies to adapt to different project development scenarios.

Images