A dynamic interface interaction method in an artificial intelligence task execution process

Abstract

This invention relates to the field of artificial intelligence interaction technology, specifically to a dynamic interface interaction method during the execution of artificial intelligence tasks. Responding to user task instructions, the method performs task parsing and execution planning to generate a task execution scheme. Based on the data characteristics and interaction requirements of each step in this scheme, an interface description configuration is dynamically generated. The interface description configuration is parsed, and corresponding visual components are instantiated and rendered from a pre-set component library to generate a task-accompanying interface. During task execution, state change events are distributed through a state synchronization channel. The task-accompanying interface captures these state change events according to a data subscription interface and drives the corresponding visual components to update their local views. This invention solves the technical problems of passive and static interfaces and separation from task execution logic in traditional human-computer interaction, achieving visualization of the execution process and real-time user intervention, significantly improving the transparency of interaction, control efficiency, and user experience.

Description

Technical Field

[0001] This invention relates to the field of artificial intelligence interaction technology, and more specifically to a dynamic interface interaction method during the execution of artificial intelligence tasks. Background Technology

[0002] With the increasing prevalence of artificial intelligence technology, users driving systems to perform complex tasks via natural language commands has become a common human-computer interaction mode. Existing solutions typically employ a linear task processing flow: the system first parses the user's commands and generates an internal execution plan, then sequentially calls the corresponding tools or models in the background to execute the plan. After all steps are completed, the results are finally summarized and presented to the user. In this process, the user interface primarily acts as a static result display terminal or initial command input box, and its functionality is separate from the actual task execution logic.

[0003] This architecture, where task execution and user interface interaction are disconnected, leads to significant user experience bottlenecks. Once execution begins, users enter a black-box waiting period, unable to perceive task progress in real time, understand the system's thought process, observe the generation of intermediate results, or effectively supervise, intervene, or guide the task during execution. For example, when a task involves multiple steps or branching choices, users cannot know which stage the system is currently processing, nor can they adjust instructions based on interim results. This weakens users' sense of control and trust in complex tasks, especially when dealing with time-consuming or logically complex tasks, significantly increasing cognitive load and uncertainty. Although some current systems attempt to provide limited feedback through progress bars, simple status text, or phased result displays, this feedback is often predefined and coarse-grained, lacking deep connection to the task's inherent logical structure and dynamic evolution. The interface cannot dynamically and structurally adapt to the unique execution path and real-time status of each task. Therefore, existing user interfaces are inherently lagging and passive, failing to achieve deep collaboration with the AI ​​task execution agent, thus limiting the efficiency and naturalness of human-machine collaboration.

[0004] Therefore, there is an urgent need for a technical solution that can deeply integrate task execution logic with user interface, so that the interface can dynamically and in real time map and reflect the complete logical flow and state changes of task execution, thereby transforming users from passive waiters into active supervisors and collaborators, and truly improving the transparency, controllability and interaction efficiency of intelligent task execution process. Summary of the Invention

[0005] The purpose of this invention is to provide a dynamic interface interaction method during the execution of artificial intelligence tasks. By generating an interface description configuration associated with the task execution logic and establishing a state synchronization channel, the interface can reflect the task execution status through real-time event updates, solving the problem of the interface being disconnected from the backend logic and improving the transparency and controllability of the interaction.

[0006] To achieve the above-mentioned technical objectives and effects, the present invention is implemented through the following technical solution:

[0007] A dynamic interface interaction method during the execution of an artificial intelligence task, comprising:

[0008] In response to user task instructions, perform task parsing and execution planning, and generate task execution schemes;

[0009] Based on the data characteristics and interaction requirements of each step in the task execution scheme, an interface description configuration is dynamically generated. The interface description configuration includes the visual component identifiers and layout parameters corresponding to each step, as well as a data subscription interface for establishing a mapping relationship between visual component attributes and task execution status fields.

[0010] The interface description configuration is parsed, and the corresponding visual components are instantiated and rendered from the preset component library to generate the task-accompanying interface.

[0011] Execute the task execution plan and establish a state synchronization channel between the task execution thread and the task-accompanying interface;

