An interactive method based on artificial intelligence

Abstract

This invention relates to the field of artificial intelligence interaction, and discloses an AI-based interactive system and method. The system includes: a data acquisition module configured to acquire user task requests and generate corresponding task execution plans; a compilation module configured to compile the task execution plans in real time and render them into an interactive execution flow graph; a data processing module configured to update the execution status of each node in the interactive execution flow graph in real time when generating the corresponding task execution plan; the data processing module is further configured to acquire user graphical operations on specific nodes or connections in the interactive execution flow graph and compile these graphical operations into intervention instructions for the task execution logic; and an execution module configured to adjust the task execution plan in real time based on the intervention instructions and update the structure and status of the interactive execution flow graph. This application presents the logical and analytical processes, enhancing the user's sense of control.

Description

Technical Field

[0001] This invention relates to the field of artificial intelligence interaction, and more specifically, to an interaction method based on artificial intelligence. Background Technology

[0002] As a core bridge connecting humans and smart devices, the development of AI interaction systems is the result of technological iteration, demand upgrading, and industrial transformation. From early simple command responses to today's intelligent systems with contextual understanding, emotion perception, and multimodal interaction capabilities, it has deeply penetrated diverse scenarios such as business services, daily life, and public governance. It has become a key benchmark for measuring the maturity of AI technology and is driving a fundamental change in how humans interact with the digital world. "When in doubt, ask AI" has become commonplace. Users need interaction methods that allow them to complete tasks using only natural language without learning complex operations, such as using AI to plan trips, tutor homework, and control smart homes. On the other hand, the demand for emotional companionship is becoming increasingly prominent, and the rise of products such as personalized AI companions and virtual characters meets users' emotional needs in social and entertainment scenarios.

[0003] Currently, a new generation of AI interactive systems driven by large-scale language models is rapidly transforming from "information providers" to "task executors." However, in this leap in capabilities, a core contradiction is becoming increasingly prominent: the severe black-box nature of the system execution process leads to a widespread lack of user control, thereby eroding trust and collaborative efficiency. When users issue complex instructions to AI (such as "plan a five-day, moderately budgeted cultural trip to Kyoto and book a cancelable hotel"), the ideal human-machine collaboration model should resemble working with a transparent, supervised, and readily intervening expert assistant. But in reality, users are more like issuing instructions to an unknowable magic box: after the system absorbs the instruction, it enters a silent "thinking" period, ultimately outputting a result or a failure message. The entire process exhibits typical black-box characteristics.

