Multi-agent collaborative supply chain bill system automatic development method and device

Abstract

The invention provides a multi-agent collaborative supply chain bill system automatic development method and device, and the method comprises the steps: receiving a user demand document related to a to-be-developed supply chain bill system, and obtaining an enterprise specification document used for constraining development technical specifications; initializing a workflow arrangement module and a state data structure for automatically developing the supply chain bill system; wherein the workflow arrangement module comprises a directed graph, an intelligent agent is used as a node, and a circulation rule is used as an edge; and the intelligent agent processing module is used for enabling the intelligent agents to work serially and / or concurrently according to an execution path determined by the workflow arrangement module by taking the enterprise specification document as a constraint, analyzing the user demand document to obtain a design document, planning a development task according to the design document, generating review opinions by reviewing the planned development task, and sending the review opinions to the intelligent agents according to the review opinions. And generating a code file based on the design document, the development task and the review opinion, and compiling the code file to obtain an executable file related to the supply chain bill system.

Description

Technical Field

[0001] This invention relates to the field of intelligent agent software development technology, and in particular to an automated development method and apparatus for a multi-agent collaborative supply chain invoice system. Background Technology

[0002] The supply chain invoicing system is a core information system in enterprise supply chain management, used to process invoice issuance, circulation, and verification. It has the following technical characteristics: 1) Complex Business Rules: This involves multiple stakeholders (core enterprises, upstream suppliers, downstream distributors, and financial institutions providing financing) and complex processes. Relevant data includes supply chain invoices and credit information and transaction data among these stakeholders. Taking invoice issuance as an example, it requires invoice whitelist verification, invoice eligibility verification, invoice quota management, and invoice application approval. Invoice status includes: pending issuance, issued, approved, voided, and reversed, each with strict circulation rules.

[0003] 2) Long chain and multiple layers: Supply chain bills may be endorsed and transferred multiple times to different entities in the supply chain. Therefore, the cash flow and credit transfer of the entire supply chain can also be analyzed based on supply chain bills.

[0004] 3) Strict technical specifications impose high demands on code quality, requiring adherence to multiple technical standards. These specification documents are typically dozens or even hundreds of pages long, and developers must strictly follow them during the coding process. These technical specifications include, but are not limited to: ① Database design specifications: table naming rules (e.g., T_PJS_ prefix), field naming rules (uppercase + underscore), and primary key generation rules (Vesta generator). ② Data model specifications: monetary fields must use the BigDecimal type, and date fields must specify formatting rules. ③ API design specifications: HTTP method restrictions (GET / POST only), unified response format (ResponseInfo). ④ URL format specifications. ⑤ Java coding specifications: layered architecture (controller + service + mapper); transaction management annotation requirements; exception handling specifications; logging specifications. ⑥ Business rule specifications: state transition rules; operation type definitions; error code naming rules.

[0005] 4) Long development cycle and high cost. Under the traditional development model, developing a supply chain invoice function module (such as invoice whitelist management) requires 10-15 working days, including: requirements analysis: 1-2 days; system design: 2-3 days; coding implementation: 3-5 days; code review: 1 day; testing and fixing: 2-3 days; deployment and launch: 1 day.

[0006] While multi-step AI workflow solutions based on the LangGraph framework exist, they all employ coarse-grained step divisions (typically 3-5 steps, such as requirements analysis, code generation, and / or testing). This leads to each step undertaking an excessively broad scope of tasks, resulting in complex and inconsistent quality of generated content. Failure of a subtask necessitates re-executing the entire step, causing wasted time. For example, the "code generation" step might require simultaneous tasks such as database design, API design, business logic writing, and front-end page development.

[0007] While there are currently automated development methods for "AI Agents" based on single models, attempting to automate the generation, execution, and testing of code by a single AI agent according to a certain process, the boundaries of a single agent's capabilities are blurred, requiring expertise in requirements analysis, system design, coding, and testing. This makes it difficult to achieve a professional level of performance at different stages. Analogous to human development, having one person simultaneously act as architect, programmer, and test engineer inevitably leads to difficulties in guaranteeing both efficiency and quality. Summary of the Invention

[0008] In view of this, embodiments of the present invention provide an automated development method and apparatus for a multi-agent collaborative supply chain invoice system to eliminate or improve one or more defects existing in the prior art.

[0009] One aspect of the present invention provides an automated development method for a multi-agent collaborative supply chain invoice system. The method includes the following steps: receiving a user requirement document for the supply chain invoice system to be developed, and obtaining an enterprise specification document for constraining development technical specifications; initializing a workflow orchestration module and a state data structure for automated development of the supply chain invoice system; wherein the workflow orchestration module includes a directed graph, with multiple agents for front-end development and multiple agents for back-end development as nodes, and flow rules between agents as edges; the state data structure is shared among the nodes of the directed graph and serves as the basis for intelligent decision-making regarding the next execution path; constrained by the enterprise specification document, enabling agents to work serially and / or in parallel according to the execution path determined by the workflow orchestration module; parsing the user requirement document to obtain a design document; planning development tasks based on the design document; reviewing the planned development tasks to generate review opinions; generating code files based on the design document, development tasks, and review opinions; and compiling the code files to obtain an executable file for the supply chain invoice system.

[0010] In some embodiments of the present invention, the categories of the enterprise specification documents include architectural specifications, data models, business rules, API design specifications, coding specifications, database design specifications, and professional terminology; the directed graph is implemented based on the LangGraph framework, the Apache Airflow platform, the Camunda engine, or a custom finite state machine.

[0011] In some embodiments of the present invention, the step of enabling agents to work serially and / or in parallel according to the execution path determined by the workflow orchestration module includes: multiple agents for front-end development working serially, multiple agents for back-end development working serially, and multiple agents for front-end development working in parallel with multiple agents for back-end development.

[0012] In some embodiments of the present invention, the plurality of intelligent agents used for front-end development comprises seven agents, including: a design document generation agent, a design quality check agent, a task planning agent, a task planning review agent, a code writing agent, a code quality check agent, and a code submission and deployment agent; the plurality of intelligent agents used for back-end development also comprises seven agents, including: a design document generation agent, a design quality check agent, a task planning agent, a task planning review agent, a code writing agent, a code quality check agent, and a code submission and deployment agent; wherein, the design document generation agent is used to parse the user requirement document to obtain a design document, the design quality check agent is used to check the quality of the design document, the task planning agent is used to plan development tasks according to the design document, the task planning review agent is used to review the planned development tasks and generate review comments, the code writing agent is used to generate code files based on the design document, development tasks, and review comments, the code quality check agent is used to check the quality of the generated code files, and the code submission and deployment agent is used to compile the code files to obtain an executable file related to the supply chain invoice system.

