Browser-based human-computer collaborative multi-agent graphical programming system and method

Abstract

This invention specifically relates to a browser-based human-computer collaborative multi-agent graphical programming system and method, belonging to the field of intelligent programming technology. It includes: acquiring input information submitted by a user through a browser interface; classifying the input information into non-deterministic and deterministic inputs based on their type; performing intent recognition and semantic parsing on the non-deterministic inputs; performing direct mapping on the deterministic inputs; and generating a unified format token stream. In this invention, the task planning module Planner hierarchically decomposes the task objective into a set of subtasks labeled with dependencies, and converts it into a directed acyclic graph for topological sorting. This solves the technical problem of the difficulty in automatically and orderly scheduling complex industrial programming tasks, achieving the technical effect of supporting dependency-driven ordered execution and concurrent scheduling of dependency-free subtasks.

Description

Technical Field

[0001] This invention relates to the field of intelligent programming technology, and in particular to a browser-based human-computer collaborative multi-agent graphical programming system and method. Background Technology

[0002] In the field of industrial automation, PLC control logic programming and industrial graphical programming tasks have long relied on manual completion by professional engineers. Engineers need to install dedicated client software locally, write control logic and configure equipment parameters one by one according to process requirements, and manually verify the generated results. This process requires a high level of professional skills, is inconvenient for cross-location collaborative operation, and makes it difficult to reuse historical programming experience across different projects.

[0003] With the development of large language model technology, exploratory solutions for introducing artificial intelligence into programming assistance have emerged. However, existing solutions generally suffer from the following shortcomings: First, the task planning capabilities of intelligent agents are limited, making it difficult to automatically decompose and orderly schedule subtasks when faced with complex industrial programming tasks containing multiple functional units. Second, the execution process of intelligent agents is isolated from human operation, preventing users from intervening and correcting intermediate results generated by the agents in real time on the same interface, resulting in the accuracy of the final deliverables depending on multiple rounds of repeated submissions. In addition, existing solutions lack automated quality verification processes oriented towards industrial standards, and whether the generated results meet industrial specifications such as IEC61131-3 still requires manual verification.

[0004] Therefore, existing graphical programming methods are insufficient in supporting the automatic breakdown and scheduling of complex tasks, real-time human-machine collaborative interaction, and industrial standard quality verification, and urgently need improvement. Summary of the Invention

[0005] The purpose of this invention is to provide a browser-based human-computer collaborative multi-agent graphical programming system and method to solve the above-mentioned problems.

[0006] To achieve the above objectives, the present invention adopts the following technical solution: Browser-based human-computer collaborative multi-agent graphical programming methods include: The system acquires input information submitted by users through the browser interface, categorizes the input information into non-deterministic and deterministic inputs based on their type, performs intent recognition and semantic parsing on non-deterministic inputs, performs direct mapping on deterministic inputs, and generates a token stream in a unified format. The Token stream is input into the task planning module, which hierarchically decomposes the task objectives carried by the Token stream, identifies multiple subtasks and the dependencies between subtasks, and generates a set of subtasks with dependency annotations. Based on the dependencies between the subtasks in the subtask set, the subtask set is converted into a directed acyclic graph, and a topological sort is performed on the directed acyclic graph to generate an execution scheduling sequence. According to the execution scheduling sequence, each subtask node is processed in a closed loop of thinking, action, and observation. In the thinking phase, an action plan is generated through a large language model. In the action phase, the action plan is executed by calling the toolset in the browser sandbox environment through the function call interface. The sandbox environment is either WebAssembly or a Docker container. In the observation phase, the execution results are compared and verified with the expected output. After all subtask nodes have been processed, the execution results of each subtask are summarized to generate digital products. The digital product and intermediate state information during the closed-loop execution process are pushed to the intelligent virtual desktop on the browser in real time, and the graphical programming results are output.