[0012] During task execution, state change events are distributed through the state synchronization channel; the task-accompanying interface captures the state change events according to the data subscription interface and drives the corresponding visual components to update the local view.

[0013] Furthermore, generating the interface description configuration includes: identifying the output data type and expected interactive behavior of each step in the task execution plan; matching component identifiers with corresponding rendering and interactive capabilities from the component description library; and constructing a structured description file containing the component identifiers, layout parameters, and data binding paths.

[0014] Furthermore, when performing the task analysis and execution planning, personalized adaptation is also performed based on user profiles and / or historical interaction habits.

[0015] Furthermore, the data subscription interface is configured to establish a mapping relationship between component attributes and backend task status fields; the local view update includes: when a status change event containing a specific field key value is received, updating the display attributes of the target component that has subscribed to that field key value.

[0016] Furthermore, the state synchronization channel adopts a long connection mechanism, and the data packet of the state change event includes: target component ID, event type, and state payload.

[0017] Furthermore, the task-accompanying interface is configured to support two-way collaboration between execution status feedback and in-process interaction; the local view update also includes: displaying the execution nodes of the task execution plan; when execution reaches a node requiring manual confirmation or branch selection, the task-accompanying interface is triggered to load interactive components according to the interface description configuration; and in response to feedback data input by the user through the interactive components, the subsequent task execution plan is adjusted in real time.

[0018] Furthermore, executing the task execution plan includes: invoking one or more predefined functional tools to perform specific operations.

[0019] Furthermore, the task parsing and execution planning, the generation of the task-accompanying interface, and the execution of the task execution plan are respectively implemented collaboratively by the task planning module, interface design module, interface interaction module, interface update module, and task execution module in the system, and the modules interact with each other through an agreed communication protocol.

[0020] On the other hand, this invention proposes a dynamic interface interaction system for the execution of artificial intelligence tasks, comprising:

[0021] The task planning module is used to respond to user task commands, perform task parsing and execution planning, and generate task execution plans.

[0022] The interface design module is used to dynamically generate interface description configuration based on the data characteristics and interaction requirements of each step in the task execution scheme. The interface description configuration includes the visual component identifiers and layout parameters corresponding to each step, as well as a data subscription interface for establishing the mapping relationship between visual component attributes and task execution status fields.

[0023] The interface interaction module is used to parse the interface description configuration, call the corresponding visual components from the preset component library for instantiation and rendering, and generate the task-accompanying interface.

[0024] The task execution module is used to execute the task execution plan and establish a state synchronization channel between the task execution thread and the task-accompanying interface.

[0025] The interface update module is used to distribute state change events through the state synchronization channel during task execution, so that the task-accompanying interface can capture the state change events according to the data subscription interface and drive the corresponding visual components to perform local view updates.

[0026] On the other hand, the present invention proposes an electronic device comprising:

[0027] Memory, used to store computer programs;

[0028] A processor is used to implement the steps of the dynamic interface interaction method in the execution process of the above-described artificial intelligence task when executing the computer program.

[0029] The beneficial effects of this invention are:

[0030] This invention generates interface description configurations synchronously during the task parsing phase and uses a data subscription interface to bind task status data with interface component attributes, enabling the task-related interface to map the background execution logic in real time and in a structured manner. This transforms the previously invisible task decomposition, tool call sequences, and intermediate data flow into front-end visualized component rendering and partial view updates, effectively solving the problem of opaque task execution processes in traditional solutions and significantly enhancing user observability and trust in system behavior and progress.

[0031] Because the interface description configuration defines the association logic between each stage of task execution and the interface interaction components, the system of this invention can trigger the loading of interaction components based on the real-time status when user intervention is required in the task flow. This allows users to directly adjust parameters, select paths, or verify results for the executing task based on the presented intermediate results and progress. This realizes a paradigm shift from one-way command issuance to bidirectional collaboration based on real-time context, improving users' control over complex tasks and the reliability of results.