[0013] In some embodiments of the present invention, the method further includes dynamically selecting a suitable AI execution engine based on the task type of the agent. An agent for handling business understanding and code generation tasks selects a first type of AI execution engine, and an agent for code manipulation tasks selects a second type of AI execution engine. The first type of AI execution engine includes the Claudecode CLI execution engine, and the second type of AI execution engine includes the Codex CLI execution engine, the Qoder CLI execution engine, the Zulu CLI execution engine, and the Cousor CLI execution engine.

[0014] In some embodiments of the present invention, a design document generation agent, a design quality inspection agent, a task planning agent, a task planning review agent, a code writing agent, and a code quality inspection agent are used to handle business understanding and code generation tasks, while a code submission and deployment agent is used to handle code operation tasks.

[0015] In some embodiments of the present invention, the state data structure includes a retry counter for counting the number of retries, and the method further includes some or all of the following adaptive retry steps: after parsing the user requirement document to obtain the design document, checking the quality of the design document, determining whether the first retry count is less than a first preset threshold; if the retry count is less than the first preset threshold and a defect in the design document is detected, then incrementing the count of the first retry count by one, and re-parsing the user requirement document to obtain the design document; after reviewing the planned development task and generating review comments, determining whether the second retry count is less than a second preset threshold; if the second retry count is less than the second preset threshold and the review comments indicate that the planned development task has a defect, then incrementing the count of the second retry count by one, and re-planning the development task according to the design document; after generating a code file based on the design document, development task, and review comments, determining whether the third retry count is less than a third preset threshold; if the third retry count is less than the third preset threshold and a defect in the code file is detected, then incrementing the count of the third retry count by one, and re-generating the code file based on the design document, development task, and review comments.

[0016] Corresponding to the above methods, the present invention also provides an automated development device for a multi-agent collaborative supply chain invoice system, including a processor, a memory, and a computer program / instructions stored in the memory. The processor is used to execute the computer program / instructions, and when the computer program / instructions are executed, the device implements the steps of any of the methods described in the above embodiments.

[0017] In accordance with the above methods, the present invention also provides a computer-readable storage medium having a computer program / instructions stored thereon, which, when executed by a processor, implements the steps of the method as described in any of the above embodiments.

[0018] Corresponding to the above methods, the present invention also provides a computer program product, including a computer program / instructions that, when executed by a processor, implement the steps of the method as described in any of the above embodiments.

[0019] The automated development method and apparatus for the supply chain invoice system proposed in this invention can combine multiple fine-grained specialized intelligent agents to divide the development process, forming two parallel development pipelines, the backend and the frontend, thereby realizing end-to-end fully automated development from requirement document input to deployable code output. Furthermore, it utilizes a directed graph-based workflow orchestration module to manage execution paths, thereby enabling efficient collaborative work among multiple intelligent agents.

[0020] Additional advantages, objects, and features of the invention will be set forth in part in the description which follows, and will also become apparent in part to those skilled in the art upon studying the description, or may be learned by practice of the invention. The objects and other advantages of the invention can be realized and obtained by means of the structures specifically pointed out in the description and drawings.

[0021] Those skilled in the art will understand that the objectives and advantages achievable with the present invention are not limited to those specifically described above, and that the above and other objectives achievable with the present invention will become clearer from the following detailed description. Attached Figure Description

[0022] The accompanying drawings, which are included to provide a further understanding of the invention and form part of this application, are not intended to limit the scope of the invention. In the drawings: Figure 1 This is a flowchart of an automated development method for a supply chain invoice system according to an embodiment of the present invention.

[0023] Figure 2 This is an architecture diagram of an automated development device for a supply chain invoice system according to one embodiment of the present invention.

[0024] Figure 3 This is a schematic diagram of a collaborative method for seven intelligent agents in the front-end / back-end of an automated supply chain invoice system development according to an embodiment of the present invention.

[0025] Figure 4 This is a schematic diagram of the computer equipment included in the system. Detailed Implementation

[0026] To make the objectives, technical solutions, and advantages of this invention clearer, the invention will be further described in detail below with reference to the embodiments and accompanying drawings. Here, the illustrative embodiments and descriptions of this invention are used to explain the invention, but are not intended to limit the invention.

[0027] It should also be noted that, in order to avoid obscuring the invention with unnecessary details, only the structures and / or processing steps closely related to the solution according to the invention are shown in the accompanying drawings, while other details that are not closely related to the invention are omitted.

[0028] It should be emphasized that the term "including / comprises" as used herein refers to the presence of a feature, element, step, or component, but does not exclude the presence or addition of one or more other features, elements, steps, or components.

[0029] It should also be noted that, unless otherwise specified, the term "connection" in this article can refer not only to a direct connection, but also to an indirect connection involving an intermediary.

[0030] In the following description, embodiments of the invention will be illustrated with reference to the accompanying drawings. In the drawings, the same reference numerals represent the same or similar parts, or the same or similar steps.

[0031] Currently, there are methods for automating software development by using the LangGraph framework to build multi-step AI workflows, and methods that attempt to automatically generate, execute, and test code for a single AI agent according to a certain process. However, handling all tasks with a single AI model and writing corresponding MCP functions, using a single CLI (Command Line Interface) execution engine, cannot select the most suitable execution engine for different types of tasks. Experiments have shown that the above two methods have limited improvement in development efficiency, typically only shortening the development cycle from 10-15 days to 5-8 days, and still requiring a large amount of manual intervention. CLI is a command-line interface, a way to interact with programs through text commands. In this invention, it refers to calling the interface of a large language model through command-line tools, such as Claude Code CLI, Codex CLI, etc.

[0032] To overcome the problems existing in the prior art, this application proposes an automated development method and apparatus for a multi-agent collaborative supply chain invoicing system. Figure 1 This is a flowchart of an automated development method for a supply chain invoice system according to an embodiment of the present invention. The method includes the following steps: Step S110: Receive user requirements documents for the supply chain invoice system to be developed, and obtain enterprise specification documents to constrain the development technical specifications.

[0033] Optionally, the aforementioned enterprise specification documents may include multiple categories, such as seven categories including architecture specifications, data models, business rules, API design specifications, coding specifications, database design specifications, and professional terminology, or other types, to meet the automation development needs in different scenarios.