[0007] Preferably, classifying the input information into non-deterministic and deterministic inputs based on its type includes: When the input information is natural language text or voice command, the input information is classified as nondeterministic input, the natural language text or voice command is passed into the large language model, the task objective, operation object and constraint conditions are extracted, and a structured task representation is generated. When the input information is an API call instruction, a preset instruction set instruction, or a graphical interface operation instruction, the input information is classified as deterministic input, and the deterministic input is directly mapped to a structured task representation; The structured task representation is subjected to unified encoding processing to generate the Token stream.

[0008] Preferably, the hierarchical decomposition of the task objectives carried by the Token stream includes: Parse the task target information in the Token stream, identify the number and type of functional units involved in the task target, and generate a list of functional units; Based on the list of functional units, the task objective is decomposed into multiple subtasks according to the data dependencies and execution order between the functional units. The dependencies between the predecessor and successor subtasks are marked for each subtask, and the set of subtasks is generated. When the list of predecessor subtasks of a certain subtask is empty, the subtask is the entry subtask.

[0009] Preferably, when parsing the task target information in the Token stream, historical context information related to the current task is retrieved from the cross-session memory storage, and the historical context information is merged with the Token stream before task target identification is performed; The cross-session memory storage maintains three types of persistent memory structures: project lifecycle state, programming capability library, and reusable instruction set. Short-term session state is stored in a cache database, and long-term knowledge base is stored in a vector database, supporting semantic-based enhanced retrieval.

[0010] Preferably, performing a topological sort on the directed acyclic graph to generate an execution scheduling sequence includes: Traverse the dependency annotations of each subtask in the set of subtasks, and generate the directed acyclic graph with subtasks as nodes and dependencies as directed edges; A topological sort is performed on the directed acyclic graph, placing nodes without predecessor dependencies at the front and nodes with predecessor dependencies after all their predecessor nodes, generating a linear execution scheduling sequence; wherein, when there are multiple nodes without predecessor dependencies, the multiple nodes without predecessor dependencies are marked as concurrent execution nodes. During the closed-loop processing, the node status of the directed acyclic graph is monitored in real time. When a node fails to execute or the execution result does not meet the input requirements of the successor node, the affected subgraph is re-sorted to generate an updated execution scheduling sequence.

[0011] Preferably, the closed-loop processing of thinking, acting, and observing for each sub-task node includes: During the thinking phase, the task description of the current subtask node, the execution result of the predecessor node, and the current environment status information are obtained. The above information is then fed into the large language model to generate an action plan. The action plan includes the name of the tool to be called, the tool call parameters, and the expected output format. During the action phase, based on the tool name and tool call parameters specified in the action plan, the corresponding tool in the tool set is called through the function call interface to generate the tool execution result; During the observation phase, the execution results of the tool and the feedback information of the execution environment are collected, and the execution results of the tool are compared with the expected output format. If the execution is successful, the execution results of the tool are recorded as the output of the current subtask node and the process proceeds to the next subtask node. If the execution is unsuccessful, the execution results of the tool and the feedback information are returned to the thinking phase as new environmental status information to regenerate the action plan.

[0012] Preferably, the closed-loop processing has a maximum iteration limit. When the number of iterations of the same subtask node reaches the preset maximum iteration threshold and still fails to execute successfully, the subtask is marked as awaiting manual intervention, and the failure information is pushed to the browser interface. During the thinking phase, historical successfully executed instruction patterns that are semantically similar to the current subtask are retrieved from the reusable instruction set. The matched instruction patterns are then fed into the large language model as reference information to assist in generating an action plan. After the observation phase determines that the current subtask has been successfully executed, the task description and corresponding action plan of the current subtask are extracted as instruction patterns and written into the reusable instruction set, and the execution progress of the current project is updated to the cross-session memory storage.

[0013] Preferably, the intelligent virtual desktop presents the current execution steps, tool calls, and intermediate results of the intelligent agent in a visual manner, while also supporting users to perform real-time editing operations on the digital products, including modifying graphical node parameters, adjusting logical connection structures, and confirming or rejecting programming suggestions generated by the intelligent agent. When a user submits an edit operation, the edit operation is converted into deterministic input and re-injected into the step of obtaining the input information submitted by the user through the browser interface, triggering subsequent task breakdown and execution; In this process, the user's real-time editing operations and the AI's autonomous execution process are carried out in parallel within the same browser interface. The browser interface schedules the operation instructions of both in an orderly manner through an event queue. The user and the AI ​​operate on the same browser interface at the same time, share the workspace, and their operations do not block each other.