[0004] The so-called black box characteristic means that the progress is not transparent. Users do not know which stage the system is currently in (is it searching for information, comparing prices, or filling out a form?), nor can they predict the completion time. The logic is not transparent, so users have no way of understanding the decision-making basis (why choose hotel A instead of hotel B? What logic is used to sort the itinerary? Have the user's implicit preferences been considered?). Furthermore, there is a lack of intervention channels. At key decision points (such as discovering date conflicts, exceeding the budget, or inconsistencies in preferences), users cannot pause, adjust their direction, or provide additional input. They can only passively accept the final result or start all over again.

[0005] Therefore, it is necessary to design an AI-based interaction method to solve the problems existing in current technologies. Summary of the Invention

[0006] In view of this, the present invention proposes an artificial intelligence-based interaction method, which aims to solve the problem of low efficiency in current aggregated payment.

[0007] On one hand, this invention proposes an artificial intelligence-based interactive system, comprising: The acquisition module is configured to acquire user task requests and generate corresponding task execution plans, which include several sub-tasks with dependencies. The compilation module is configured to compile in real time based on the task execution plan and render it into an interactive execution flow graph, wherein each subtask is an interactive node in the interactive execution flow graph, and the dependencies between the subtasks are editable connection lines connecting the nodes; The data processing module is configured to update the execution status of each node in the interactive execution flow graph in real time when generating the corresponding task execution plan, and update the visual status of each node in the interactive execution flow graph in real time based on the execution status. The execution status includes at least pending execution, executing, successful, failed, and waiting for user input. The data processing module is also configured to acquire graphical operations performed by the user on specific nodes or connections in the interactive execution flow graph, and to compile the graphical operations into intervention instructions for the task execution logic; The execution module is configured to adjust the task execution plan in real time based on the intervention command, and update the structure and status of the interactive execution flow graph.

[0008] Furthermore, the intervention instructions include at least dragging nodes, dragging the endpoints of connecting lines, and right-clicking a node and selecting a menu item; The drag-and-drop node is configured to change the position of the node in the interactive execution flow graph and adjust the execution priority and / or order of the subtasks; The drag-and-drop connection is configured to disconnect the connection from the original node and connect it to another node, thereby changing the task dependency. The right-clicking of a node and selection of a menu item is configured to execute a specific operation instruction on the subtask, which includes at least skip, retry, edit parameters, view details, and manually set the result.

[0009] Furthermore, the interactive execution flow graph is in the form of a directed graph, wherein: The nodes use differentiated visual encoding to represent different types of the subtasks, and the types include at least data query, calculation, condition judgment, user input waiting, and external API call; The connection lines use differential visual encoding to represent different types of dependencies, including at least sequential dependencies, data flow dependencies, conditional branches, and parallel execution.

[0010] Furthermore, when performing real-time compilation and rendering into an interactive execution flow graph based on the task execution plan, it includes: Perform static analysis on the task execution plan to identify all the subtasks and their dependencies; The nodes are automatically laid out based on the resource requirements and estimated execution time of the sub-tasks. A context menu is generated for each node, and the context menu includes executable action options for that subtask.

[0011] Furthermore, when performing real-time compilation and rendering into an interactive execution flow graph based on the task execution plan, the method also includes: Obtain the domain to which the current task belongs and its dependencies, and load the knowledge graph and historical database corresponding to the domain of the current task; The knowledge graph and the historical database are compared using preset constraint rules, and their logical order is determined based on the comparison results. Based on the logical order, the structural similarity is determined by matching it with the historical database. Based on the logical order and the structural similarity, a dependency verification report is generated. The dependency verification includes at least a conflict list, a confidence score, and correction suggestions. When the confidence score is lower than a preset threshold, the dependency relationship is adjusted based on the correction suggestion.

[0012] Furthermore, the dependencies include data flow dependencies, sequence dependencies, conditional branch dependencies, and parallel execution dependencies; When the execution of one of the subtasks requires the output data of another subtask as input data, or when the execution result of one subtask affects the parameter selection or execution path of another subtask, it is determined to be a data flow dependency. When there is no direct data relationship, but the data needs to be executed in the order of business logic, it is determined to be a sequential dependency. When the execution of one or more of the subtasks depends on the result of a precondition judgment task, it is determined to be a conditional branch dependency; When multiple subtasks have no data or logical connection and can be executed simultaneously, they are considered to be parallel execution dependencies.

[0013] Furthermore, when generating a dependency verification report based on the logical order and the structural similarity, the process includes: The dependencies are subjected to static structure verification and dynamic behavior verification. The static structure verification includes constructing a dependency graph with the subtasks as nodes and the dependencies as outgoing edges, and determining whether there are circular dependencies and subsequent tasks not covered by any branches in the dependency graph based on the topological sorting algorithm. The dynamic behavior verification includes performing a simulation in a lightweight simulation environment based on the dependency graph, determining whether the actual task execution path is consistent with the path specified in the dependency graph under various preset input and abnormal conditions, and recording the execution status and path deviation. The confidence score for each dependency is determined based on the static structure verification and the dynamic behavior verification.

[0014] Furthermore, when generating a dependency verification report based on the logical order and the structural similarity, the method also includes: Based on the dependency graph, determine whether multiple subtasks marked as parallel execution dependencies actually require the same exclusive resource; Based on the dependency graph, determine whether two subtasks with data flow dependencies are simultaneously and incorrectly marked as executable in parallel; For the subtask used as a conditional judgment, iterate through all possible output results and check whether each result maps to at least one subsequent executed subtask branch to determine if there are any logical loopholes.

[0015] Furthermore, when generating a dependency verification report based on the logical order and the structural similarity, the method also includes: The lightweight simulation environment is constructed, which configures a simulation executor and a virtual data generator for each type of subtask; Execute multiple verification test cases based on the aforementioned dependencies. The test cases at least cover the normal execution path, boundary condition inputs, and failure scenarios simulating random subtask execution failures. During the simulation, the system monitors and records whether the data transfer between tasks conforms to the definition of the data flow dependency, and whether the task execution sequence violates the conventions of sequential dependency and parallel execution dependency. Based on the results of the simulation, the system marks each dependency with a dynamic verification status, including: verification passed, verification failed, or verification questionable.

[0016] Compared with the prior art, the beneficial effects of the present invention are as follows: (1) The present invention realizes a fundamental paradigm shift in artificial intelligence interaction from "black box automation" to "white box collaboration", improving the transparency and comprehensibility of the interaction process. Through the compilation module, the abstract execution plan is "translated" into an intuitive graphical execution flow diagram, making the complex task logic (subtask composition, dependency relationship, execution path) clear at a glance. Users can clearly see the "thinking steps" of AI and the current work focus. This visual exposure of the execution process transforms the invisible computation into a visible process, eliminating the confusion and anxiety caused by mystery. The real-time update and visual feedback of the node status by the data processing module provides users with continuous and clear status synchronization. This instant and rich progress feedback eliminates the uncertainty and guesswork in the waiting process, enabling users to establish accurate psychological expectations of task progress, thereby shifting their attention from worrying about the process to focusing on the results and decisions.

[0017] (2) This invention designs nodes and connections to be "interactive" and "editable," allowing users to directly intervene in the execution logic through intuitive graphical operations (such as dragging, reconnecting, and clicking menus). This means that users are no longer the "initiators" of commands, but have been upgraded to "co-editors" and "real-time supervisors" of the process. This empowerment from observer to participant changes the human-machine relationship, enhances user confidence and immersion, and makes AI a truly intelligent collaborator at the user's command. In the visual interactive flow diagram constructed by this invention, errors are accurately located to specific nodes (such as marked as "failed"), and their impact range is clearly shown through the dependency graph. Users or the system can intervene in a targeted manner to achieve local repair rather than global restart, improving the system's resilience to abnormal situations and reducing the failure rate caused by ambiguous or dynamically changing requirements. This invention supports dynamic adjustments during execution. When users change the node order or edit node parameters by dragging, the execution module can reorganize the task plan in real time based on the new intervention instructions. This ability to adapt to dynamic needs in real time enables the system to flexibly respond to changes in user thinking, transforming many situations that might otherwise lead to task failure or unsatisfactory results into a smooth collaborative optimization process.

[0018] On the other hand, this application also provides an artificial intelligence-based interaction method, including: Obtain the user's task request and generate a corresponding task execution plan, which includes several sub-tasks with dependencies. The task execution plan is compiled in real time and rendered into an interactive execution flow graph, wherein each subtask is an interactive node in the interactive execution flow graph, and the dependencies between the subtasks are editable connection lines connecting the nodes; When generating the corresponding task execution plan, the execution status of each node in the interactive execution flow graph is updated in real time, and the visual status of each node in the interactive execution flow graph is updated in real time based on the execution status. The execution status includes at least pending execution, executing, successful, failed, and waiting for user input. Obtain the user's graphical operations on specific nodes or connections in the interactive execution flow graph, and compile the graphical operations into intervention instructions for the task execution logic; Based on the intervention instructions, the task execution plan is adjusted in real time, and the structure and status of the interactive execution flow graph are updated.

[0019] It is understood that the artificial intelligence interaction system and method provided in this application have the same beneficial effects, and will not be described in detail here. Attached Figure Description

[0020] Various other advantages and benefits will become apparent to those skilled in the art upon reading the following detailed description of preferred embodiments. The accompanying drawings are for illustrative purposes only and are not intended to limit the invention. Furthermore, the same reference numerals denote the same parts throughout the drawings. In the drawings: Figure 1 A functional block diagram of an artificial intelligence-based interactive system provided in an embodiment of the present invention; Figure 2 A flowchart of an AI-based interaction method provided in an embodiment of the present invention. Detailed Implementation

[0021] Exemplary embodiments of the present disclosure will now be described in more detail with reference to the accompanying drawings. While exemplary embodiments of the present disclosure are shown in the drawings, it should be understood that the present disclosure may be implemented in various forms and should not be limited to the embodiments set forth herein. Rather, these embodiments are provided to enable a more thorough understanding of the present disclosure and to fully convey the scope of the disclosure to those skilled in the art. It should be noted that, unless otherwise specified, embodiments and features in the embodiments of the present invention can be combined with each other. The present invention will now be described in detail with reference to the accompanying drawings and embodiments.

[0022] On the one hand, in some embodiments of this application, see Figure 1 As shown, this embodiment provides an artificial intelligence-based interactive system, including: The acquisition module is configured to acquire user task requests and generate corresponding task execution plans, which include several subtasks with dependencies.

[0023] The compilation module is configured to compile in real time based on the task execution plan and render it as an interactive execution flow graph, where each subtask is an interactive node in the interactive execution flow graph, and the dependencies between subtasks are editable connection lines connecting nodes.

[0024] The data processing module is configured to update the execution status of each node in the interactive execution flow graph in real time when generating the corresponding task execution plan, and to update the visual status of each node in the interactive execution flow graph in real time based on the execution status. The execution status includes at least pending execution, executing, successful, failed, and waiting for user input.

[0025] The data processing module is also configured to acquire graphical operations performed by the user on specific nodes or connections in the interactive execution flow graph, and to compile these graphical operations into intervention instructions for the task execution logic.

[0026] The execution module is configured to adjust the task execution plan in real time based on intervention commands and update the structure and status of the interactive execution flow graph.

[0027] Specifically, the acquisition module generates a corresponding task execution plan by obtaining the user's initial task request. This task execution plan includes multiple dependent subtasks given to the initial task request. At the same time, the compilation module compiles and renders this task execution plan in real time into an interactive execution flow graph. In this execution flow graph, each subtask is an interactive node, and the connection nodes between the dependencies of the subtasks are editable connection lines. When generating the corresponding task execution plan, the execution status of each node is updated in real time, and the corresponding visual status is changed in the interactive execution flow graph. Furthermore, the execution logic can be changed based on the user's graphical operation on specific nodes or connection lines.

[0028] Understandably, firstly, at the user's cognitive and psychological level, this system enhances the transparency and predictability of the interaction process, while reducing the resulting confusion and distrust. In traditional AI interaction, after issuing a command, the user is trapped in a "black box wait," unable to know how the system understands the task, its progress, or potential difficulties. This system, through its compilation module, compiles abstract task execution plans into interactive execution flow diagrams in real time, presenting complex task decomposition logic, dependencies between subtasks, and dynamic execution paths in a clear and intuitive graphical manner. This visual exposure of the AI's "thought process" allows users to clearly perceive the system's working logic and current focus. The data processing module's real-time visual updates of node status (such as the dynamic effect of "Executing" and the explicit prompt of "Waiting for user input") provide continuous and definite status feedback, enabling users to establish accurate psychological expectations of task progress. This shifts attention from worry and speculation about the process to focus on the outcome and key decision points, alleviating anxiety and uncertainty during the waiting process.

[0029] Secondly, regarding system controllability and robustness, this system enhances users' ability to guide and correct complex task execution processes in real time, while reducing the overall failure risk caused by dynamic changes in requirements or uncertainties in the execution environment. Traditional automated processes are difficult to intervene in once started, and often become rigid when faced with execution deviations or new ideas generated by users midway. This system defines nodes and connections in the execution flow diagram as interactive and editable objects. Users can directly issue precise intervention commands to the data processing module through intuitive graphical operations (such as dragging and dropping nodes to adjust their order, editing connections to change dependencies, and clicking on node menus to modify parameters). The execution module adjusts the task plan and updates the flow diagram in real time accordingly, realizing "online programming" and dynamic refactoring of task logic. This means that the system no longer mechanically executes initial commands, but can flexibly adapt to the evolution of user thinking and changes in external conditions, transforming many potential failure scenarios into a smooth collaborative optimization process, enhancing the system's fault tolerance and adaptability in handling complex and non-standard tasks.

[0030] Furthermore, in terms of collaboration efficiency and communication quality, this system constructs a high-bandwidth, low-loss human-machine collaborative language, improving the accuracy and efficiency of collaborative problem-solving while reducing communication costs and repetitive work caused by misunderstandings of intent or information asymmetry. The interactive execution flow diagram acts as a shared, structured "strategic map" for both humans and machines. It transcends the ambiguity that may exist in natural language, providing a visual common language that precisely expresses task structure, logical constraints, and real-time status. Every user operation on the "map" is a clear and unambiguous instruction to the AI. Every status update of the "map" by the AI ​​is a transparent and traceable report to the user. This bidirectional, precise alignment based on the same visual medium ensures that both parties maintain a consistent understanding of task objectives and the current situation, reducing the repetitive clarification, confirmation, and correction cycles common in traditional interactions, making human-machine collaboration as efficient and smooth as team collaboration.

[0031] Furthermore, in terms of error diagnosis and problem resolution, this invention improves the accuracy of problem localization and the targeted nature of repair, while reducing the difficulty of troubleshooting and the time cost of system recovery. When a subtask fails or produces abnormal results, traditional systems often only provide general error codes or logs, making it difficult for users to quickly locate the root cause and its scope of impact. In this system, the problem is directly located and highlighted on a specific node in the flow graph, and its impact on upstream and downstream tasks through dependency connections is also clear at a glance. This visualized "fault topology" allows users or operations personnel to quickly understand the nature and scope of the problem. Combined with the context menus provided by the nodes (such as "View Details," "Retry," and "Manually Set Results"), rapid root cause analysis, local retries, or manual overwriting can be achieved, thus enabling "surgical" precision repair and avoiding the costly expense of restarting the entire task chain or starting troubleshooting from scratch due to local problems.

[0032] In some embodiments of this application, the intervention instructions include at least dragging a node, dragging the endpoint of a connection line, and right-clicking a node and selecting a menu item.

[0033] Drag and drop nodes are configured to change the position of nodes in the interactive execution flow graph and adjust the execution priority and / or order of subtasks.

[0034] Drag and drop connections are configured to disconnect a connection from its original node and connect it to another node, thus changing task dependencies.

[0035] Right-clicking a node and selecting a menu item configures it to perform a specific action command on the subtask. The specific action command includes at least skip, retry, edit parameters, view details, and manually set the result.

[0036] In some embodiments of this application, the interactive execution flow graph takes the form of a directed graph, wherein: Nodes use differentiated visual encoding to represent different types of subtasks, including at least data query, calculation, condition judgment, user input waiting, and external API call.

[0037] The connectors use differential visual encoding to represent different types of dependencies, including at least sequential dependencies, data flow dependencies, conditional branches, and parallel execution.

[0038] Specifically, intervention commands include at least dragging nodes, dragging the endpoints of connectors, and right-clicking a node and selecting a menu item. By changing nodes or connectors, the system can then adjust task dependencies and execution priorities accordingly, clearly displaying these changes by altering their positions in the graph. Furthermore, menu items allow for skipping, retrying, and other conceptual operations, expanding the user's operational scope and enabling clear visualization of the AI's thought process. This clear and intuitive view of the AI's thought process helps determine if its logic and direction deviate from the user's original intent, allowing for adjustments to ascertain the user's true intentions.

[0039] Understandably, this technical solution transforms the execution logic of artificial intelligence into a visualized, operable, and interactive execution flow diagram, empowering users to intervene in real time through intuitive graphical operations, thus constructing a completely new paradigm of human-machine collaboration. Its core benefits extend far beyond interface aesthetics; it profoundly changes the relationship between users and AI systems, bringing about a qualitative leap in several key dimensions.

[0040] First, this invention enhances the transparency and explainability of the interaction process, reducing user confusion and distrust caused by "black box" operations. In traditional AI systems, the internal decision-making chain, sub-task breakdown logic, and dependencies are completely invisible to the user, who can only passively accept the final result or vague progress prompts. This invention, by employing differentiated visually encoded nodes and connections, compiles the abstract "task execution plan" into a readily understandable visual picture. Different types of sub-tasks (such as data querying and conditional judgment) and dependencies (such as data flow and parallel execution) are clearly encoded using visual elements such as shape, color, and line type, fully revealing the AI's complete "thinking process" to the user, from goal decomposition to step planning and logical connections. This "visual exposure" of the AI's mental model allows users to intuitively understand what the system is doing, why it executes in this order, and how the steps are related. When users can clearly "see" the AI's logic, its decision-making is no longer mysterious, and this understanding forms the cornerstone of trust, eliminating anxiety and suspicion caused by the unknown.

[0041] Secondly, this invention empowers users with refined real-time control capabilities, thereby reducing the risk of overall task failure or unsatisfactory results due to initial AI misunderstandings or dynamic changes in requirements. In traditional models, if users discover that the AI's execution direction is incorrect, they often have to stop the task and redescribe it, a cumbersome and frustrating process. This invention provides three core intervention commands: dragging nodes, dragging endpoints of connectors, and right-click menu operations, forming a powerful and intuitive "on-site editing" language. When users observe a deviation between the AI's thinking direction (manifested as the connection relationships or order between nodes) and their own intentions, they can directly change dependencies by dragging connectors or adjust execution priorities and order by dragging nodes, essentially rewriting the AI's "program logic" at the flowchart level. For specific task execution details, the right-click menu provides functions such as "skip," "retry," "edit parameters," and "manually set results," allowing users to perform surgical-like precise intervention. This means that the entire task's execution logic is no longer pre-set and unchanging, but rather becomes a collaborative creation process that can be dynamically adjusted and continuously optimized under user supervision, fundamentally improving the system's flexibility and fault tolerance.

[0042] Furthermore, this invention constructs an efficient "intent alignment" and "cognitive synchronization" mechanism. This invention improves the accuracy and efficiency of human-machine collaboration while reducing communication costs and rework expenses caused by information asymmetry or misunderstandings between the two parties. In many complex scenarios, the user's true intent is subtle and gradually becomes clear, while the AI's initial planning may only capture surface-level needs. The interactive execution flow diagram becomes a shared and authoritative "cognitive anchor point" for both parties. By examining the flow diagram, users can quickly locate subtle differences between the AI's understanding and their own intent—for example, a key conditional branch being ignored, or two tasks that could have been executed in parallel being incorrectly set to execute sequentially. Subsequently, users can directly correct these deviations through the aforementioned graphical intervention, and the system responds and updates the flow diagram in real time. This process realizes a transformation from "users expressing vaguely in natural language" to "both parties reaching a precise consensus at the level of visual logic." It ensures that during execution, humans and AI maintain a synchronized understanding of the task objective, current state, and subsequent paths, eliminating many potential misunderstandings at the outset, making human-machine collaboration as smooth and efficient as team collaboration.

[0043] In some embodiments of this application, when performing real-time compilation based on the task execution plan and rendering it as an interactive execution flow graph, the following is included: Perform static analysis on the task execution plan to identify all subtasks and their dependencies.

[0044] Nodes are automatically deployed based on the resource requirements and estimated execution time of subtasks.

[0045] A context menu is generated for each node, and the context menu includes executable action options for that subtask.

[0046] Understandably, the first step of "statically analyzing the task execution plan to identify all subtasks and their dependencies" enhances the clarity of the system's self-awareness and the structured nature of its external expression, while lowering the mental barrier for users to understand the overall task complexity. Before compilation, the task execution plan is a structured object composed of data and logical relationships, but it remains an invisible abstraction to the user. The static analysis process, like a skilled architect, systematically interprets this blueprint, identifying each functional unit (subtask) and all the complex relationships (data flow, sequence, conditions, etc.) between units that are mutually constrained and dependent. The value of this process lies in its complete and comprehensive extraction of the discrete logical points and relationship lines within the system into a "relationship model" ready for visualization. This lays an absolutely accurate data foundation for subsequent intuitive presentation, ensuring strict consistency between the visualized content and the actual execution logic. For users, they no longer need to start from scratch and painstakingly reconstruct their AI thinking framework in their minds. Through this step, the system is ready to present them with a complete and structured "task map," directly reducing their cognitive burden.

[0047] Secondly, the step of "automatically laying out nodes based on the resource requirements and estimated execution time of subtasks" improves the readability, logic, and aesthetic consistency of the visualized information, and reduces the risk of visual confusion and logical misinterpretation caused by chaotic layout. Simply listing subtasks and dependencies, if poorly laid out, can create a messy "spider web," increasing the difficulty of understanding. The automatic layout algorithm acts as the "spatial planner" and "information designer" in this step. It doesn't just randomly or linearly arrange nodes, but intelligently arranges them spatially based on the inherent logic of the tasks (dependencies form the topological structure) and external attributes (resource requirements imply importance, estimated time affects visual weight). For example, it might place clusters of core tasks with dense dependencies at the visual center, horizontally align parallelizable tasks to imply their simultaneity, and allocate more space to time-consuming task nodes to draw attention. This semantic-based layout makes the direction of dependencies clearer, and the task execution path and critical path readily apparent. It encodes abstract logical relationships into intuitive spatial locations and arrangements, enabling users to quickly grasp the overall picture of a task, understand key points and bottlenecks by relying on the innate human ability to perceive graphics and space, thus improving the efficiency and accuracy of information transmission and reducing confusion caused by interface clutter.

[0048] Finally, the step of "generating a context menu based on each node, with the context menu including executable operation options for that subtask" fundamentally improves the accuracy, immediacy, and functional depth of user interaction, while reducing the operational and learning costs for users to translate intent into effective commands. Visualization itself provides a channel for observation and understanding, while the context menu embeds the gate to control. This step is key to "interaction empowerment," transforming the static "graph" into a dynamic "interface." Based on the type of each node (such as data query, API call) and its current state, the system dynamically generates highly relevant operation options (such as "retry" or "edit parameters" for query nodes, and "manually set results" for nodes waiting for input). This creates an immersive interactive experience of "what you see is what you control": the user's attention is focused on a specific link (node) in the flowchart, and all possible intervention actions (menu items) related to that link are ready and within reach. Users do not need to memorize complex commands or jump to other control panels. Intent and operation are seamlessly connected within the same visual context. This shortens the path from "identifying a problem" or "generating an idea" to "implementing intervention," enabling the pace of human-computer dialogue to evolve from a slow "turn-based" to a smooth "real-time collaboration," reducing interaction friction and making deep control and fine-tuning simple and natural.

[0049] In some embodiments of this application, when performing real-time compilation based on the task execution plan and rendering it as an interactive execution flow graph, the method further includes: Obtain the domain to which the current task belongs and its dependencies, and load the knowledge graph and historical database corresponding to the domain of the current task.

[0050] The comparison is performed based on the knowledge graph and pre-set constraint rules in the historical database, and the logical order is determined based on the comparison results.

[0051] The structural similarity is determined by matching the logical order with historical databases.

[0052] Based on logical order and structural similarity, a dependency verification report is generated. The dependency verification includes at least a conflict list, confidence score, and correction suggestions.

[0053] When the confidence score is lower than the preset threshold, the dependency relationship is adjusted based on the correction suggestions.

[0054] In some embodiments of this application, dependencies include data flow dependencies, sequence dependencies, conditional branch dependencies, and parallel execution dependencies.

[0055] When the execution of one subtask requires the output data of another subtask as input data, or when the execution result of one subtask affects the parameter selection or execution path of another subtask, it is determined to be a data flow dependency.

[0056] When there is no direct data relationship, but the data needs to be executed in the order of business logic, it is determined to be a sequential dependency.

[0057] When the execution of one or more subtasks depends on the result of a precondition judgment task, it is determined to be a conditional branch dependency.

[0058] When multiple subtasks have no data or logical connection and can be executed simultaneously, they are considered to be parallel execution dependencies.

[0059] Understandably, this invention, by introducing comparison and verification with domain knowledge graphs and historical databases, improves the logical rationality and business compliance of task execution plans, reducing implicit errors and execution risks caused by plans violating domain common sense or best practices. Traditional automated planning may rely solely on general algorithms or real-time data, easily generating dependencies that are technically feasible but logically absurd or inefficient. This invention, by loading a knowledge graph from the corresponding domain, uses expert experience, industry rules, and physical constraints (such as "international travel requires a visa") as pre-defined constraints to rigorously verify the initially generated dependencies. Simultaneously, matching with historical databases ensures that the new plan's structure aligns with past successful cases. This is equivalent to equipping the AI's planning process with an experienced "domain advisor" and "historical analyst," transforming implicit domain wisdom and collective experience into computable and executable verification standards. This preemptively eliminates numerous low-level errors and process loopholes that violate common sense or conventions before task execution, improving the reliability and maturity of the planning results.

[0060] Secondly, this invention enhances the transparency and interpretability of the system's decision-making process by generating a verification report that includes a conflict list, confidence score, and correction suggestions. This reduces the difficulty and time cost for users or maintenance personnel in diagnosing problems and debugging the system. When the system automatically identifies "sequential dependencies" or "parallel execution dependencies," the basis for this identification is often a black box to the user. This verification mechanism makes this judgment process public and structured. It not only provides the "what" of the dependency but also explains "why" this judgment was made and how credible it is through the verification report. The conflict list in the report directly points out specific problems in the planning that contradict known rules or historical patterns. The confidence score quantifies the overall credibility of the planning. The correction suggestions provide clear optimization directions. This externalizes the evaluation logic, which was originally hidden within the model, into a readable and deliberable "quality checklist." For users, this enhances their understanding and trust in the AI ​​planning results. For developers or operations personnel, this provides a valuable entry point for quickly locating planning defects and understanding system logic, making system maintenance and optimization more evidence-based and reducing the complexity of later operations and maintenance.

[0061] Furthermore, this invention, based on a mechanism that automatically triggers dependency adjustments using confidence thresholds, enhances the system's self-optimization and adaptive capabilities while reducing the operational burden and response delays caused by frequent manual intervention due to imperfect initial planning. A static system can only stall and issue an alarm when it detects planning problems. This invention endows the system with the ability for dynamic closed-loop correction. When the verification phase determines that the confidence level of a certain dependency is low, the system does not wait rigidly but can proactively adjust the dependencies based on correction suggestions (which themselves originate from knowledge graph rules or transformations of historical successful patterns). This means that the system possesses a basic autonomous capability of "discovering a problem, analyzing the problem, and attempting to solve the problem." This real-time cycle of "planning-verification-adjustment" allows the task execution plan to be continuously iterated and optimized during the generation phase, evolving towards a more reasonable and efficient direction. It reduces the absolute dependence on real-time monitoring and manual parameter tuning by operators, enabling the system to exhibit stronger robustness and autonomy when facing complex, variable, or ambiguous tasks, and improving the overall smoothness of operation.

[0062] In some embodiments of this application, when generating a dependency verification report based on logical order and structural similarity, the following are included: Perform static structural verification and dynamic behavioral verification of dependencies.

[0063] Static structure verification involves constructing a dependency graph with subtasks as nodes and dependencies as outgoing edges, and using a topological sorting algorithm to determine whether there are circular dependencies and subsequent tasks not covered by any branches in the dependency graph.

[0064] Dynamic behavior verification involves running a simulation in a lightweight simulation environment based on a dependency graph to determine whether the actual task execution path is consistent with the path specified in the dependency graph under various preset input and abnormal conditions, and to record the execution status and path deviation.

[0065] The confidence score for each dependency is determined based on static structural verification and dynamic behavioral verification.

[0066] Specifically, first, obtain the set of subtasks in the task execution plan. And the dependency set D, which will include each subtask Mapped to graph nodes Each dependency Mapped to directed edges , indicating from arrive Dependencies, resulting in a directed graph ,in, For a set of nodes, Given a set of directed edges, we then detect whether a directed cycle exists in the graph by calculating the value of each node. in-degree That is, pointing to The number of edges, initialize queue Q to contain all nodes with an in-degree of 0: Initialize the topological sequence table The loop continues until Q is empty: node V is removed from Q and added to the new node list. For each adjacent node V of V (i.e., there exists an edge), ):Will ,if If V is added to Q, the loop ends. If all nodes are sorted, then graph G is acyclic; otherwise, there is a circular dependency.