[0032] This invention employs a component-based and configuration-driven design. The task planning, interface generation, and task execution modules communicate via a state synchronization channel, and a structured description file serves as the abstract interface between business logic and the presentation layer, achieving high cohesion and low coupling. This allows for expansion of functional tools or changes to interface styles only requiring adjustments to the corresponding component library or description configuration, without refactoring the entire codebase, ensuring the flexibility and maintainability of the solution. Furthermore, this architecture provides a technical foundation for integrating user profile data into the interface description generation stage to achieve personalized adaptation, enhancing the solution's versatility.

[0033] Of course, any product implementing this invention does not necessarily need to achieve all of the advantages described above at the same time. Attached Figure Description

[0034] To more clearly illustrate the technical solutions of the embodiments of the present invention, the accompanying drawings used in the description of the embodiments will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0035] Figure 1 This is a schematic diagram of the overall process of the present invention;

[0036] Figure 2 This is a timing diagram of the system of the present invention. Detailed Implementation

[0037] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0038] This embodiment describes a specific implementation of a dynamic interface interaction method during the execution of an artificial intelligence task. The method is implemented by constructing a collaborative system consisting of a task planning module, an interface design module, an interface interaction module, a task execution module, and an interface update module. The modules interact with each other using an agreed-upon communication protocol.

[0039] In some embodiments, the task planning module first receives natural language instructions input by the user. This module has a built-in or connected semantic reasoning engine based on a Large Language Model (LLM) to perform deep intent recognition and task decomposition on the instructions. Specifically, the task planning module transforms the user's natural language instructions into a directed acyclic graph (DAG) structure containing multiple atomic subtasks. For each atomic subtask node in the DAG, the system extracts its task feature vector (…). The task feature vector contains feature encodings in the following dimensions: input and output data modal features:

[0040] Identify the data type processed in this step (such as plain text stream, time-series numerical data, binary image data, JSON structured data, etc.);

[0041] Interaction intent characteristics: Identify the expected user behavior for this step (e.g., viewing only, requiring one confirmation, requiring parameter input, requiring multiple rounds of dialogue, etc.);

[0042] Semantic context features: Based on the context embedding of task instructions, it represents the semantic role of the step in the overall task flow (such as "background introduction", "data analysis", "result summary").

[0043] In some embodiments, when performing task parsing and execution planning, the task planning module also accesses a user profile database to obtain user profile information, including the user's professional field, operational proficiency level, and historical preferences for frequently used components. For example, for users marked as 'expert,' the system tends to select components with higher information density (such as multidimensional data tables) in the interface description configuration, while for 'novice' users, it prioritizes components with stronger guidance (such as step-by-step guide cards). Historical interaction habit data can also influence the generation of layout parameters, such as placing components corresponding to areas of high-frequency clicks in the user's history at the visual focus position.

[0044] It should be understood that during the planning process, the interface design module will generate a structured interface description configuration based on the data characteristics and interaction requirements of the task steps, using a dynamic mapping mechanism based on vector similarity matching. This configuration defines the hierarchical structure, attribute parameters, and data subscription interfaces of the interface components.

[0045] The pre-built component library stores several visual components, each of which is pre-associated with a component capability feature vector. This vector numerically encodes the component's rendering overhead, interaction depth (such as whether it supports editing and drill-down), and applicable data types (such as a line chart component suitable for displaying time-series data).