[0014] Preferably, before outputting the graphical programming result, the method further includes: Perform syntax validation on the digital product to check whether the generated code conforms to the syntax specifications of the industrial graphical programming language; Perform logical consistency checks on digital artifacts that pass syntax verification to verify the integrity and deadlock-free nature of the control logic; Perform industry standard compliance verification on digital products that pass the logical consistency check; If the digital product passes all verifications, the digital product will be output to the subsequent push and presentation process; if it fails, the error information of the verification failure will be extracted as structured feedback and pushed to the browser interface. At the same time, the correction task in the structured feedback will be re-injected into the hierarchical decomposition step and executed through directed acyclic graph scheduling and closed-loop processing to execute the correction process. After outputting the graphical programming results, the quality-verified and user-approved digital products are converted into standard format outputs usable in the industrial field, including PLC control logic programs, equipment configuration files, visual monitoring charts, and process flow documents.

[0015] A browser-based human-computer collaborative multi-agent graphical programming system includes: The input encoding module is used to acquire input information submitted by the user through the browser interface, classify the input information into non-deterministic input and deterministic input according to the type of input information, perform intent recognition and semantic parsing on non-deterministic input, perform direct mapping on deterministic input, and generate a token stream in a unified format. The task planning module is used to hierarchically decompose the task objectives carried by the Token stream, identify multiple subtasks and the dependencies between subtasks, and generate a set of subtasks with dependency annotations. The scheduling generation module is used to convert the subtask set into a directed acyclic graph based on the dependency relationship of each subtask in the subtask set, perform topological sorting on the directed acyclic graph, and generate an execution scheduling sequence. The closed-loop execution module is used to perform closed-loop processing of thinking, action, and observation on each subtask node in the order of the execution scheduling sequence, and to summarize the execution results of each subtask to generate digital products. The result push module is used to push the digital product and intermediate state information during the closed-loop execution process to the intelligent virtual desktop on the browser in real time and output the graphical programming results. The digital product quality verification module is used to perform automated quality checks on the digital products output by the core layer of the OT general intelligent agent, including: syntax verification, logic consistency check, and industry standard compliance verification. The OT Digital Goods Delivery Module is used to receive quality-verified digital products and deliver them in standard formats available for industrial OT scenarios, including: PLC control logic programs, equipment configuration files, visual monitoring charts, and process flow documents.

[0016] In summary, due to the adoption of the above technical solution, the beneficial effects of the present invention are: 1. This invention uses the task planning module Planner to hierarchically decompose the task objective into a set of subtasks labeled with dependencies, and converts them into a directed acyclic graph for topological sorting. This solves the technical problem of the difficulty in automatically and orderly scheduling complex industrial programming tasks, and achieves the technical effect of supporting the ordered execution driven by dependencies and the concurrent scheduling of dependency-free subtasks.

[0017] 2. This invention solves the technical problem that a single generated result cannot be automatically corrected by performing a Think-Act-Observe closed-loop process on each sub-task node and automatically regenerating a corrected action plan when execution fails. This achieves the technical effect that the sub-task execution has the ability to autonomously iterate and correct itself. Attached Figure Description

[0018] Further details, features, and advantages of this application are disclosed in the following description of exemplary embodiments in conjunction with the accompanying drawings, in which: Figure 1 This is a flowchart of the method of the present invention. Detailed Implementation

[0019] Several embodiments of this application will now be described in more detail with reference to the accompanying drawings to enable those skilled in the art to implement this application. This application may be embodied in many different forms and for various purposes and should not be limited to the embodiments set forth herein. These embodiments are provided to make this application thorough and complete, and to fully convey the scope of this application to those skilled in the art. The embodiments described do not limit this application.