[0034] Step S120: Initialize the workflow orchestration module and state data structure for the automated development of the supply chain invoice system; wherein, the workflow orchestration module includes a directed graph, with multiple agents for front-end development and multiple agents for back-end development as nodes of the directed graph, and the flow rules between agents as edges of the directed graph, and the state data structure is shared among the nodes of the directed graph, serving as the basis for intelligent decision-making on the next execution path.

[0035] In this invention, an agent acts as a node, equivalent to an "employee," representing a specific functional module. For example, the seven agents at the front end and the seven agents at the back end are equivalent to seven "employees" responsible for the front end and seven "employees" responsible for the back end, respectively. Edges represent the execution order, and complex workflow control is implemented based on the LangGraph framework. Optionally, this application can intelligently decide the next execution path based on a global state data structure. In this invention, each agent is responsible for a specific stage in the software development process, such as a requirements analysis agent, a code generation agent, and a quality inspection agent.

[0036] Optionally, the state data structure can be implemented based on Python TypeDict, defined and validated using JSONSchema, or implemented using a specific table structure in an in-memory database (such as Redis), a relational database, or even an event message body in a message queue (such as Kafka). This invention is not limited to these examples; the above are merely illustrations to achieve a structured, shared state storage device accessible to multiple agents for reading and writing.

[0037] Step S130: Using the enterprise specification document as a constraint, the intelligent agents work serially and / or in parallel according to the execution path determined by the workflow orchestration module. The user requirement document is parsed to obtain a design document. Development tasks are planned according to the design document. The planned development tasks are reviewed to generate review opinions. Code files are generated based on the design document, development tasks, and review opinions. The code files are compiled to obtain an executable file related to the supply chain invoice system.

[0038] In a professional software development lifecycle, after compiling an executable file signifies that the system's logic has initially run successfully, further steps are needed to make the developed system "usable," including testing and debugging, performance optimization, and user interface design. Furthermore, to transform a file into a software product, packaging and distribution, documentation, and the release / deployment of the system application are also necessary, allowing users to download, install, and run it, and even subsequently fixing vulnerabilities and adding new features based on user feedback.

[0039] The automated development method for the supply chain invoice system proposed in this invention can combine multiple fine-grained specialized intelligent agents to divide the development process, forming two parallel development pipelines: the backend and the frontend. This enables end-to-end automated development from requirement document input to deployable code output. Furthermore, the execution path is managed using a directed graph-based workflow orchestration module, thereby achieving efficient collaborative work among multiple intelligent agents.

[0040] In some embodiments of the present invention, the categories of the enterprise specification documents include architecture specifications, data models, business rules, API design specifications, coding specifications, database design specifications, and professional terminology.

[0041] In some embodiments of the present invention, the directed graph is implemented based on the LangGraph framework, the Apache Airflow platform, the Camunda engine, or a custom finite state machine.

[0042] Using the above embodiments of the invention, various enterprise specification documents and directed graphs that can be used to implement this solution are listed. The above content is only an example, and the invention is not limited thereto. Any alternative enterprise specification documents and workflow orchestration engines that can be easily conceived by those skilled in the art are within the technical scope of the invention.

[0043] In some embodiments of the present invention, the step of enabling agents to work serially and / or in parallel according to the execution path determined by the workflow orchestration module includes: multiple agents for front-end development working serially, multiple agents for back-end development working serially, and multiple agents for front-end development working in parallel with multiple agents for back-end development.

[0044] Optionally, in other embodiments of the present invention, parallel execution can be used for steps where there are no dependency conflicts to further improve efficiency. For example, in backend development, after generating the design document, there are also steps for a backend database design agent and a backend API design agent, and the design steps of these two agents can be executed in parallel. Similarly, the frontend and backend development pipelines can also proceed in parallel most of the time.

[0045] This invention allows for flexible configuration of serial and / or parallel execution modes based on the dependencies between front-end and back-end development steps, thereby further improving the execution efficiency of the solution. The core of this invention lies in coordinating the collaboration between various agents (whether serial or parallel) through a state-sharing mechanism, intelligently deciding the execution path for each step. Furthermore, an adaptive retry mechanism is introduced based on this intelligent decision-making to enhance error correction opportunities and avoid infinite loops. The state-sharing mechanism refers to a mechanism where multiple agents share information through a shared data structure. In this invention, a key-value dictionary is used to store the execution results of each agent, allowing subsequent agents to read the work results of previous agents. The adaptive retry mechanism refers to a mechanism that intelligently adjusts the retry strategy based on the number of task failures and the reasons for failure. In this invention, a retry counter is used: after the first failure, a retry is performed; after multiple failures, the retry is skipped and the process continues, avoiding infinite loops.

[0046] In a specific embodiment of the present invention, the multiple intelligent agents used for front-end development may be seven, including: a design document generation intelligent agent, a design quality check intelligent agent, a task planning intelligent agent, a task planning review intelligent agent, a code writing intelligent agent, a code quality check intelligent agent, and a code submission and deployment intelligent agent.

[0047] Similarly, in a specific embodiment of the present invention, the multiple intelligent agents used for backend development can be seven, including: a design document generation intelligent agent, a design quality check intelligent agent, a task planning intelligent agent, a task planning review intelligent agent, a code writing intelligent agent, a code quality check intelligent agent, and a code submission and deployment intelligent agent.

[0048] The design document generation agent parses the user requirement document to obtain a design document; the design quality check agent checks the quality of the design document; the task planning agent plans development tasks based on the design document; the task planning review agent reviews the planned development tasks and generates review comments; the code writing agent generates code files based on the design document, development tasks, and review comments; the code quality check agent checks the quality of the generated code files; and the code submission and deployment agent compiles the code files to obtain an executable file for the supply chain invoice system.

[0049] Optionally, the above-described agent division method is merely an example. For instance, the task planning agent and the task planning review agent can be merged into a single task planning and review agent, or the code writing agent can be split into a business logic writing agent and a data layer writing agent. The above fine-grained agent division methods are merely examples and do not constitute a specific limitation on the scope of protection of this application. Any agent "function" division method in the development process of a supply chain invoice system that is readily conceived by those skilled in the art falls within the technical scope of protection claimed by this invention.

[0050] This invention describes a fine-grained division of agent "functions" that can be used to implement the present solution. Compared to the conventional division of 3-5 agents in the prior art, the fine-grained division of labor among multiple agents in this application can improve the quality of automated development results. This invention is not limited thereto; any solution employing "fine-grained division of labor among multiple agents," regardless of the specific number of agents, should be considered within the scope of protection of this invention.