[0067] Conditional branch coverage integrity verification (ensuring that all possible result branches of each conditional judgment task have corresponding follow-up tasks): Identify the set of all conditional judgment task nodes. For each condition node 1. Determine the set of possible outcomes. (For example ), 2. For each result Find the set of nodes that are pointed to by the dependent edges originating from c and marked as result r. ,if If the value is 0, it is marked as "uncovered branch". 3. Summarize all uncovered branches and add them to the conflict list.

[0068] Static structure verification score calculation: for each dependency edge Define its static structure verification score : Then, dynamic behavior verification is performed: Task Simulator: for each subtask type Implement a function to simulate execution. Receive input data Output is generated based on preset test conditions (normal / abnormal). and execution status Data flow simulator: simulates the transfer and transformation of data between tasks; scheduler: determines the next executable task based on the dependency graph G and the task status.

[0069] Design a set of test cases: Test case definition: Each test case It is a triple ,in, For initial input data, Configure environmental conditions (such as network latency, resource limitations). Configure fault injection (specify which tasks will fail under what conditions), test case generation strategy: Normal path testing: Boundary condition testing covers typical inputs and normal environments: Fault injection testing covering input boundary values ​​and extreme environments: Random or systematic injection of task failures, total set of test cases: Then, simulated execution and path recording are performed for each test case. :1: Set the current time ready task set Completed task collection Execution path record 2:a. Loop until all tasks are completed or cannot continue: Select a task from R. Execute (if multiple simulators are available, they can be simulated in parallel), b. Call the corresponding simulator. c. Input the current input data, get the output and status, and record the execution events. d. Update e. Update dependencies: For each... Edges with source vertex , target node Decrement the count of unfinished prerequisite tasks by 1. If it reaches 0, then... join in f. Time Progression Finally, the loop ends, yielding the complete execution path. Next, path consistency and deviation detection are performed: First, valid partial order relationships are preset, and partial order relationships between tasks are defined according to the dependency graph G. If there exists from arrive The path, then ( Must (Previously), then deviation detection is performed: for test cases The actual execution path Check for violations of partial order relations: for each pair of tasks ,if But middle The execution timestamp is earlier than Then a violation is recorded, specifically for each dependent edge. If in a certain execution exist If execution begins before completion, the edge is marked as violated in that test case, and the number of violations for each dependent edge is then counted. Finally, the dynamic behavior verification score is calculated: the number of executions for each dependency edge is calculated. Calculate the dynamic behavior verification score: The score ranges from [0,1], where 1 indicates that there was no violation in all relevant executions.

[0070] Preset static validation weights and dynamic verification weights Finally, for each dependent edge Calculate the overall confidence score: ,because If static validation fails ( If the dynamic verification results are negative, the final confidence level will be significantly reduced.

[0071] Understandably, this invention, through static structural verification, enhances the logical rigor and structural integrity of the task execution plan, reducing the risk of the entire execution process collapsing or deadlocking due to fundamental design flaws. Traditional systems, when executing complex dependent tasks, often expose structural errors such as circular dependencies or incomplete conditional branch coverage only at runtime, leading to unpredictable failures. This invention incorporates a verification step based on graph theory (topological sorting) and logical completeness checks. It systematically scans the dependency graph, pre-identifying fatal circular dependencies such as "task A waits for task B to complete, while task B depends on task A," and logical vulnerabilities such as "when the condition is 'no,' subsequent processes have no path." This deep static analysis, performed during the "compilation" phase, intercepts many inherent defects that could lead to system stagnation or undefined behavior before startup, ensuring that the logical framework presented by the visualized flow graph is robust and consistent, thereby improving the robustness of the entire system's execution foundation.

[0072] Secondly, extensive testing in a lightweight simulation environment through dynamic behavior verification improves the predictability and fault tolerance of the system's behavior in the face of real-world uncertainties, while reducing the probability of the planning logic misbehaving in complex or abnormal scenarios. A statically correct structure may not necessarily produce the expected behavior in dynamic execution. The dynamic verification module constructs a "digital twin" sandbox environment containing multiple test cases (normal, boundary, and fault) to stress test the dependency graph. It not only checks whether tasks are executed sequentially, but more importantly, verifies whether the actual execution path of the system still conforms to or reasonably deviates from the established logic under various preset abnormal conditions (such as network latency, subtask failure, and input boundary values). This process transforms implicit logical risks that depend on specific execution environments into explicit and observable test results. For example, it can expose temporary deadlocks that may occur in a theoretically acyclic graph due to resource contention during actual scheduling. In this way, system planning is no longer just theoretical but undergoes testing in a virtual "real-world exercise," substantially improving its robustness and adaptability and reducing unexpected failures caused by environmental disturbances.

[0073] Furthermore, generating a verification report that includes a conflict list, confidence score, and corrective suggestions enhances the transparency, auditability, and collaborative nature of the system's decision-making process, while reducing the cognitive load and time cost for operations personnel and users in root cause analysis and system debugging. When planning encounters problems, traditional black-box systems typically only provide vague error codes. The verification report output by this solution is a structured "health check report." It not only identifies "where the problem is" (conflict list) but also assesses "the severity of the problem" (confidence score) and even provides "how to fix it" (corrective suggestions). For each dependency's confidence score, a precise quality metric is formed by combining static "structural health" and dynamic "behavioral compliance." This externalizes and standardizes the system's internal self-evaluation process into a shareable and discussable knowledge carrier. Developers and users can clearly understand the system's judgment criteria for its own planning quality, quickly locate weaknesses, and make efficient adjustments based on intelligent suggestions, making system maintenance, optimization, and human-machine collaborative decision-making evidence-based and goal-oriented.

[0074] In some embodiments of this application, when generating a dependency verification report based on logical order and structural similarity, the method further includes: Dependency graphs are used to determine whether multiple subtasks marked as dependencies for parallel execution actually require the same exclusive resource.

[0075] Determine whether two subtasks with data flow dependencies are incorrectly marked as executable in parallel based on the dependency graph.

[0076] For subtasks used as conditional judgments, iterate through all possible output results and check whether each result maps to at least one subsequent executed subtask branch to determine if there are any logical loopholes.

[0077] In some embodiments of this application, when generating a dependency verification report based on logical order and structural similarity, the method further includes: Build a lightweight simulation environment that configures a simulation executor and a virtual data generator for each type of subtask.

[0078] Execute multiple verification test cases based on dependencies. The test cases should at least cover the normal execution path, boundary condition inputs, and failure scenarios simulating random subtask execution failures.

[0079] During the simulation, the system monitors and records whether the data transfer between tasks conforms to the definition of data flow dependencies, and whether the task execution sequence violates the conventions of sequential and parallel execution dependencies. Based on the simulation results, each dependency is marked with a dynamic verification status, including: verification passed, verification failed, or verification questionable.

[0080] Understandably, firstly, the targeted inspection rules at the static verification level enhance the system's ability to pre-identify potential resource conflicts and implicit logical contradictions, reducing the risk of runtime deadlocks, data races, and process interruptions caused by "assuming" parallelization or negligence in condition design during the planning stage.

[0081] For resource exclusivity checks related to parallel dependencies, dependency verification is extended from the purely logical level to the physical resource constraint level. It recognizes that if tasks marked as "parallelizable" need to compete for the same "lock" in the real world (e.g., writing to the same file, calling the same rate-limited API), then such parallel planning is theoretically infeasible, and forced execution will inevitably lead to conflicts or errors. This check injects domain knowledge and physical constraints into the logical verification in advance, avoiding the delivery of planning diagrams with inherent resource conflict defects, thereby improving the executability of the planning scheme in real-world environments.

[0082] The checks for data flow dependencies and parallel tag consistency delve into the logical kernel, preventing self-contradictory planning. If task A must pass data to task B (strong data flow dependency), then the two must have a strict temporal relationship and can never truly execute "simultaneously." Automatically detecting and correcting such contradictory tags ensures the self-consistency and consistency of the system's internal logical model, fundamentally eliminating unpredictable behavior caused by paradoxes in the planning itself.

[0083] Mandatory traversal checks on the completeness of conditional branches are a rigorous safeguard for the system's "decision robustness." It requires that all possible paths for each conditional judgment (e.g., "yes" and "no") must have a clear task assignment, ensuring that the system has a path to follow under any decision outcome and avoids falling into a "no response" or "undefined" state. This improves the system's behavioral completeness and certainty in the face of various decision outcomes, reducing the probability of process "blocking" or requiring exception handling due to missing branches.

[0084] Secondly, the detailed simulation environment construction and test execution procedures at the dynamic verification level improve the coverage, authenticity, and interpretability of verification tests, thereby reducing the possibility of failing to discover deep-seated and concurrent defects due to a single test scenario or vague monitoring indicators.

[0085] The construction of a modular simulation environment (simulator and data generator) transforms dynamic verification from a simple process deduction into a "high-fidelity" test capable of highly simulating the semantics of real task execution and environmental interactions. Different types of subtasks possess customized simulated behaviors, generating expected data flows and simulating various states such as success, failure, and delay. This enhances the testing environment's ability to represent the complexities of reality, making the problems exposed in the simulation more relevant and instructive in practice.

[0086] A systematic, multi-dimensional test case design (normal, boundary, and fault) ensures that verification is not merely a formality, but rather a comprehensive "check-up" of the dependency relationships under various pressures. In particular, fault injection testing actively simulates random task failures to verify whether the fault tolerance and recovery mechanisms of the entire task flow function as designed in the dependency graph. This incorporates the system's behavior under abnormal conditions into the scope of mandatory verification, enhancing its resilience to unexpected situations and the foresight of its planning.

[0087] On the other hand, see Figure 2 As shown, this application also provides an artificial intelligence-based interaction method, applied to the aforementioned artificial intelligence-based interaction system, comprising the following steps: Obtain the user's task request and generate the corresponding task execution plan, which includes several subtasks with dependencies.

[0088] The task execution plan is compiled in real time and rendered into an interactive execution flow graph, where each subtask is an interactive node in the interactive execution flow graph, and the dependencies between subtasks are editable connection lines connecting the nodes.

[0089] When generating the corresponding task execution plan, the execution status of each node in the interactive execution flow graph is updated in real time, and the visual status of each node in the interactive execution flow graph is updated in real time based on the execution status. The execution status includes at least pending execution, executing, successful, failed, and waiting for user input.

[0090] Obtain the user's graphical operations on specific nodes or connections in the interactive execution flow graph, and compile the graphical operations into intervention instructions for the task execution logic.

[0091] Based on intervention commands, the task execution plan is adjusted in real time, and the structure and status of the interactive execution flow graph are updated.

[0092] In summary, the beneficial effects of this invention are as follows: (1) This invention realizes a fundamental paradigm shift in artificial intelligence interaction from "black box automation" to "white box collaboration," improving the transparency and comprehensibility of the interaction process. Through the compilation module, the abstract execution plan is "translated" into an intuitive graphical execution flow diagram, making the complex task logic (subtask composition, dependencies, execution paths) clear at a glance. Users can clearly see the AI's "thinking steps" and current work focus. This visual exposure of the execution process transforms invisible computation into visible processes, eliminating the confusion and anxiety caused by mystery. The real-time updates and visual feedback of node status by the data processing module provide users with continuous and clear status synchronization. This immediate and rich progress feedback eliminates the uncertainty and guesswork during the waiting process, enabling users to establish accurate psychological expectations of task progress, thereby shifting their attention from worrying about the process to focusing on the results and decisions.

[0093] (2) This invention designs nodes and connections to be "interactive" and "editable," allowing users to directly intervene in the execution logic through intuitive graphical operations (such as dragging, reconnecting, and clicking menus). This means that users are no longer the "initiators" of commands, but have been upgraded to "co-editors" and "real-time supervisors" of the process. This empowerment from observer to participant changes the human-machine relationship, enhances user confidence and immersion, and makes AI a truly intelligent collaborator at the user's command. In the visual interactive flow diagram constructed by this invention, errors are accurately located to specific nodes (such as marked as "failed"), and their impact range is clearly shown through the dependency graph. Users or the system can intervene in a targeted manner to achieve local repair rather than global restart, improving the system's resilience to abnormal situations and reducing the failure rate caused by ambiguous or dynamically changing requirements. This invention supports dynamic adjustments during execution. When users change the node order or edit node parameters by dragging, the execution module can reorganize the task plan in real time based on the new intervention instructions. This ability to adapt to dynamic needs in real time enables the system to flexibly respond to changes in user thinking, transforming many situations that might otherwise lead to task failure or unsatisfactory results into a smooth collaborative optimization process.

[0094] Those skilled in the art will understand that embodiments of this application can be provided as methods, systems, or computer program goods. Therefore, this application can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, this application can take the form of a computer program goods embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0095] This application is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program goods according to embodiments of this application. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, generate instructions for implementing the flowchart... Figure 1 One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0096] These computer program instructions may also be stored in a computer-readable storage device that can direct a computer or other programmable data processing device to operate in a particular manner, such that the instructions stored in the computer-readable storage device produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.