[0020] Unless otherwise defined, all terms used herein (including technical and scientific terms) shall have the same meaning as commonly understood by one of ordinary skill in the art to which this application pertains. It will be further understood that terms such as those defined in commonly used dictionaries shall be interpreted as having a meaning consistent with their meaning in the relevant field and / or the context of this specification, and shall not be interpreted in an idealized or overly formal sense unless expressly defined herein.

[0021] Example 1 Its specific implementation method is combined with the appendix Figure 1 Please provide a detailed explanation.

[0022] In this embodiment, it includes: In a factory automation production line project, engineers accessed a graphical programming platform via a standard web browser to add automated control logic for the bottle cap pressing process on a beverage bottling line. The line already has conveyor belt nodes and filling nodes. The engineers wanted to write and deliver the pressing process control program without installing any local software, using a combination of natural language descriptions and graphical operations.

[0023] Step S100 is the input information acquisition and intent encoding processing stage. The engineer enters a natural language description in the input box of the browser interface. The system determines that the input is non-deterministic and then passes it to the large language model to perform intent recognition and semantic parsing, extracting the task objective, operation object and constraints, and finally generating a token stream in a unified format.

[0024] Table 1 Input Information Parsing and Token Stream Generation

[0025] Step S200 is the task hierarchical decomposition stage. The Planner module parses the Token stream and retrieves the historical context of the project from the cross-session memory storage, discovering that the production line already has programming records for the conveyor belt node (node ​​number N-001) and the filling node (node ​​number N-002). Combining the historical context and the Token stream, the Planner module identifies that this task involves 4 functional units and generates a set of subtasks according to data dependencies.

[0026] Table 2 Subtask Sets and Dependency Labels

[0027] The system retrieved historical records from cross-session memory storage: In 20XX, this production line used a single-point pressure detection template when configuring the filling node, and this template was incorporated into the context of ST-01 as reference information.

[0028] Step S300 is the directed acyclic graph generation and execution scheduling stage. Based on the dependencies in Table 2, the system converts the four subtasks into a directed acyclic graph. ST-01 and ST-02 have no predecessor dependencies and are marked as concurrently executable nodes; ST-03 depends on ST-01 and ST-02; ST-04 depends on ST-03. After performing topological sorting on the directed acyclic graph, a linear execution scheduling sequence is generated.

[0029] The set of edges of a directed acyclic graph is: , , .

[0030] Table 3 Execution Scheduling Sequence

[0031] Step S400 is the TAO closed-loop execution phase. Following the execution scheduling sequence, the system sequentially executes the Think-Act-Observe loop on each subtask node. Taking ST-03 (generating the dual-detection logic control block code) as an example, the complete TAO closed-loop process is illustrated.

[0032] Think phase: The large language model acquires the task description of ST-03, the pressure detection template (template number TPL-P-042) output by ST-01, the travel limit template (template number TPL-L-017) output by ST-02, and the current environment status. At the same time, it retrieves historical similar instruction patterns (pattern number PAT-2203, corresponding to the two-parameter interlocking logic of the filling node) from the reusable instruction set and generates an action plan: calls the integrated compilation and execution tool with the following parameters: merge TPL-P-042 and TPL-L-017, set the pressure threshold to 120N, set the travel limit to 15mm, and the expected output format is CQG function block code text.

[0033] Act phase: The integrated compilation and execution tool is called through the FunctionCalling interface, passing in the above parameters. The tool performs code generation and compilation checks in the browser sandbox environment and returns the function block code text (code block number CB-CAPPER-DualCheck).

[0034] Observe Phase: The CB-CAPPER-DualCheck is compared with the expected output format. If compilation is successful and the logical structure is complete, ST-03 indicates successful execution. The system extracts the current task description and action plan into a new instruction pattern (pattern number PAT-2251), writes it into the reusable instruction set, and updates the project lifecycle status.

[0035] When ST-04 is executed, the browser automation tool automatically completes the node connection operation in the graphical programming interface, establishes a trigger connection between the CB-CAPPER-DualCheck node and N-002 (filling node), and fills in the pressure threshold and stroke limit parameter form.

[0036] Table 4 Summary of TAO Closed-Loop Execution Results