[0051] In some embodiments of the present invention, the method further includes dynamically selecting a suitable AI execution engine based on the task type of the agent. Agents handling business understanding and code generation tasks select a first type of AI execution engine, while agents handling code manipulation tasks select a second type of AI execution engine. The first type of AI execution engine includes the Claudecode CLI execution engine, and the second type of AI execution engine includes the Codex CLI execution engine, the Qoder CLI execution engine, the Zulu CLI execution engine, and the Cousor CLI execution engine.

[0052] In addition, in specific scenarios, the AI ​​execution engine can be replaced with a non-AI automated script execution engine.

[0053] Specifically, the business understanding and code generation tasks include: receiving prompts from the agent, invoking the Claude code CLI command-line tool, configuring execution parameters (timeout of 3000 seconds, streaming output mode), capturing the AI's streaming output in real time, parsing JSON-formatted events (such as content_block_delta), extracting incrementally generated text content, recording detailed execution logs, and invoking the claude-sonnet-4-5 large models. This execution engine is suitable for business understanding tasks that require long-term inference.

[0054] Specifically, the code manipulation tasks include: receiving command sequences from the agent, invoking the Codex CLI command-line tool, configuring execution parameters (timeout of 1800 seconds, command-line mode), executing code compilation commands (such as javac), executing unit test commands (such as junit), executing git commands (such as git add, git commit, git push), capturing command execution results (exit codes, standard output, and error output), and invoking the gpt-5 high large model. This execution engine is suitable for code manipulation tasks that require precise command execution.

[0055] By employing this embodiment of the invention, AI execution engines with different characteristics can be dynamically scheduled according to the task type, and suitable AI execution engines can be selected according to the characteristics of different tasks, thereby realizing the collaborative scheduling of heterogeneous AI execution engines and achieving the automated development of supply chain invoice systems.

[0056] In some embodiments of the present invention, a design document generation agent, a design quality inspection agent, a task planning agent, a task planning review agent, a code writing agent, and a code quality inspection agent are used to handle business understanding and code generation tasks, and a code submission and deployment agent is used to handle code operation tasks.

[0057] In some embodiments of the present invention, the state data structure includes a retry counter for counting the number of retries, and the method further includes some or all of the following adaptive retry steps: after parsing the user requirement document to obtain the design document, checking the quality of the design document, determining whether the first retry count is less than a first preset threshold; if the retry count is less than the first preset threshold and a defect in the design document is detected, then incrementing the count of the first retry count by one, and re-parsing the user requirement document to obtain the design document; after reviewing the planned development task and generating review comments, determining whether the second retry count is less than a second preset threshold; if the second retry count is less than the second preset threshold and the review comments indicate that the planned development task has a defect, then incrementing the count of the second retry count by one, and re-planning the development task according to the design document; after generating a code file based on the design document, development task, and review comments, determining whether the third retry count is less than a third preset threshold; if the third retry count is less than the third preset threshold and a defect in the code file is detected, then incrementing the count of the third retry count by one, and re-generating the code file based on the design document, development task, and review comments.

[0058] Optionally, the number of first retries, second retries, and third retries can be flexibly adjusted according to the type of defect detected. For example, if the design document has defects such as incompleteness, inconsistency, or inaccuracy, the first retries can be set to 3 for incompleteness, 5 for inconsistency, and 7 for inaccuracy. These numbers are merely examples, and the invention is not limited thereto.

[0059] By adopting this embodiment of the invention, an adaptive retry mechanism with a newly designed design is introduced to enhance error correction opportunities and avoid infinite loops based on intelligent decision-making. It intelligently decides how many times to retry and when to give up retrying, and automatically rolls back to the erroneous link to regenerate. This can significantly improve the fault tolerance and development success rate of the system and help overcome the problem of weak error recovery capability in the existing technology.

[0060] Figure 2 This is an architecture diagram of an automated development device for a supply chain invoice system according to an embodiment of the present invention. Starting from the user uploading the requirement document, the device adopts a layered architecture, divided from left to right into a web front-end, a workflow orchestration layer, an intelligent agent execution layer, and an execution engine layer.

[0061] The web front-end setup includes a front-end page that allows users to upload their requirements documents. Once the user triggers code generation, the current execution process and stage documentation can be displayed in real time. React (a JavaScript library) can be chosen as the front-end page, using HTTP and WebSocket communication to achieve real-time display.

[0062] The workflow orchestration layer can include three core modules: a multi-agent controller, a state manager, and a coordinator.

[0063] The orchestration layer (LangGraph Orchestrator) can implement multi-agent workflow scheduling according to the LangGraph framework. The core of the LangGraph framework is the StateGraph state graph, ConditionalEdge conditional edges, and RouterFunction routing functions. It supports workflow definition of directed acyclic graphs (DAG) and has dynamic routing and conditional branching capabilities.

[0064] The multi-agent controller is responsible for building and managing the workflow of 14 agents. Its implementation includes: initializing 14 agent instances, specifying a name for each agent (e.g., "backend_step1"), specifying the Prompt template path (e.g., " / prompt / backend / steps1_backend_design_document.md"), and specifying the execution engine type (agents 1-6 use the Claude code CLI execution engine, and agent 7 uses Codex). The CLI execution engine uses the LangGraph framework to build the workflow state graph. It calls the `stategraph` class to create workflow objects, calls the `add_node` method to add 14 nodes (one node per agent), calls the `add_edge` method to define the execution order between nodes (e.g., `backend_step1→backend_step2→backend_step3...`), and calls the `add_conditional_edges` method to configure conditional routing for the `backend_step6` and `frontend_step6` nodes. The routing function `route_backend_step6` is defined: it reads the `flow_check_passed` value from `backend_step6_result` from the state manager, reads `backend_step6_retry_count` to get the retry count, and decides whether to return "backend_step7" (continue) or "backend_step5" (back off) based on the two values. If backing off, it increments `retry_count` by 1. The workflow is compiled and streaming execution is started: `workflow.compile()` is called to compile the workflow, `workflow.stream(initial_state)` is called to start execution, iterates through the output of each node, and updates the state manager.