[0097] These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0098] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention and not to limit it. Although the present invention has been described in detail with reference to the above embodiments, those skilled in the art should understand that modifications or equivalent substitutions can still be made to the specific implementation of the present invention. Any modifications or equivalent substitutions that do not depart from the spirit and scope of the present invention should be covered within the protection scope of the claims of the present invention.

Claims

1. An interactive system based on artificial intelligence, characterized in that, include: The acquisition module is configured to acquire user task requests and generate corresponding task execution plans, which include several sub-tasks with dependencies. The compilation module is configured to compile in real time based on the task execution plan and render it into an interactive execution flow graph, wherein each subtask is an interactive node in the interactive execution flow graph, and the dependencies between the subtasks are editable connection lines connecting the nodes; The data processing module is configured to update the execution status of each node in the interactive execution flow graph in real time when generating the corresponding task execution plan, and update the visual status of each node in the interactive execution flow graph in real time based on the execution status. The execution status includes at least pending execution, executing, successful, failed, and waiting for user input. The data processing module is also configured to acquire graphical operations performed by the user on specific nodes or connections in the interactive execution flow graph, and to compile the graphical operations into intervention instructions for the task execution logic; The execution module is configured to adjust the task execution plan in real time based on the intervention command, and update the structure and status of the interactive execution flow graph.