[0037] After all subtasks are executed successfully, the outputs of each node are summarized to generate a digital product (product number ART-CAPPER-20XX0312).

[0038] Steps S501 to S504 constitute the quality verification phase. The system sequentially performs syntax verification, logical consistency check, and industry standard compliance verification on ART-CAPPER-20XX0312.

[0039] The syntax verification phase checks whether CB-CAPPER-DualCheck conforms to the CQG syntax specification, and the result is passed. The logic consistency check phase verifies the integrity of the dual-detection logic, confirming that there is no deadlock path in the interlocking conditions between pressure detection and stroke detection, and the result is passed. The compliance verification phase checks whether the digital artifact meets the specification requirements for function block declarations and variable types in IEC61131-3, and the result is passed. After all three verifications pass, the digital artifact enters the push process.

[0040] Table 5 Quality Verification Results

[0041] Step S500 is the real-time push and human-machine collaborative presentation stage. The system pushes intermediate state information (including execution progress from ST-01 to ST-04 and tool call status) during the TAO closed-loop execution process to the intelligent virtual desktop in the browser in real time via the SSE protocol. After observing the automatically generated pressing control node in the virtual desktop, the engineer modifies the pressure threshold from 120N to 115N through the graphical interface. This operation is recognized as a graphical interface operation command (deterministic input) and re-injected into step S100, triggering the parameter update process of ST-04. After the engineer confirms the final result, the digital product is converted and output in step S601.

[0042] Step S601 converts the verified ART-CAPPER-20XX0312 into the following standard format deliverables: Table 6 Standard Format Delivery List

[0043] Throughout the process, data starts with the natural language description input by the engineer, and after semantic parsing in step S100, a structured token stream is generated, carrying the task type, operation object, and parameter constraints. After entering step S200, the token stream is broken down into four sub-tasks with clear dependencies based on the historical context. Step S300 transforms the dependencies into a directed acyclic graph and sorts them. The concurrent arrangement of ST-01 and ST-02 is directly due to the fact that their predecessor columns are both empty in Table 2. In the TAO closed-loop execution in step S400, the template outputs of ST-01 and ST-02 serve as the inputs of ST-03, and the code output of ST-03 serves as the operation object of ST-04. The data flow between each step strictly follows the dependency relationship. After all three quality verifications are passed, the engineer's parameter modification on the virtual desktop serves as a deterministic input to re-trigger local execution, and finally, a complete control program package that meets industry standards is delivered.

[0044] The foregoing has only described certain exemplary embodiments of the present invention by way of illustration. Undoubtedly, those skilled in the art can modify the described embodiments in various ways without departing from the spirit and scope of the present invention. Therefore, the foregoing drawings and descriptions are illustrative in nature and should not be construed as limiting the scope of protection of the claims of the present invention.

[0045] It should be understood that in the various embodiments of this application, the order of the above-mentioned processes does not imply the order of execution. The execution order of each process should be determined by its function and internal logic, and should not constitute any limitation on the implementation process of the embodiments of this application.

[0046] In addition, the functional units in the various embodiments of this application can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit.

[0047] The above description is merely a specific embodiment of this application, but the scope of protection of this application is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the scope of the technology disclosed in this application should be included within the scope of protection of this application. Therefore, the scope of protection of this application should be determined by the scope of the claims.

Claims

1. A browser-based human-computer collaborative multi-agent graphical programming method, characterized in that, include: The system acquires input information submitted by users through the browser interface, categorizes the input information into non-deterministic and deterministic inputs based on their type, performs intent recognition and semantic parsing on non-deterministic inputs, performs direct mapping on deterministic inputs, and generates a token stream in a unified format. The Token stream is input into the task planning module, which hierarchically decomposes the task objectives carried by the Token stream, identifies multiple subtasks and the dependencies between subtasks, and generates a set of subtasks with dependency annotations. Based on the dependencies between the subtasks in the subtask set, the subtask set is converted into a directed acyclic graph, and a topological sort is performed on the directed acyclic graph to generate an execution scheduling sequence. According to the execution scheduling sequence, each subtask node is processed in a closed loop of thinking, action, and observation. In the thinking phase, an action plan is generated through a large language model. In the action phase, the action plan is executed by calling the toolset in the browser sandbox environment through the function call interface. The sandbox environment is either WebAssembly or a Docker container. In the observation phase, the execution results are compared and verified with the expected output. After all subtask nodes have been processed, the execution results of each subtask are summarized to generate digital products. The digital product and intermediate state information during the closed-loop execution process are pushed to the intelligent virtual desktop on the browser in real time, and the graphical programming results are output.