[0065] Optionally, during conditional routing, the routing decision relies on real-time reading and judgment of specific fields in the shared state (such as the check result `flow_check_passed` and the retry counter `retry_count`), and dynamically decides whether to "continue," "roll back to the specified node for retry," or "skip and mark the risk" based on the judgment result. This method further enhances fault tolerance, replacing fixed linear processes or simple count-based retries, thus effectively utilizing error correction opportunities and avoiding infinite loops. Conditional routing refers to a mechanism that dynamically determines the next execution path based on the agent's execution result; for example, if the quality check passes, it continues to the next stage; if the check fails, it rolls back to the previous stage for reprocessing.

[0066] The state manager uses Python's `typeddict` data structure to maintain the state data structure. Specifically, it defines a structured dictionary containing the following fields: global configuration fields (using `requirement_doc` to store the path to the requirement document, `project_name` to store the project name, and `branch_name` to store the Git branch name); backend agent status fields (using `backend_step1` to store the execution status, `backend_step1_result` to store the execution result of agent 1, `backend_step2` to store the execution status, `backend_step2_result` to store the execution result of agent 2, and so on); and prefix agent status fields (from `frontend_step1_status` to `frontend_step7_status`, `frontend_step1_result` to `frontend_step_...`). The `step7_result` and `frontend_step6` are retry counters; the front-end agent status fields (`frontend_step1_status` to `frontend_step7_status`, `frontend_completed_steps` stores a list of completed front-end steps, `errors` stores a list of error messages, and `logs` stores a list of log messages) are used. The key role of the state manager is to enable cross-agent information sharing: each agent reads necessary information from the state manager before execution (such as the output file path of the preceding agent), and writes the results to the state manager after execution (such as the path to the generated document, inspection results, code path, etc.). Subsequent agents can then read this information to continue their work. `TypedDict` is a typed dictionary data structure in the Python programming language, used to define dictionaries with fixed field names and data types. In this invention, `TypedDict` is used to define a data model for shared states among multiple agents.

[0067] Optionally, the State Manager maintains a globally shared state, enabling data transfer and state synchronization among multiple agents. The State Manager's functionality is implemented using a TypedDict structured state container, which includes key state fields such as `progress_tracker`, `current_step`, `retry_count`, and `specification_docs`. Furthermore, a block persistence mechanism based on the State Management module enables the saving and restoration of state snapshots, helping to ensure the continuity of workflow execution.

[0068] The coordinator is responsible for summarizing the results after all agents have completed their execution. Its implementation includes: reading `backend_step7_result` and `frontend_step7_result` from the state manager; extracting the `push_status` field to determine if the code was successfully committed to Git; counting the number of steps completed by the backend and frontend; and calculating the overall completion rate. It checks the `errors` list to obtain error information during execution. It determines `overall_success`: `overall_success` is true if and only if both `backend_push_status` and `frontend_push_status` are "success". Finally, it generates a final execution report, which includes the execution status, completion rate, error information, and subsequent suggestions for each agent.

[0069] The agent execution layer consists of 7 backend agents and 7 frontend agents. The 7 frontend agents have the same structure as the backend agents, except their specific tasks (Vue components, route configuration, API calls, etc.) are different. Let's take the 7 backend agents as an example: Agent 1 - Design Document Generation Agent: Its task is to generate backend design documents based on the requirements document. This task specifically includes seven sections: requirements analysis, system architecture design, API interface design, database design, core business process design, backend technical solution design, and external dependency service design. This agent reads the requirements document path, calls the Claude codeCLI execution engine, saves the generated design document to the specified path, and writes the path to the `backend_step1_result` field of the state manager.

[0070] Agent 2 - Design Quality Check Agent: Its task is to check whether the design document generated by Agent 1 is complete and conforms to the business and technical specifications of the supply chain invoice system. This agent reads the design document path from the state manager (backend_step1_result), loads the document content, calls the Claude code CLI to execute the engine check, generates a check report (including passed items, problematic items, and modification suggestions), and writes the check results to backend_step2_result.

[0071] Agent 3 - Task Planning Agent: The development task is a specific development task planned according to the design document, broken down into a list of executable interface development tasks. This agent reads the design document of Agent 1 and the inspection comments of Agent 2 from the state manager, calls the Claude code CLI to execute the task list, and each task includes a task ID, task description, involved interfaces, and estimated workload. The task list is then written to backend_step3_result.

[0072] Agent 4 - Task Planning and Review Agent: Its task is to review the task list generated by Agent 3 to ensure its rationality, absence of important tasks, and appropriate task granularity. This agent reads the task list from the state manager, calls the Claudecode CLI to perform the review, generates review comments, and writes the results to backend_step4_result.

[0073] Agent 5 - Code Writing Agent: Its task is to generate complete backend code based on the results of the previous four agents, including the Controller layer, Service layer, Mapper layer, entity classes, and configuration files. This agent reads the design document, task list, and review comments from the state manager, calls the Claude code CLI execution engine to generate code, saves the code file to the specified directory, and writes the code path to `backend_step5_result`.

[0074] Agent 6 - Code Quality Inspection Agent: Its task is to check whether the code generated by Agent 5 conforms to enterprise standards (database standards, API standards, and Java coding standards, etc.) and whether it contains necessary business logic (such as whitelist verification and audit logs). Agent 6 reads the code path from the state manager, loads the code file, calls the Claude code CLI to perform the inspection, generates the inspection result flow_check_passed (boolean value) and a list of violations, and writes the result to backend_step6_result.

[0075] Optionally, the code quality inspection agent can be replaced by a code quality assurance module to implement multi-level code quality checks and automatic repairs. This includes checking for syntax correctness, compliance with specifications, completeness of business logic, and database design compliance, and automatically identifying common error patterns to provide repair suggestions. Furthermore, an incremental quality improvement approach can also be adopted.

[0076] Agent 7 - Code Commit Deployment Agent: Its task is to compile code, execute tests, and commit to the Git repository. This agent reads the code path from the state manager, calls the Codex CLI to execute a series of commands (java compilation, JUnit testing, git add, git commit, git push), and writes the final commit status (success / failed) to backend_step7_result.

[0077] The execution engine (AI Engine Scheduler) comprises two heterogeneous AI execution engines: the Claude code CLI execution engine and the Codex CLI execution engine. The execution engine dynamically selects and schedules different AI engines based on task type and resource availability, and sets intelligent scheduling algorithms based on factors such as task complexity, engine load, and token configuration.

[0078] In some embodiments of the present invention, a retry mechanism module (Retry Handler) is also included to introduce an adaptive retry strategy to handle cases where the AI ​​engine fails to execute. The retry logic is as follows: an exponential backoff algorithm based on the retry_count parameter, employing differentiated retry strategies for different failure types. The exception handling method is: an integrated automatic recovery mechanism for exceptions such as token quota exhaustion, network timeout, and API rate limiting.