2. The artificial intelligence-based interactive system according to claim 1, characterized in that, The intervention commands include at least dragging nodes, dragging the endpoints of connecting lines, and right-clicking a node and selecting a menu item; The drag-and-drop node is configured to change the position of the node in the interactive execution flow graph and adjust the execution priority and / or order of the subtasks; The drag-and-drop connection is configured to disconnect the connection from the original node and connect it to another node, thereby changing the task dependency. The right-clicking of a node and selection of a menu item is configured to execute a specific operation instruction on the subtask, which includes at least skip, retry, edit parameters, view details, and manually set the result.

3. The artificial intelligence-based interactive system according to claim 2, characterized in that, The interactive execution flow graph is in the form of a directed graph, wherein: The nodes use differentiated visual encoding to represent different types of the subtasks, and the types include at least data query, calculation, condition judgment, user input waiting, and external API call; The connection lines use differential visual encoding to represent different types of dependencies, including at least sequential dependencies, data flow dependencies, conditional branches, and parallel execution.

4. The artificial intelligence-based interactive system according to claim 3, characterized in that, When performing real-time compilation and rendering into an interactive execution flow graph based on the task execution plan, the following is included: Perform static analysis on the task execution plan to identify all the subtasks and their dependencies; The nodes are automatically laid out based on the resource requirements and estimated execution time of the sub-tasks. A context menu is generated for each node, and the context menu includes executable action options for that subtask.