2. The browser-based human-computer collaborative multi-agent graphical programming method according to claim 1, characterized in that, Based on the type of input information, it is divided into nondeterministic input and deterministic input, including: When the input information is natural language text or voice command, the input information is classified as nondeterministic input, the natural language text or voice command is passed into the large language model, the task objective, operation object and constraint conditions are extracted, and a structured task representation is generated. When the input information is an API call instruction, a preset instruction set instruction, or a graphical interface operation instruction, the input information is classified as deterministic input, and the deterministic input is directly mapped to a structured task representation; The structured task representation is subjected to unified encoding processing to generate the Token stream.

3. The browser-based human-computer collaborative multi-agent graphical programming method according to claim 1, characterized in that, The hierarchical decomposition of the task objectives carried by the Token stream includes: Parse the task target information in the Token stream, identify the number and type of functional units involved in the task target, and generate a list of functional units; Based on the list of functional units, the task objective is decomposed into multiple subtasks according to the data dependencies and execution order between the functional units. The dependencies between the predecessor and successor subtasks are marked for each subtask, and the set of subtasks is generated. When the list of predecessor subtasks of a certain subtask is empty, the subtask is the entry subtask.

4. The browser-based human-computer collaborative multi-agent graphical programming method according to claim 1, characterized in that, When parsing the task target information in the Token stream, historical context information related to the current task is also retrieved from the cross-session memory storage. The historical context information is then merged with the Token stream before task target identification is performed. The cross-session memory storage maintains three types of persistent memory structures: project lifecycle state, programming capability library, and reusable instruction set. Short-term session state is stored in a cache database, and long-term knowledge base is stored in a vector database, supporting semantic-based enhanced retrieval.

5. The browser-based human-computer collaborative multi-agent graphical programming method according to claim 1, characterized in that, Performing a topological sort on the directed acyclic graph to generate an execution scheduling sequence includes: Traverse the dependency annotations of each subtask in the set of subtasks, and generate the directed acyclic graph with subtasks as nodes and dependencies as directed edges; A topological sort is performed on the directed acyclic graph, placing nodes without predecessor dependencies at the front and nodes with predecessor dependencies after all their predecessor nodes, generating a linear execution scheduling sequence; wherein, when there are multiple nodes without predecessor dependencies, the multiple nodes without predecessor dependencies are marked as concurrent execution nodes. During the closed-loop processing, the node status of the directed acyclic graph is monitored in real time. When a node fails to execute or the execution result does not meet the input requirements of the successor node, the affected subgraph is re-sorted to generate an updated execution scheduling sequence.

6. The browser-based human-computer collaborative multi-agent graphical programming method according to claim 1, characterized in that, The closed-loop processing of thinking, action, and observation for each subtask node includes: During the thinking phase, the task description of the current subtask node, the execution result of the predecessor node, and the current environment status information are obtained. The above information is then fed into the large language model to generate an action plan. The action plan includes the name of the tool to be called, the tool call parameters, and the expected output format. During the action phase, based on the tool name and tool call parameters specified in the action plan, the corresponding tool in the tool set is called through the function call interface to generate the tool execution result; During the observation phase, the execution results of the tool and the feedback information of the execution environment are collected, and the execution results of the tool are compared with the expected output format. If the execution is successful, the execution results of the tool are recorded as the output of the current subtask node and the process proceeds to the next subtask node. If the execution is unsuccessful, the execution results of the tool and the feedback information are returned to the thinking phase as new environmental status information to regenerate the action plan.