[0079] Furthermore, the adaptive retry decision can be a more complex policy function whose inputs include, but are not limited to, failure error type, historical success rate and task priority. The policy function's decision outputs include, but are not limited to, rolling back to the previous step, rolling back to the previous two steps, or jumping to a specific repair node.

[0080] In some embodiments of the present invention, a domain knowledge injection module is also included, which is used to dynamically inject enterprise-level specification documents and supply chain invoice business and code knowledge into the agent prompt, and select and inject context-related knowledge based on task type and execution steps.

[0081] In some embodiments of the present invention, an output controller is also included to manage and standardize the output results of 14 specialized intelligent agents, and to unify the structured output format of the output results, supporting multiple output types such as Markdown, JSON, and SQL. The output controller checks both the completeness and format compliance of the output content, as well as the consistency of the business logic.

[0082] like Figure 2As shown, the process includes the following steps: ① Receiving the user-uploaded requirement document; ② The web frontend sends the requirement document to the orchestration layer, which initializes the automated development of the supply chain invoice system; ③ The user requirement document is handed over to the agent execution layer for processing, with 7 agents in the backend jointly developing the backend and 7 agents in the frontend jointly developing the frontend; ④ Heterogeneous execution engines support the operation of agents with different task types, such as the Claude code CLI execution engine and the Codex CLI execution engine.

[0083] Figure 3 This is a schematic diagram of a collaborative method for seven intelligent agents in the front-end / back-end of an automated supply chain invoice system development according to an embodiment of the present invention.

[0084] Step S310: Design document generation intelligent agent, parse the user requirement document to obtain the design document.

[0085] The design document generation agent receives user-input requirement documents and dynamically injects relevant domain knowledge from seven types of enterprise standard documents (architecture specifications, data models, business rules, API design specifications, coding standards, database design specifications, and technical terminology). This agent performs three core tasks: functional requirement extraction, business constraint identification, and system boundary definition, storing the task processing results in a shared state data structure among the agents. Optionally, the design document generation agent can also perform requirement verification, checking against dynamically input requirements and specifications, and directly modifying any issues found.

[0086] Step S320: Design a quality inspection agent to check the quality of the design document.

[0087] Step S330: The task planning agent plans the development tasks according to the design document.

[0088] Step S340: The task planning review agent generates review comments on the development tasks of the plan.

[0089] Step S350: The code writing agent generates code files based on the design document, development tasks, and review comments.

[0090] Optionally, the task planning agent, task planning review agent, and code writing agent can be started in parallel. The task planning agent decomposes the design based on API interfaces and SQL dimensions to form individual minimum executable tasks, resulting in multiple YAML files. The task planning review agent checks the results of the task planning agent (multiple YAML files) based on the current design document, and directly modifies any discrepancies. The code writing agent processes each YAML file to implement the coding.

[0091] Step S360: The task planning agent plans development tasks according to the design document.

[0092] Step S370: The code is committed to the deployment agent, which compiles the code file to obtain the executable file for the supply chain invoice system. In this step, the agent compiles the current project code, switches branches according to the current company's Git branch requirements, pushes the branch to GitLab, and can directly deploy the current branch.

[0093] Before step S310, the supply chain invoice business requirement document input by the user is first received. The TypedDict structured state container is initialized through the workflow orchestration engine based on the LangGraph framework. The initial parameter retry_count = 0 is set in the state container. Data transfer between multiple agents is realized through the state container.

[0094] Optionally, 1 to 3 quality checkpoints can be set to perform quality checks on design documents, planned development tasks, and code files using the quality assurance module. Taking code file quality checks as an example, code style checks, business logic verification, and interface integrity checks can be performed on the backend design results. The preset retry check conditions are: if retry_count < 3 and a defect is detected, retry_count is automatically incremented and the process returns to step S350 to re-execute the backend code design; otherwise, the process continues to the next stage. This adaptive retry mechanism ensures that the backend design quality meets enterprise standards.

[0095] Similarly, for front-end design, seven additional specialized agents are activated during the front-end design phase. These seven agent nodes have similar functions to the back-end agent nodes, except that their roles are defined differently: the design agent is positioned as a front-end architect, the coding agent as a front-end engineer, and the validation agent as a senior front-end designer. The back-end API design results are included as input items in the agent input projects. A retry mechanism module can also be set up on the front end. The retry mechanism module checks the following conditions: if retry_count < 3 and a design defect is detected, retry_count is automatically incremented, and the front-end code generation step is returned to re-execute the front-end design; otherwise, the next stage is continued. This adaptive retry mechanism ensures that the front-end design quality meets enterprise standards. Optionally, front-end quality checks can also be arranged. These checks include front-end and back-end interface matching, user experience verification, and responsive layout checks. After the front-end quality checks are completed, the front-end compilation is pushed out, resulting in a complete configuration (including both back-end and front-end).

[0096] Optionally, after the front-end and back-end development is completed, the generated stage results throughout the process will be stored in a cache. The content of each stage can be integrated to finally output a complete supply chain invoice system solution, which specifically includes: back-end code: conforming to the T_PJS_ table naming convention and containing complete business logic; front-end code: responsive UI interface with a good user interaction experience; API documentation: detailed interface specification documentation to facilitate front-end and back-end integration; database scripts: containing table creation SQL and initialization data; deployment configuration: deployed by reading the specified project branch on GitLab.

[0097] In summary, the key technical points of this invention include, but are not limited to: 1) A collaborative mechanism based on multiple fine-grained specialized intelligent agents was designed to form two parallel development pipelines, the backend and the frontend. This enables a specialized division of labor similar to that of a human development team, with each agent focusing on a specific task. This division method helps to achieve end-to-end automation from input of requirements documents to output of deployable code.

[0098] The development process can be divided into 14 fine-grained specialized intelligent agents (7 for the backend and 7 for the frontend). The 7 backend agents correspond to 7 steps: design document generation, design quality inspection, interface task planning, task planning review, code writing, code quality inspection, and code submission and deployment. The 7 frontend agents also correspond to these 7 steps. Simulation experiments demonstrate that this can shorten the development cycle of the supply chain invoice function from the traditional 10–15 working days to 2–4 hours, improving efficiency by 30–50 times. Furthermore, this application uses a TypedDict structured state dictionary to achieve information sharing and decoupling among the agents. Compared to the 3–5 coarse-grained steps typically used in existing technologies, this application avoids task overload for individual agents, avoids high coupling between internal subtasks, eliminates the need for overall retries, and saves time.