5. The artificial intelligence-based interactive system according to claim 4, characterized in that, When performing real-time compilation and rendering into an interactive execution flow graph based on the task execution plan, the method further includes: Obtain the domain to which the current task belongs and its dependencies, and load the knowledge graph and historical database corresponding to the domain of the current task; The knowledge graph and the historical database are compared using preset constraint rules, and their logical order is determined based on the comparison results. Based on the logical order, the structural similarity is determined by matching it with the historical database. Based on the logical order and the structural similarity, a dependency verification report is generated. The dependency verification includes at least a conflict list, a confidence score, and correction suggestions. When the confidence score is lower than a preset threshold, the dependency relationship is adjusted based on the correction suggestion.

6. The artificial intelligence-based interactive system according to claim 5, characterized in that, The dependencies include data flow dependencies, sequence dependencies, conditional branch dependencies, and parallel execution dependencies; When the execution of one of the subtasks requires the output data of another subtask as input data, or when the execution result of one subtask affects the parameter selection or execution path of another subtask, it is determined to be a data flow dependency. When there is no direct data relationship, but the data needs to be executed in the order of business logic, it is determined to be a sequential dependency. When the execution of one or more of the subtasks depends on the result of a precondition judgment task, it is determined to be a conditional branch dependency; When multiple subtasks have no data or logical connection and can be executed simultaneously, they are considered to be parallel execution dependencies.