7. The browser-based human-computer collaborative multi-agent graphical programming method according to claim 1, characterized in that, The closed-loop processing has a maximum iteration limit. When the number of iterations of the same subtask node reaches the preset maximum iteration threshold and still fails to execute successfully, the subtask is marked as awaiting manual intervention and the failure information is pushed to the browser interface. During the thinking phase, historical successfully executed instruction patterns that are semantically similar to the current subtask are retrieved from the reusable instruction set. The matched instruction patterns are then fed into the large language model as reference information to assist in generating an action plan. After the observation phase determines that the current subtask has been successfully executed, the task description and corresponding action plan of the current subtask are extracted as instruction patterns and written into the reusable instruction set, and the execution progress of the current project is updated to the cross-session memory storage.

8. The browser-based human-computer collaborative multi-agent graphical programming method according to claim 1, characterized in that, The intelligent virtual desktop presents the current execution steps, tool calls, and intermediate results of the intelligent agent in a visual manner. It also supports human users to perform real-time editing operations on the digital products, including modifying graphical node parameters, adjusting logical connection structures, and confirming or rejecting programming suggestions generated by the intelligent agent. When a human user submits an edit operation, the edit operation is converted into deterministic input and re-injected into the step of obtaining the input information submitted by the user through the browser interface, triggering subsequent task breakdown and execution; In this process, the real-time editing operations of human users and the autonomous execution process of intelligent agents are carried out in parallel within the same browser interface. The browser interface schedules the operation instructions of the two in an orderly manner through an event queue. The user and the AI ​​operate the same browser interface simultaneously, share the workspace, and their operations do not block each other.

9. The browser-based human-computer collaborative multi-agent graphical programming method according to claim 1, characterized in that, Before outputting the graphical programming results, it also includes: Perform syntax validation on the digital product to check whether the generated code conforms to the syntax specifications of the industrial graphical programming language; Perform logical consistency checks on digital artifacts that pass syntax verification to verify the integrity and deadlock-free nature of the control logic; Perform industry standard compliance verification on digital products that pass the logical consistency check; If the digital product passes all verifications, the digital product will be output to the subsequent push and presentation process; if it fails, the error information of the verification failure will be extracted as structured feedback and pushed to the browser interface. At the same time, the correction task in the structured feedback will be re-injected into the hierarchical decomposition step and executed through directed acyclic graph scheduling and closed-loop processing to execute the correction process. After outputting the graphical programming results, the quality-verified and user-approved digital products are converted into standard format outputs usable in the industrial field, including PLC control logic programs, equipment configuration files, visual monitoring charts, and process flow documents.

10. A browser-based human-computer collaborative multi-agent graphical programming system, comprising the browser-based human-computer collaborative multi-agent graphical programming method according to any one of claims 1-9, characterized in that, include: The input encoding module is used to acquire input information submitted by the user through the browser interface, classify the input information into non-deterministic input and deterministic input according to the type of input information, perform intent recognition and semantic parsing on non-deterministic input, perform direct mapping on deterministic input, and generate a token stream in a unified format. The task planning module is used to hierarchically decompose the task objectives carried by the Token stream, identify multiple subtasks and the dependencies between subtasks, and generate a set of subtasks with dependency annotations. The scheduling generation module is used to convert the subtask set into a directed acyclic graph based on the dependency relationship of each subtask in the subtask set, perform topological sorting on the directed acyclic graph, and generate an execution scheduling sequence. The closed-loop execution module is used to perform closed-loop processing of thinking, action, and observation on each subtask node in the order of the execution scheduling sequence, and to summarize the execution results of each subtask to generate digital products. The result push module is used to push the digital product and intermediate state information during the closed-loop execution process to the intelligent virtual desktop on the browser in real time and output the graphical programming results. The digital product quality verification module is used to perform automated quality checks on the digital products output by the core layer of the OT general intelligent agent, including: syntax verification, logic consistency check, and industry standard compliance verification. The OT Digital Goods Delivery Module is used to receive quality-verified digital products and deliver them in standard formats available for industrial OT scenarios, including: PLC control logic programs, equipment configuration files, visual monitoring charts, and process flow documents.

Images