[0099] Causal relationship explanation: Because each agent focuses on only a single, well-defined task (such as "design document generation" or "code quality inspection"), its specialization and execution accuracy are greatly improved. Simultaneously, the state-sharing mechanism ensures that the output of upstream agents can be seamlessly and accurately received by downstream agents, forming a "production" mode similar to an industrial assembly line. This design of specialized division of labor and parallelized processes fundamentally avoids the efficiency bottlenecks caused by mixed tasks and sequential dependencies in coarse-grained solutions.

[0100] 2) An adaptive retry mechanism is implemented at key quality check nodes (e.g., code quality checks) to set up conditional routing. This mechanism, based on `retry_count`, dynamically determines the next step based on conditional edges, intelligently deciding the next execution path according to the check results and the retry counter. This intelligent decision-making process ensures code quality while providing AI with opportunities for error correction and avoiding resource waste caused by infinite retries. It significantly improves the system's fault tolerance and development success rate, helping to overcome the weak error recovery capabilities of existing technologies.

[0101] The intelligent decision-making process includes: ① If the check passes, retry_count is reset to 0, and the code submission and deployment step begins; ② If the first failure occurs (retry_count=0), the process reverts to the code writing step to regenerate, and the retry counter is incremented by 1 (retry_count is incremented by 1); ③ If multiple failures occur (retry_count>0 or retry_count≥8, which can be flexibly set), the process continues to the code submission and deployment step, but a risk is marked for manual review. Compared to the linear process or fixed-number retry mechanism used in existing technologies, this application can intelligently handle complex generation errors without causing process interruption or infinite loops.

[0102] Causal relationship explanation: This mechanism upgrades "retry decision-making" from a fixed program logic to an intelligent process that relies on real-time state (check results) and historical context (retry_count). Specifically: when the initial check fails (retry_count=0), the system determines that the error may stem from a random bias in the AI ​​model, so it rolls back and regenerates, giving it a chance to self-correct; when multiple retries still fail (retry_count≥threshold), the system determines that there may be a deeper problem (such as conflicting requirements). At this point, it no longer blindly retryes, but marks the risk and continues the process, leaving the final decision-making power to human engineers. This state-based intelligent decision-making mechanism fully utilizes the self-correcting capabilities of AI while effectively preventing resource waste and process blockage, thus significantly improving the success rate and usability of the entire automated process while ensuring code quality.

[0103] 3) A task-driven heterogeneous AI engine scheduling mechanism is introduced, which can dynamically select the most suitable execution engine based on the task type of the agent. Using this mechanism allows for the complementary advantages of different engines, improving the adaptability between tasks and engines, and enhancing the execution quality and success rate at each stage of the development process.

[0104] For example, business understanding tasks (including design document generation, quality inspection, interface planning, task review, code writing, and code inspection) can be executed using the Claude code CLI, configured with a timeout of 3000 seconds and streaming output mode; code manipulation tasks (including code compilation, testing, and Git commits) can be executed using the Codex CLI, configured with a timeout of 1800 seconds and command-line mode. Compared to existing technologies that use a single AI model to handle all types of tasks, this approach recognizes the differences in AI capability requirements across various tasks.

[0105] Causal Relationship Explanation: This solution follows the principle of "using the right tools for the right tasks." The Claude codeCLI engine is a basic intelligent agent developed based on the Claude-Sonnet-4-5 model. It fully leverages the natural language understanding, code reasoning, and execution capabilities of the Claude-related large-scale model, far exceeding the basic capabilities of tools developed specifically for the Claude model. It is also more suitable for handling complex tasks requiring deep thinking, such as requirements analysis, architecture design, and code writing. Codex CLI, a CLI tool from the chatgpt vendor, is further integrated with its own gpt-5 model through in-depth debugging, allowing it to fully utilize the capabilities of the gpt-5 model. Due to the characteristics of the gpt-5 model and the CLI's built-in Git tools, it offers more precise command-line control and a higher success rate, making it more suitable for tasks requiring precision, such as compilation, testing, and Git operations. By dynamically scheduling the most suitable execution engine, this solution ensures that each component performs at its highest level in its strongest area, achieving complementary advantages. This heterogeneous scheduling directly leads to an increase in the success rate of each subtask, and ultimately integrates into a fundamental improvement in the overall output code quality and compliance with standards.

[0106] Corresponding to the above method, the present invention also provides an automated development device for a multi-agent collaborative supply chain invoice system. The device includes a computer device, which includes a processor and a memory. The memory stores computer instructions, and the processor is used to execute the computer instructions stored in the memory. When the computer instructions are executed by the processor, the device implements the steps of the method described above.

[0107] Figure 4 See the schematic diagram of the computer equipment included in the system. Figure 4 The computer device 00 includes: a processor 01, a memory 02, and a computer program stored on the memory 02 and executable on the processor 01. When the processor 01 executes the computer program, it implements the method steps proposed in any of the above embodiments.

[0108] The processor 01 is connected to the memory 02, such as via a bus 03. The processor 01 can be a CPU (Central Processing Unit), a general-purpose processor, a DSP (Digital Signal Processor), an ASIC (Application Specific Integrated Circuit), an FPGA (Field Programmable Gate Array), or other programmable logic devices, transistor logic devices, hardware components, or any combination thereof. It can implement or execute various exemplary logic blocks, modules, and circuits described in conjunction with the disclosure of this application. The processor 01 can also be a combination that implements computing functions, such as a combination of one or more microprocessors, a combination of a DSP and a microprocessor, etc. The bus 03 may include a pathway for transmitting information between the aforementioned components. The bus 03 can be a PCI (Peripheral Component Interconnect) bus or an EISA (Extended Industry Standard Architecture) bus, etc. The bus 03 can be divided into an address bus, a data bus, a control bus, etc. For ease of representation, Figure 4 The text uses only a single thick line to represent a bus, but this does not imply that there is only one bus or one type of bus. Memory 02 stores a computer program corresponding to the human factors data server access control method described in the above embodiments of this application. This computer program is executed under the control of processor 01. Processor 01 executes the computer program stored in memory 02 to implement the content shown in the aforementioned method embodiments.