[0046] The interface design module calculates the task feature vector of the current subtask. ) and the component capability feature vectors of each candidate component in the component library ( Semantic similarity between (e.g., calculating cosine similarity) This is used to filter for the best matching component. For example, when When the instruction is "output as time-series numerical values" and "interaction intent is trend analysis," the system calculates and finds that the vector similarity score of the "interactive line chart component" is higher than that of the "static table component," and therefore maps this step to the line chart component. Finally, the module encapsulates the selected component identifier, layout parameters, and data binding relationships into a structured interface description configuration in JSON format.

[0047] Furthermore, the interface description configuration generation process also integrates an environment context-aware adaptive reasoning mechanism. Based on the above vector matching, the interface design module constructs an environment context vector by collecting real-time status features of the device (including network bandwidth status, screen resolution, and battery level). And it is introduced as a weighting factor into the component decision model.

[0048] The system pre-sets a degradation strategy based on rule or model reasoning. In this embodiment, the adaptation is based on the following strategy:

[0049] when When the system indicates that the current device is in a weak network environment (e.g., bandwidth < 500Kbps), it will automatically correct the component type when generating the interface description, replacing the original high-bandwidth-consuming 'high-definition video stream component' with the low-bandwidth-consuming 'keyframe image and text summary component' or 'plain text log component'.

[0050] when When the device is identified as being in 'foldable screen unfolded state' or 'desktop state', the layout_mode field in the interface description configuration is set to multi_column to display 'task execution log' and 'intermediate result preview' in parallel; otherwise, if it is in portrait mode on a mobile device, a stack layout configuration is generated.

[0051] In this embodiment, the inference agent generates the following JSON-formatted interface description configuration:

[0052] {

[0053] "view_meta": {

[0054] "view_id": "task_monitor_v1",

[0055] "layout_strategy": "responsive_flow", / / Responsive flow layout

[0056] "context_sensitivity": ["network", "battery"] / / Declare sensitivity to network and battery usage

[0057] },

[0058] "components": [

[0059] {

[0060] "id": "realtime_chart_01",

[0061] "type": "DynamicTrendChart",

[0062] "layout_constraints": {

[0063] "width": "match_parent",

[0064] "min_height": "300dp",

[0065] "render_priority": "high"

[0066] },

[0067] "adaptive_rules": [ / / Context-aware rules]

[0068] {

[0069] "condition": "context.network_bandwidth < 500kbps", / / Weak network detection

[0070] "action": "downgrade_component",

[0071] "target_type": "StaticSummaryCard", / / Downgraded to a static card

[0072] "params": { "auto_refresh": false}

[0073] },

[0074] {

[0075] "condition": "context.battery_level < 0.2", / / Low battery detection

[0076] "action": "reduce_animation",

[0077] "params": { "frame_rate": 15}

[0078] }

[0079] ],

[0080] "subscription": { / / Data subscription interface

[0081] "topic": "task.runtime.data_stream",

[0082] "transform_pipeline": ["normalize", "moving_average"] / / Front-end preprocessing pipeline

[0083] }

[0084] },

[0085] {

[0086] "id": "interaction_panel",

[0087] "type": "DecisionGroup",

[0088] "visibility_logic": "task.state == 'awaiting_confirmation'", / / Dynamic visibility

[0089] "interaction_hooks": {

[0090] "on_commit": {

[0091] "event_type": "resume_task_signal",

[0092] "payload_schema": { "selected_option": "string", "timestamp": "int64"}

[0093] }

[0094] }

[0095] } ]

[0097] }

[0098] In some embodiments, the interface interaction module receives and parses the interface description configuration. The module traverses the configuration tree, calls the corresponding visual components from a pre-set local or cloud component library for instantiation and rendering, and generates the task-accompanying interface. Simultaneously, the interface interaction module completes the data subscription registration for each component based on the "subscription" field in the description file, establishing a mapping relationship between component attributes and backend task status fields.

[0099] The task execution module executes the task execution plan and establishes a state synchronization channel based on a full-duplex long connection (such as WebSocket over TLS). To minimize network bandwidth consumption and reduce rendering latency, this embodiment abandons full state transmission and instead adopts a synchronization protocol based on incremental patches.

[0100] Specifically, the task execution module maintains a "virtual task state tree" in memory, which is logically mapped to the DOM structure or component tree rendered by the front end. When the task state changes (e.g., a sub-step is completed or new data is generated), the back end performs a snapshot comparison of the state tree, comparing the changed state tree with the snapshot of the previous frame to calculate the difference set;

[0101] During the dynamic update phase, the system adopts an event-driven architecture. The atomic operation instruction set is designed to describe the largest view changes with the minimum instruction length, and mainly includes the following instruction types:

[0102] OP_INSERT(path, node_data): Inserts a new task node at the specified path (e.g., dynamically adding an approval step).

[0103] OP_UPDATE(path, key, value): Updates the attribute value of the specified node (e.g., updating the percent value of a progress bar or the buffer content of a log terminal).

