Industrial Software Multi-Agent Cooperative Scheduling Architecture Based on Large Language Model
By adopting a multi-agent collaborative scheduling architecture based on a large language model, the inefficiency of traditional industrial software scheduling systems in dealing with rapidly changing environments is solved, achieving efficient and intelligent scheduling and execution, and improving the system's flexibility and user experience.
Patent Information
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- SHENYANG INST OF AUTOMATION - CHINESE ACAD OF SCI
- Filing Date
- 2024-11-26
- Publication Date
- 2026-05-26
AI Technical Summary
Traditional industrial software scheduling systems struggle to cope with rapidly changing production environments and unforeseen events, exhibiting problems such as slow response times, low scheduling efficiency, and poor system scalability.
It adopts a multi-agent collaborative scheduling architecture based on a large language model, including a multi-engine unit, a management agent, a software agent agent, an APP-engine unit, and a ChainFlow tool. Through the understanding and generation capabilities of the large language model, combined with a visual drag-and-drop toolchain, it can customize execution plans and make real-time decisions.
It improves the flexibility and response speed of the scheduling system, enhances the system's intelligence and automation level, simplifies the execution process of complex tasks, and improves workflow efficiency and user satisfaction.
Smart Images
Figure CN122086533A_ABST
Abstract
Description
Technical Field
[0001] This invention belongs to the field of artificial intelligence, specifically a multi-agent collaborative scheduling architecture for industrial software based on a large language model. Background Technology
[0002] A multi-agent system (MAS) is a distributed artificial intelligence system comprising multiple autonomous agents, each of which can be considered an independent entity with specific functions. These agents can collaborate and communicate to accomplish complex tasks. The advantages of MAS lie in its distributed processing capabilities and high flexibility, enabling it to effectively cope with dynamically changing environments. MAS allows for task decomposition, parallel processing, and adaptive scheduling, thereby improving the efficiency and robustness of the entire system.
[0003] With the rapid development of artificial intelligence technology, especially the rise of Large Language Models (LLMs), more intelligent and efficient solutions have been provided. Trained on large-scale data, LLMs possess powerful language understanding and generation capabilities, enabling them to perform exceptionally well in various natural language processing tasks. In the multi-agent collaborative scheduling architecture of industrial software, introducing LLMs can significantly improve the system's intelligence level, particularly in solving complex scheduling problems and providing decision support.
[0004] In modern industrial environments, with increasingly complex and dynamic manufacturing processes, industrial software must possess high flexibility and intelligence to cope with rapidly changing market demands and production environments. Traditional single-schedule systems often struggle to meet these requirements, exhibiting problems such as slow response times, low scheduling efficiency, and poor system scalability. Therefore, the proposed multi-agent collaborative scheduling architecture for industrial software based on large language models offers an effective solution to these issues. In industrial production, scheduling systems need to handle multiple tasks, including production planning, resource allocation, task assignment, and schedule control. Traditional scheduling systems, typically based on fixed rules and algorithms, struggle to cope with unexpected events and environmental changes. For example, equipment failures, raw material shortages, and temporary order changes pose significant challenges to scheduling systems. Therefore, constructing a multi-agent collaborative scheduling architecture based on a large language model can improve the flexibility, response speed, automation, and intelligence of the scheduling system through collaborative work and real-time decision-making among multiple agents, as well as the understanding and optimization capabilities of the large language model. Summary of the Invention
[0005] To address the aforementioned technical problems, this invention provides a multi-agent collaborative scheduling architecture for industrial software based on a large language model and its implementation method.
[0006] This invention adopts the following technical solution: a multi-agent collaborative scheduling architecture for industrial software based on a large language model, comprising:
[0007] The Multi-Engine unit is used to directly generate an execution plan based on user input and the software capabilities of the agent, and then send it to the APP-Engine unit; it includes:
[0008] The User Agent is used to receive user input information and issue tasks that require software execution; it stores the execution plan sent by the Decision Agent into the case library and updates the AIAS description file of the case.
[0009] The management agent is used to automatically query and understand the software capabilities of the software agent based on the task execution requirements, and search for cases in the case library that match the execution requirements. If a case that matches the execution requirements is found, the case in the case library is reconstructed based on the understanding of the task and the software capabilities of the software agent to generate an execution plan. If no case that matches the execution requirements is found, the execution plan is generated directly based on its own understanding of the task.
[0010] A software agent is a software or program used to perform some or all of the tasks.
[0011] The APP-Engine unit is used to operate according to the execution plan; it includes:
[0012] The decision agent is used to understand the execution plan, determine the task sequence, and then hand it over to the execution agent for operation; when the user confirms that the overall task has been completed, it feeds back the execution plan of the current task to the Multi-Engine unit.
[0013] The execution agent is used to identify task steps and perform operations according to the task steps; after each operation is completed, feedback is given to the decision agent, which then decides on the next action or completes the operation.
[0014] The industrial software multi-agent collaborative scheduling architecture based on a large language model also includes ChainFlow, which is used to customize toolchains through visual drag-and-drop. Execution nodes are LLM nodes, RAG nodes, third-party tool nodes, or condition judgments can be made by dragging and dropping branch nodes. All tool nodes and the toolchain nodes they form are described by AIAS description files. The ChainFlow instances composed of various tools constitute a case library.
[0015] The cases and software capabilities in the case library are represented by AIAS description files; these AIAS description files describe the API and UI capabilities of industrial software; prompt words are output to an external large language model in the form of self-prompt and self-RAG; including:
[0016] Since Prompt, it is used to convert the content of the XML description into a prompt word that explains its own function;
[0017] The self-RAG function is used to store the description content as word vectors in a vector database. When an external query is triggered, the relevance is retrieved from the vector database and suggestions are generated and output.
[0018] The implementation method of multi-agent collaborative scheduling architecture for industrial software based on large language models includes the following steps:
[0019] 1) In the Multi-Engine unit, the user agent receives user input information and issues tasks that require software execution.
[0020] 2) The management agent automatically queries and understands the software capabilities of the software agent, and searches the case library for cases that match the execution requirements;
[0021] If a case that matches the execution requirements is found, the cases in the case library are reconstructed based on the understanding of the task and the software capabilities of the software agent to generate an execution plan.
[0022] If no case matching the execution requirements is found, an execution plan is generated directly based on the user's understanding of the task.
[0023] 3) In the APP-Engine unit, the decision agent understands the execution plan, determines the task sequence, and then hands it over to the execution agent for operation;
[0024] The Agent performs the identification task steps and operates according to the execution plan; after each step is completed, feedback is given to the decision Agent, which then decides on the next action or completes the task.
[0025] 4) When the decision agent receives confirmation from the user that the overall task has been completed, it feeds back the execution plan of the current task to the Multi-Engine unit, which then stores it in the case library and updates the AIAS description file of the case.
[0026] If no case matching the execution requirements is found, the system will match the capabilities of its internal AI tools based on its understanding of the task, and directly generate an execution plan using the matched AI tools.
[0027] In step 3), during the operation according to the execution plan, for the set execution nodes, the decision agent invites the user to intervene to confirm or perform manual operation; after all execution plans are completed by the APP-Engine, feedback is sent to the Multi-Engine's user agent for confirmation with the user.
[0028] The step of accumulating the execution plan of the current task into the case library is as follows: the AIAS of the case is stored in VectorDB in the form of embedding, so as to facilitate the reuse of the case in the future.
[0029] The software capabilities include API capabilities, UI capabilities, and internal AI tool capabilities.
[0030] The cases and software capabilities in the case library are represented by AIAS description files; these AIAS description files describe the API and UI capabilities of industrial software; prompt words are output to an external large language model in the form of self-prompt and self-RAG; including:
[0031] Since Prompt, it is used to convert the content of the XML description into a prompt word that explains its own function;
[0032] The self-RAG function is used to store the description content as word vectors in a vector database. When an external query is triggered, the relevance is retrieved from the vector database and suggestions are generated and output.
[0033] A computer-readable storage medium storing a computer program, which, when executed by a processor, implements the aforementioned method for implementing a multi-agent collaborative scheduling architecture for industrial software based on a large language model.
[0034] The beneficial effects and advantages of this invention are as follows:
[0035] 1. This invention utilizes an interactive multi-agent approach to fully leverage the understanding and design capabilities of a large language model, helping users plan the scheduling processes of industrial software themselves. Furthermore, the interactive nature of the process enhances its fault tolerance, allowing users to correct and guide the behavior of the large language model during execution.
[0036] 2. This invention develops AI applications through workflow construction and allows the developed applications to be nested and called as custom tools. This makes the application scenarios of large language models closer to end users and makes it easier to build custom knowledge bases, chatbots, analysis assistants, etc.
[0037] 3. This invention describes the capabilities of software itself through the creation of AIAS, and possesses self-prompt and self-RAG capabilities. This enables large language models to quickly understand the capabilities of industrial software or tools and form long-term memory for the agent.
[0038] 4. This invention constructs an internal scheduling module based on a multi-agent mechanism, and introduces an OCR parsing module and a WEB parsing module to more easily understand the current progress and execution steps of the software, providing a large language model for further decision-making.
[0039] 5. This invention simplifies the process of collaborative scheduling of multiple industrial software programs, helping users complete complex execution requirements through basic prompts and simple operation instructions. Attached Figure Description
[0040] Figure 1 This is an architecture diagram of a multi-agent collaborative scheduling architecture for industrial software based on a large language model.
[0041] Figure 2 This is a basic structural diagram of AIAS.
[0042] Figure 3 This is a diagram illustrating the execution principle of APP-Engine.
[0043] Figure 4 This is a diagram showing the interaction structure between Multi-Engine and ChainFlow.
[0044] Figure 5 This is a diagram showing the structural relationship between ChainFlow and AIAS.
[0045] Figure 6 This is a conceptual diagram of the planning for AI tools within industrial software.
[0046] Figure 7 This is a diagram illustrating the software execution process optimized by AI tools.
[0047] Figure 8 This is a case study of industrial software transformation.
[0048] Figure 9 This is a diagram of a multi-industry software collaboration scenario. Detailed Implementation
[0049] The present invention will now be described in detail with reference to the accompanying drawings.
[0050] like Figure 1The diagram illustrates the specific working logic of each module in this invention and the interaction information and methods between modules. This invention is mainly divided into three system modules: ChainFlow, APP-Engine, and Multi-Engine.
[0051] ChainFlow is a visual development tool for LangChain, providing a basic runtime environment including a large language model (LLM), a vector database (VectorDB), and related development tools such as RAG-enhanced knowledge retrieval. ChainFlow also supports calling other third-party tools via HTTP interfaces, such as Google online search tools and numerical analysis tools. A key feature of ChainFlow is its ability to customize toolchain execution flows through visual drag-and-drop functionality, similar to workflow creation in an OA system. Specific execution nodes include LLM nodes, RAG nodes, and third-party tool nodes. Branch nodes can also be dragged and dropped for conditional checks. All tool nodes and their associated toolchain nodes can be described using AIAS (AIAS will be explained later). Furthermore, ChainFlow includes an AIAS parser for parsing external AIAS description files, allowing the described content to be dragged and dropped as nodes within ChainFlow.
[0052] APP-Engine is an intelligent multi-agent engine for encapsulating industrial software. Its function is to understand the capabilities of the encapsulated industrial software and, based on external operational requirements, call the software's own interfaces to complete corresponding business execution. First, the API backend interfaces and UI frontend functions of the industrial software need to be abstracted and described using AIAS description files. ChainFlow tools can be used to construct these capability descriptions. AIAS itself is not just a description file; it also possesses self-prompt and self-RAG capabilities. By converting the description file into prompt words or word vectors, its capabilities can be understood by a large language model or more easily stored and retrieved. Supported by the large language model, the decision agent understands external operational requirements and drives the execution agent to perform specific software operations. The execution unit receives commands from the execution agent and drives the OCR parsing module or WEB parsing model to call specific APIs or UIs to achieve the final execution goal. Furthermore, ChainFlow can assist in building AI tools within industrial software and can also serve as an API for the decision agent to perform decision-making and planning.
[0053] Multi-Engine is a multi-agent intelligent decision-making engine. Its function is to formulate specific software scheduling and execution plans through collaborative interaction among multiple agents, and then issue these plans to multiple APP-Engines to fulfill the user's final requirements. Multi-Engine includes basic user agents, management agents, testing agents, and software agent agents. The user agent communicates requirements with end-users, the management agent plans the execution plan, the testing agent verifies the feasibility of the plan, and the software agent agent schedules the corresponding industrial software to complete the task. Multi-Engine also features a case library, which is essentially a toolchain described by AIAS. The nodes of this toolchain are not composed of basic ChainFlow tool nodes, but rather of software API nodes, UI nodes, or internal AI tool nodes from the APP-Engine. It includes scenario examples of software tool combinations for large language models to learn from and reference. Furthermore, Multi-Engine has multi-window scheduling management and user interaction management functions. Multi-window scheduling management is used to switch between different industrial software to execute specific tasks, while user interaction management is used to input user modifications and execution requirements at key execution nodes.
[0054] like Figure 2 The diagram illustrates the basic working principle of AIAS. AIAS, short for Artificial Intelligence AdminShell, is used to describe the capabilities and interfaces of tools / artificial intelligence units, with a file format similar to XML. The right side of the diagram shows a simple example of a description of the API and interface capabilities of industrial software. AIAS is expressive of its descriptions, providing prompts to an external large language model through self-prompt and self-RAG functions. The self-prompt function converts the XML description into prompts explaining its own function, allowing the large language model to fully understand the capabilities of the described target unit. The self-RAG function stores the description as word vectors in a vector database. When an external query is triggered, it retrieves relevance from the vector database, generates prompts, and outputs them to the large model. The self-RAG function acts like long-term memory, preventing the large language model from forgetting it over multiple rounds of dialogue. AIAS not only describes the capabilities of individual tools but also transforms these descriptions into shareable knowledge for the large language model to learn from and reference. This knowledge sharing and reuse mechanism reduces repetitive work and improves overall efficiency.
[0055] like Figure 3The diagram illustrates the decision-making and scheduling mechanism within the APP-Engine. The API and UI capabilities of the industrial software are described by AIAS and can be understood by the decision agent. After the decision agent determines the next software function to execute, it drives the execution agent to call the software function. Inside the execution unit, the unit selects different parsing modules based on the type of industrial software. For C / S architecture systems, the OCR parsing module is selected, capturing the software interface and recognizing the text content to select function menus and execution buttons. For B / S architecture systems, the specific menus and execution buttons are selected by recognizing the corresponding DOM elements in the browser. This process calls the API or UI functions, completing the software function execution required by the decision agent.
[0056] like Figure 4 The diagram illustrates the working principles of Multi-Engine and ChainFlow. Multi-Engine receives user software requirements, while the management agent generates an execution plan by referencing the internal case library and the execution capabilities of the software agent. The case library, composed of various tools, is a ChainFlow instance that can be defined through drag-and-drop interaction via the software interface. The case library is initially predefined by software developers and business users, providing the large model with prior knowledge. AIAS's self-prompt and self-RAG capabilities enable the large model to form long-term memory. Successful cases that have been adjusted by the user are also added to the case library, continuously optimizing the large model's understanding capabilities.
[0057] like Figure 5 The diagram illustrates the working principle of ChainFlow and AIAS. Objects that can be described by AIAS include the case library in the Multi-Engine and the APIs, UI capabilities, and internal AI tools in the APP-Engine. Through AIAS's self-prompt and self-RAG capabilities, it can be understood by large language models; this is the scenario of automatic recognition. For scenarios requiring manual invocation, ChainFlow needs to be able to create toolchains manually through drag-and-drop. Therefore, ChainFlow needs to have the ability to parse and recognize AIAS, identifying it as a draggable element within ChainFlow. This allows for repeated encapsulation and nested invocation, enabling existing AI tools to continue to function in larger scenarios.
[0058] like Figure 6The diagram illustrates the conceptual design for internal AI tools in industrial software. ChainFlow can be used to build internal AI tools in commonly used industrial software. For data acquisition software, tools such as ChatBot, ChatDB, AI data formatting, and AI data analysis can be built; for simulation software, tools such as ChatBot, AI-assisted mapping for digital twin interfaces, simulation process recommendation, and AI report generation can be built; for knowledge graph analysis software, tools such as ChatBot, AI knowledge extraction, AI entity relationship fusion, and AI question answering can be built; for algorithm training platforms, tools such as ChatBot, AI operator recommendation, AI parameter recommendation, and AI result visualization evaluation can be built; for 3D design software, tools such as ChatBot, Wensheng 3D rapid verification, design parameter recommendation, and assembly assembly recommendation can be built; and for electrical programming software, tools such as ChatBot, automatic code generation, solution recommendation, rapid retrieval, and standardized question answering can be built.
[0059] like Figure 7 The diagram illustrates the optimized software execution process using AI tools. In traditional workflows, fulfilling the needs of a production line requires the collaborative work of 3D design software, simulation software, and programming software to generate design documents, cycle times, interference checks, PLC programs, and robot trajectories. The portion within the red box represents the manual intervention, which incurs significant labor costs. In the intelligent agent workflow, with the support of internal AI tools, most tasks can be completed by the intelligent agent scheduling AI tools, improving execution efficiency and accuracy.
[0060] like Figure 8 The image shows a case study of industrial software transformation. Taking data acquisition software as an example, the preparation phase requires standardization of the software's internal components. This involves clarifying the descriptions of the API, UI, and internal AI tools. ChainFlow can be used to design and describe these capabilities, achieving a unified expression of AIAS. The execution phase involves the following steps: (in...) Figure 8 In the diagram, nodes marked with a finger are manually operated nodes, while nodes marked with a circular "A" are automatically operated nodes.
[0061] Step 1: Taking data acquisition as an example, using Multi-Engine as the entry point, users can issue software execution requirements to the Multi-Engine user agent through dialog boxes or voice input, such as "Acquire data from the device with IP address 192.168.1.103, driven by Modbus, with acquisition points including <temperature, address space 302>..." etc.
[0062] Step 2: The Multi-Engine's management agent will automatically query and understand the data collection agent (analogous to...). Figure 1 The software capabilities of "App1 Agent" (analogous to...) Figure 1 The API / UI capabilities or internal AI tools of "App1's APP-Engine" are used to manage the agent, which searches for relevant cases in the case library. If a similar case is found, the agent may reconstruct the case in the library based on the large model's understanding of the task, combined with the capabilities of the data acquisition software, to generate an execution plan. If no similar case is found, the large model directly generates an execution plan based on its own understanding of the task. For example, the management agent might find a case in the case library involving data collection from a Modbus device. While the data acquisition software can fulfill the requirements initially, an internal AI tool might be discovered that can replace some of the previous data entry work, improving efficiency. In this case, the case can be reconstructed to generate an execution plan. Finally, the test agent verifies the execution plan to ensure its feasibility. If any issues are found, they are reported to the management agent for iterative modifications.
[0063] Step 3: After the execution plan is generated, the user agent interacts with the user, who can then intervene to modify and confirm it.
[0064] Step 4: The Data Acquisition App-Engine acts as the executor of the execution plan. Internally, the decision agent understands the execution plan, determines the opened page and input content, and then hands it over to the execution agent for further processing. The execution agent uses a visual module to recognize the software's page and then performs operations such as input, selection, and clicking. After each step, feedback is sent to the decision agent, which then decides on the next action or completes the execution. At critical execution nodes, such as deletion operations, the decision agent invites user intervention for confirmation or manual operation. Once the Data Acquisition App-Engine has completed all execution plans, feedback is sent to the Multi-Engine's user agent for user confirmation.
[0065] Step 5: The user confirms the overall task execution is complete. If the execution plan is correct, the decision agent feeds back to the Multi-Engine unit, where the user agent adds it to the case library and updates the AIAS description file of the case. The AIAS of the case is stored in VectorDB in the form of embeddings, becoming a long-term memory for the management agent, facilitating subsequent case reuse.
[0066] like Figure 9The diagram illustrates a scenario of multiple industrial software programs working collaboratively. In such a scenario, if 3D design software is first used to automatically design industrial parts, then simulation software performs assembly and mechanical motion simulations, and finally, programming software generates the electrical control program, then the generation of the execution plan and the specific scheduling process are related to… Figure 8 The execution flow shown in the example is similar, except that the execution flow of a single software is changed into an execution flow in which multiple software programs call each other alternately.
[0067] This invention integrates the powerful language understanding and generation capabilities of a large language model with the interaction mechanism of a multi-agent system, enabling the system to understand user needs more deeply and provide a more accurate and user-friendly interactive experience. Users can communicate with the system through natural language, making the execution of complex tasks intuitive and easy to manage. The multi-agent system can process multiple tasks in parallel, intelligently allocate resources and schedule execution plans, and efficiently complete complex workflows, especially when coordinating multiple industrial software and tools, demonstrating better management and execution capabilities. During execution, if errors or unexpected results are encountered, the multi-agent system can adjust its strategy in a timely manner, and the large language model can provide correction suggestions, enabling the system to have self-correcting capabilities and accept real-time user feedback to dynamically adjust its behavior. The Multi-Engine module, combined with the reasoning capabilities of the large language model, can not only adapt to various customized needs but also continuously optimize processes based on execution results, achieving self-learning and evolution. The multi-window scheduling management and user interaction management functions in Multi-Engine ensure efficient switching between different software and tasks, while promoting collaborative work between users and the system, improving work efficiency and user satisfaction. ChainFlow boasts excellent compatibility and scalability due to its support for third-party tool calls and AIAS description file parsing. It can integrate various existing tools and software, continuously expanding its functionality and application scope.
[0068] The above description represents the preferred embodiments of the present invention. It should be noted that those skilled in the art can make various improvements and modifications without departing from the principles of the present invention, and these improvements and modifications should be considered within the scope of protection of the present invention.
Claims
1. A multi-agent collaborative scheduling architecture for industrial software based on a large language model, characterized in that, include: The Multi-Engine unit is used to directly generate an execution plan based on user input and the software capabilities of the agent, and then send it to the APP-Engine unit; it includes: The User Agent is used to receive user input information and issue tasks that require software execution; it stores the execution plan sent by the Decision Agent into the case library and updates the AIAS description file of the case. The management agent is used to automatically query and understand the software capabilities of the software agent based on the task execution requirements, and search for cases in the case library that match the execution requirements. If a case that matches the execution requirements is found, the case in the case library is reconstructed based on the understanding of the task and the software capabilities of the software agent to generate an execution plan. If no case that matches the execution requirements is found, the execution plan is generated directly based on its own understanding of the task. A software agent is a software or program used to perform some or all of the tasks. The APP-Engine unit is used to operate according to the execution plan; it includes: The decision agent is used to understand the execution plan, determine the task sequence, and then hand it over to the execution agent for operation; when the user confirms that the overall task has been completed, it feeds back the execution plan of the current task to the Multi-Engine unit. The execution agent is used to identify task steps and perform operations according to the task steps; after each operation is completed, feedback is given to the decision agent, which then decides on the next action or completes the operation.
2. The industrial software multi-agent collaborative scheduling architecture based on a large language model according to claim 1, characterized in that, It also includes ChainFlow, which is used to customize toolchains through visual drag-and-drop. Execution nodes are LLM nodes, RAG nodes, third-party tool nodes, or conditional judgments can be made by dragging and dropping branch nodes. All tool nodes and the toolchain nodes they form are described by AIAS description files. The case library is composed of ChainFlow instances composed of various tools.
3. The method for implementing a multi-agent collaborative scheduling architecture for industrial software based on a large language model according to claim 1, characterized in that, The cases and software capabilities in the case library are represented by AIAS description files; the AIAS description files are used to describe the API and UI capabilities of industrial software; prompt words are output to external large language models in the form of self-prompt and self-RAG; include: Since Prompt, it is used to convert the content of the XML description into a prompt word that explains its own function; The self-RAG function is used to store the description content as word vectors in a vector database. When an external query is triggered, the relevance is retrieved from the vector database and suggestions are generated and output.
4. A method for implementing a multi-agent collaborative scheduling architecture for industrial software based on a large language model, characterized in that, Includes the following steps: 1) In the Multi-Engine unit, the user agent receives user input information and issues tasks that require software execution. 2) The management agent automatically queries and understands the software capabilities of the software agent, and searches the case library for cases that match the execution requirements; If a case that matches the execution requirements is found, the cases in the case library are reconstructed based on the understanding of the task and the software capabilities of the software agent to generate an execution plan. If no case matching the execution requirements is found, an execution plan is generated directly based on the user's understanding of the task. 3) In the APP-Engine unit, the decision agent understands the execution plan, determines the task sequence, and then hands it over to the execution agent for operation; The Agent performs the identification task steps and operates according to the execution plan; after each step is completed, feedback is given to the decision Agent, which then decides on the next action or completes the task. 4) When the decision agent receives confirmation from the user that the overall task has been completed, it feeds back the execution plan of the current task to the Multi-Engine unit, which then stores it in the case library and updates the AIAS description file of the case.
5. The method for implementing a multi-agent collaborative scheduling architecture for industrial software based on a large language model according to claim 4, characterized in that, If no case matching the execution requirements is found, the system will match the capabilities of its internal AI tools based on its understanding of the task, and directly generate an execution plan using the matched AI tools.
6. The method for implementing a multi-agent collaborative scheduling architecture for industrial software based on a large language model according to claim 4, characterized in that, In step 3), during the operation according to the execution plan, for the set execution nodes, the decision agent invites the user to intervene to confirm or perform manual operation; after all execution plans are completed by the APP-Engine, feedback is sent to the Multi-Engine's user agent for confirmation with the user.
7. The method for implementing a multi-agent collaborative scheduling architecture for industrial software based on a large language model according to claim 4, characterized in that, The step of accumulating the execution plan of the current task into the case library is as follows: the AIAS of the case is stored in VectorDB in the form of embedding, so as to facilitate the reuse of the case in the future.
8. The method for implementing a multi-agent collaborative scheduling architecture for industrial software based on a large language model according to claim 4, characterized in that, The software capabilities include API capabilities, UI capabilities, and internal AI tool capabilities.
9. The method for implementing a multi-agent collaborative scheduling architecture for industrial software based on a large language model according to claim 4 or 8, characterized in that, The cases and software capabilities in the case library are represented by AIAS description files; the AIAS description files are used to describe the API and UI capabilities of industrial software; prompt words are output to external large language models in the form of self-prompt and self-RAG; include: Since Prompt, it is used to convert the content of the XML description into a prompt word that explains its own function; The self-RAG function is used to store the description content as word vectors in a vector database. When an external query is triggered, the relevance is retrieved from the vector database and suggestions are generated and output.
10. A computer-readable storage medium, characterized in that, The storage medium stores a computer program, which, when executed by a processor, implements the method for implementing a multi-agent collaborative scheduling architecture for industrial software based on a large language model as described in any one of claims 4-9.