7. The artificial intelligence-based interactive system according to claim 6, characterized in that, When generating a dependency verification report based on the logical order and structural similarity, the following are included: The dependencies are subjected to static structure verification and dynamic behavior verification. The static structure verification includes constructing a dependency graph with the subtasks as nodes and the dependencies as outgoing edges, and determining whether there are circular dependencies and subsequent tasks not covered by any branches in the dependency graph based on the topological sorting algorithm. The dynamic behavior verification includes performing a simulation in a lightweight simulation environment based on the dependency graph, determining whether the actual task execution path is consistent with the path specified in the dependency graph under various preset input and abnormal conditions, and recording the execution status and path deviation. The confidence score for each dependency is determined based on the static structure verification and the dynamic behavior verification.

8. The artificial intelligence-based interactive system according to claim 7, characterized in that, When generating a dependency verification report based on the logical order and the structural similarity, the following additional steps are also included: Based on the dependency graph, determine whether multiple subtasks marked as parallel execution dependencies actually require the same exclusive resource; Based on the dependency graph, determine whether two subtasks with data flow dependencies are simultaneously and incorrectly marked as executable in parallel; For the subtask used as a conditional judgment, iterate through all possible output results and check whether each result maps to at least one subsequent executed subtask branch to determine if there are any logical loopholes.