[0104] OP_MOVE(path, new_index): Adjusts the order of nodes (e.g., rearranges the list of tasks to be executed according to priority).

[0105] OP_DELETE(path): Removes invalid or obsolete component nodes.

[0106] For example, when the task execution module completes the first step, it sends the following standard event via the WebSocket channel:

[0107] {

[0108] "seq_id": 1024,

[0109] "timestamp": 1715068800500,

[0110] "patches": [

[0111] { "op": "OP_UPDATE", "path": "root.components['progress_01']", "key": "current_step", "val": 2},

[0112] { "op": "OP_INSERT", "path": "root.components['log_terminal']", "val": { "line": "Step 1 completed.", "style": "info"}} ]

[0114] }

[0115] Upon receiving an event update, the task-accompanying interface (front-end) will automatically capture the event and change the progress status.

[0116] Furthermore, the task-related interface is configured to support two-way collaboration. When the task execution reaches a node requiring manual confirmation or branch selection, the task execution module sends a specific interaction request event. According to the interface description configuration, the interface interaction module dynamically loads interactive components (such as confirmation buttons or tabs) and sends the user's feedback data input through the interactive components back to the task execution module in real time, thereby adjusting the subsequent task execution plan.

[0117] To illustrate the effectiveness of this solution more intuitively, let's take the "intelligent patent drafting assistant" scenario as an example:

[0118] 1. Initial Planning: The user inputs "Write a patent for a drone". The system generates a DAG containing three nodes: "Prior Art Search", "Claim Generation", and "Specification Writing", and pushes the initial interface configuration, with the left side rendered as the "Search Progress Flow" and the right side as the "Outline Editor".

[0119] 2. State Synchronization: During the "Existing Technology Retrieval" phase, the backend generates an OP_INSERT patch for each document crawled. The frontend uses a shadow tree mechanism to smoothly insert the document card into the left-hand list without refreshing the page.

[0120] 3. Triggering Collaboration: When a highly similar document is retrieved, the system determines that manual verification is required and suspends the current node. The front-end receives the INTERACTION_REQUIRED event and pops up a "Comparison Confirmation Overlay" in the center of the interface, displaying the highlighted comparison abstract.

[0121] 4. Dynamic Restructuring: When a user clicks "This document does not constitute a conflict," the system receives feedback, removes the original "Avoidance Design" branch, and immediately adds a new "Distinguishing Technical Feature Extraction" subtask node, automatically advancing the progress bar to the next stage.

[0122] Through the above implementation methods, this invention achieves deep integration of task execution logic and user interface. Utilizing a configuration-driven rendering mechanism and event-driven state synchronization, the system can achieve high-frequency, precise dynamic interface interaction with extremely low resource consumption, significantly improving the transparency of the AI ​​task execution process and the user experience.

[0123] Those skilled in the art will understand that the above embodiments are merely illustrative. Without departing from the core concept of this invention, various adjustments and modifications can be made to the specific implementation of each module, the selection of communication protocols, the field definitions of interface description configurations, and the composition of the component library. All changes and modifications should be considered to fall within the protection scope of this invention.

[0124] In summary, this invention proposes a dynamic interface interaction method during the execution of artificial intelligence tasks. Responding to user task instructions, it synchronously generates a task execution plan and interface description configuration during the task parsing and execution planning stages. Based on this configuration, it calls corresponding visual components from a pre-built component library for instantiation and rendering, generating a task-related interface associated with the task logic. During task execution, it distributes state change events through a state synchronization channel and drives corresponding visual components to update local views based on a data subscription interface. The corresponding system includes collaborative modules for task planning, interface design, interface interaction, task execution, and interface updates. This invention solves the technical problems of passive and static interfaces and separation from task execution logic in traditional human-computer interaction. Through deep integration of configuration-driven and event-driven approaches, it achieves visualization of the execution process and real-time user intervention, significantly improving the transparency of interaction, control efficiency, and user experience.