[0109] Corresponding to the methods described above, the present invention also provides a computer-readable storage medium having a computer program / instructions stored thereon, which, when executed by a processor, implements the steps of the method as described in any of the above embodiments. The computer-readable storage medium may be a tangible storage medium, such as random access memory (RAM), main memory, read-only memory (ROM), electrically programmable ROM, electrically erasable programmable ROM, register, floppy disk, hard disk, removable storage disk, CD-ROM, or any other form of storage medium known in the art.

[0110] Corresponding to the above methods, the present invention also provides a computer program product, including a computer program / instructions that, when executed by a processor, implement the steps of the method as described in any of the above embodiments.

[0111] Those skilled in the art will understand that the exemplary components, systems, and methods described in conjunction with the embodiments disclosed herein can be implemented in hardware, software, or a combination of both. Whether implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of this invention. When implemented in hardware, it can be, for example, electronic circuits, application-specific integrated circuits (ASICs), appropriate firmware, plug-ins, function cards, etc. When implemented in software, the elements of this invention are programs or code segments used to perform the desired tasks. The programs or code segments can be stored in a machine-readable medium or transmitted over a transmission medium or communication link via data signals carried in a carrier wave.

[0112] It should be clarified that the present invention is not limited to the specific configurations and processes described above and shown in the figures. For the sake of brevity, detailed descriptions of known methods are omitted here. In the above embodiments, several specific steps are described and shown as examples. However, the method process of the present invention is not limited to the specific steps described and shown. Those skilled in the art can make various changes, modifications, and additions, or change the order of steps, after understanding the spirit of the present invention.

[0113] In this invention, features described and / or illustrated for one embodiment may be used in the same or similar manner in one or more other embodiments, and / or combined with or in place of features of other embodiments.

[0114] The above description is merely a preferred embodiment of the present invention and is not intended to limit the present invention. For those skilled in the art, various modifications and variations of the embodiments of the present invention are possible. 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 multi-agent collaborative supply chain invoice system automation development method, characterized in that, The method comprises the following steps: receiving a user requirement document related to a to-be-developed supply chain ticket system and obtaining an enterprise specification document used to constrain a development technical specification; initializing a workflow orchestration module and a state data structure for automated development of the supply chain ticket system; wherein the workflow orchestration module comprises a directed graph, a plurality of agents for front-end development and a plurality of agents for back-end development as nodes of the directed graph, and a flow transfer rule between the agents as an edge of the directed graph, and the state data structure is shared between the nodes of the directed graph as a basis for intelligent decision-making of a next execution path; under the constraint of the enterprise specification document, making the agents work in series and / or in parallel according to the execution path determined by the workflow orchestration module, analyzing the user requirement document to obtain a design document, planning a development task according to the design document, reviewing the planned development task to generate review opinions, generating a code file based on the design document, the development task and the review opinions, and compiling the code file to obtain an executable file related to the supply chain ticket system.

2. The method of claim 1, wherein, The categories of the enterprise specification document include architecture specification, data model, business rule, API design specification, coding specification, database design specification and professional term vocabulary. The directed graph is based on LangGraph framework, Apache Airflow platform, Camunda engine or custom implementation of finite state machine.

3. The method of claim 1, wherein, The step of making the agents work in series and / or in parallel according to the execution path determined by the workflow orchestration module comprises: the plurality of agents for front-end development work in series, the plurality of agents for back-end development work in series, and the plurality of agents for front-end development and the plurality of agents for back-end development work in parallel.

4. The method of claim 1, wherein, The plurality of agents for front-end development is 7, including a design document generation agent, a design quality check agent, a task planning agent, a task planning review agent, a code writing agent, a code quality check agent and a code submission and deployment agent. The plurality of agents for back-end development is 7, including a design document generation agent, a design quality check agent, a task planning agent, a task planning review agent, a code writing agent, a code quality check agent and a code submission and deployment agent. The design document generation agent is used to analyze the user requirement document to obtain a design document, the design quality check agent is used to check the quality of the design document, the task planning agent is used to plan a development task according to the design document, the task planning review agent is used to review the planned development task to generate review opinions, the code writing agent is used to generate a code file based on the design document, the development task and the review opinions, the code quality check agent is used to check the quality of the generated code file, and the code submission and deployment agent is used to compile the code file to obtain an executable file related to the supply chain ticket system.

5. The method of claim 4, wherein, The method further comprises dynamically selecting a suitable AI execution engine according to the task type of the agent, and the agent selects a first type of AI execution engine for processing the business understanding and code generation task, and selects a second type of AI execution engine for processing the code operation task. The first type of AI execution engine comprises a Claude code CLI execution engine, and the second type of AI execution engine comprises a Codex CLI execution engine, a Qoder CLI execution engine, a Zulu CLI execution engine, and a Cousor CLI execution engine.

6. The method of claim 5, wherein, The design document generation agent, the design quality inspection agent, the task planning agent, the task planning review agent, the code writing agent, and the code quality inspection agent are used for processing the business understanding and code generation task, and the code submission and deployment agent is used for processing the code operation task.

7. The method of claim 1, wherein, The state data structure comprises a retry counter for counting the number of retries, and the method further comprises the following adaptive retry steps: After the design document is obtained by parsing the user requirement document, the quality of the design document is checked, and it is determined whether the first retry count is less than a first preset threshold value. If the retry count is less than the first preset threshold value and defects are detected in the design document, the first retry count is incremented by one, and the design document is obtained by re-parsing the user requirement document; After the review opinion is generated by reviewing the planned development task, it is determined whether the second retry count is less than a second preset threshold value. If the second retry count is less than the second preset threshold value and the review opinion indicates that the planned development task has defects, the second retry count is incremented by one, and the development task is planned again based on the design document; After the code file is generated based on the design document, the development task, and the review opinion, it is determined whether the third retry count is less than a third preset threshold value. If the third retry count is less than the third preset threshold value and defects are detected in the code file, the third retry count is incremented by one, and the code file is generated again based on the design document, the development task, and the review opinion.

8. A multi-agent collaborative supply chain invoice system automation development device, comprising a processor, a memory and a computer program / instruction stored on the memory, characterized in that, The processor is configured to execute the computer program / instructions, and when the computer program / instructions are executed, the device implements the steps of the method according to any one of claims 1 to 7.

9. A computer readable storage medium having stored thereon computer programs / instructions, characterized in that, The computer program / instructions are executed by the processor to implement the steps of the method according to any one of claims 1 to 7.

10. A computer program product comprising computer programs / instructions, characterized in that, The computer program / instructions are executed by the processor to implement the steps of the method according to any one of claims 1 to 7.

Images