9. The artificial intelligence-based interactive system according to claim 8, characterized in that, When generating a dependency verification report based on the logical order and the structural similarity, the following additional steps are also included: The lightweight simulation environment is constructed, which configures a simulation executor and a virtual data generator for each type of subtask; Execute multiple verification test cases based on the aforementioned dependencies. The test cases at least cover the normal execution path, boundary condition inputs, and failure scenarios simulating random subtask execution failures. During the simulation, the system monitors and records whether the data transfer between tasks conforms to the definition of the data flow dependency, and whether the task execution sequence violates the conventions of sequential dependency and parallel execution dependency. Based on the results of the simulation, the system marks each dependency with a dynamic verification status, including: verification passed, verification failed, or verification questionable.

10. An artificial intelligence-based interaction method, applied to the artificial intelligence-based interaction system as described in any one of claims 1-9, characterized in that, include: Obtain the user's task request and generate a corresponding task execution plan, which includes several sub-tasks with dependencies. The task execution plan is compiled in real time and rendered into an interactive execution flow graph, wherein each subtask is an interactive node in the interactive execution flow graph, and the dependencies between the subtasks are editable connection lines connecting the nodes; When generating the corresponding task execution plan, the execution status of each node in the interactive execution flow graph is updated in real time, and the visual status of each node in the interactive execution flow graph is updated in real time based on the execution status. The execution status includes at least pending execution, executing, successful, failed, and waiting for user input. Obtain the user's graphical operations on specific nodes or connections in the interactive execution flow graph, and compile the graphical operations into intervention instructions for the task execution logic; Based on the intervention instructions, the task execution plan is adjusted in real time, and the structure and status of the interactive execution flow graph are updated.

Images