[0125] The preferred embodiments of the present invention disclosed above are merely illustrative of the invention. These preferred embodiments do not exhaustively describe all details, nor do they limit the invention to the specific implementations described. Clearly, many modifications and variations can be made based on the content of this specification. This specification selects and specifically describes these embodiments to better explain the principles and practical applications of the invention, thereby enabling those skilled in the art to better understand and utilize the invention. The invention is limited only by the claims and their full scope and equivalents.

Claims

1. A dynamic interface interaction method during the execution of an artificial intelligence task, characterized in that, include: In response to user task instructions, perform task parsing and execution planning, and generate task execution schemes; Based on the data characteristics and interaction requirements of each step in the task execution scheme, an interface description configuration is dynamically generated. The interface description configuration includes the visual component identifiers and layout parameters corresponding to each step, as well as a data subscription interface for establishing a mapping relationship between visual component attributes and task execution status fields. The interface description configuration is parsed, and the corresponding visual components are instantiated and rendered from the preset component library to generate the task-accompanying interface. Execute the task execution plan and establish a state synchronization channel between the task execution thread and the task-accompanying interface; During task execution, state change events are distributed through the state synchronization channel; The task-accompanying interface captures the state change event based on the data subscription interface and drives the corresponding visual components to update the local view.

2. The method as described in claim 1, characterized in that, When performing the task analysis and execution planning, personalized adaptation is also performed based on user profiles and / or historical interaction habits.

3. The method as described in claim 1, characterized in that, The configuration for generating the interface description includes: identifying the output data type and expected interactive behavior of each step in the task execution plan; matching component identifiers with corresponding rendering and interactive capabilities from the pre-made component library; and constructing a structured description file containing the component identifiers, layout parameters, and data binding paths.

4. The method as described in claim 1, characterized in that, The data subscription interface is configured to establish a mapping relationship between component attributes and backend task status fields; the local view update includes: when a status change event containing a specific field key value is received, updating the display attributes of the target component that has subscribed to that field key value.

5. The method as described in claim 4, characterized in that, The state synchronization channel adopts a long connection mechanism, and the data packet of the state change event includes: target component ID, event type, and state payload.

6. The method as described in claim 1, characterized in that, The task-accompanying interface is configured to support two-way collaboration between execution status feedback and interaction during execution; The partial view update also includes: displaying the execution nodes of the task execution plan; when the execution reaches a node that requires manual confirmation or branch selection, triggering the loading of interactive components on the task's accompanying interface according to the interface description configuration; and adjusting the subsequent task execution plan in real time in response to feedback data input by the user through the interactive components.

7. The method as described in claim 1, characterized in that, The task parsing and execution planning, the generation of the task-accompanying interface, and the execution of the task execution plan are achieved collaboratively by the task planning module, interface design module, interface interaction module, interface update module, and task execution module in the system. The modules interact with each other through an agreed communication protocol.

8. The method as described in claim 1, characterized in that, The execution of the task execution plan includes: calling one or more predefined functional tools to perform specific operations.

9. A dynamic interface interaction system for the execution of artificial intelligence tasks, characterized in that, include: The task planning module is used to respond to user task commands, perform task parsing and execution planning, and generate task execution plans. The interface design module is used to receive the task execution plan and dynamically generate an interface description configuration based on the data characteristics and interaction requirements of each step in the plan. The interface description configuration includes the visual component identifiers and layout parameters corresponding to each step, as well as a data subscription interface for establishing a mapping relationship between visual component attributes and task execution status fields. The interface interaction module is used to parse the interface description configuration, call the corresponding visual components from the preset component library for instantiation and rendering, and generate the task-accompanying interface. The task execution module is used to execute the task execution plan and establish a state synchronization channel between the task execution thread and the task-accompanying interface. The interface update module is used to distribute state change events through the state synchronization channel during task execution, so that the task-accompanying interface can capture the state change events according to the data subscription interface and drive the corresponding visual components to perform local view updates.

10. An electronic device, characterized in that, include: Memory, used to store computer programs; A processor, configured to implement the steps of the dynamic interface interaction method during the execution of an artificial intelligence task as described in any one of claims 1 to 8 when executing the computer program.

Images