Multi-task agent execution method and device based on large language model, electronic equipment and storage medium

Abstract

The embodiment of the invention relates to the technical field of natural language processing, and discloses a multi-task agent execution method and device based on a large language model, electronic equipment and a storage medium, and the method comprises the following steps: receiving natural language target task description and constraint conditions input by a user; generating a task tree with a hierarchical structure and a dependency relationship; calculating an initial priority for each task node based on a preset priority scoring model, and dynamically adjusting the real-time priority of the task node according to the execution feedback of the task node to form a scheduling queue; asynchronously executing each task node in the task tree according to the scheduling queue, and calling a large language model to complete the generation of subtask contents corresponding to each node; and integrating the execution results of the task nodes, and generating a final output result oriented to the target task. According to the method, the intelligent agent system with self-adaptive dynamic scheduling, hierarchical task decomposition and stable long-range context management capabilities is constructed, so that efficient, reliable and user-controllable multi-task automation is realized.

Description

TECHNICAL FIELD

[0001] Embodiments of the present application relate to the technical field of natural language processing, and in particular to a multi-task agent execution method and device based on a large language model, an electronic device, and a storage medium. BACKGROUND

[0002] In recent years, the rapid development of large-scale pre-training language models (LLMs) has significantly promoted the leap in the capabilities of artificial intelligence in language understanding, logical reasoning, and complex task planning. The new generation of models represented by GPT-4 have made breakthroughs in cross-domain generalization, context semantic modeling, and decision generation capabilities, making it possible to build an agent system with autonomous planning, continuous task execution, and dynamic feedback adjustment capabilities. The agent system is gradually changing from traditional passive response question answering to active task planning and execution, and its potential application scenarios cover software development automation, business decision assistance, content generation, and intelligent services in multiple fields.

[0003] Under this background, AgentGPT, as a natural language driven agent framework based on GPT-4, realizes a closed-loop execution process from user goal understanding to task chain automatic generation and completion by combining task generation, scheduling execution, result feedback, and process visualization. Compared with early rule-dependent automation systems, the advantages of AgentGPT lie in its ability to directly drive task decomposition and planning through natural language, high flexibility, strong context association, and adaptability to complex cross-domain task requirements. In addition, compared with AutoGPT, BabyAGI, and other LLM-based autonomous agents, AgentGPT has been significantly strengthened in visual interaction, task state tracking, and execution stability, enabling users to intuitively monitor agent strategy reasoning and task progress and improving the controllability and usability of the system.

[0004] Although the agent technology is developing rapidly, its performance in multi-task scenarios, the universality of system architecture, the reliability of scheduling mechanism and reasoning efficiency still need further research. Specifically, in the existing technology, although the agent framework represented by AgentGPT has shown the potential of task automation, it still faces significant challenges in actual multi-task and high-concurrency scenarios. First, the scheduling mechanism of the system mostly uses static or simple priority queues, which is difficult to dynamically adjust according to real-time feedback of task execution, system load fluctuations and resource competition, resulting in task congestion, response delay or resource idling. Second, the task decomposition process relies on single or linear reasoning of large language models, and the generated task chain is often flat in structure and lacks hierarchy, and in complex long-chain tasks, redundant sub-tasks or missing key dependencies are likely to occur, affecting execution efficiency and logical coherence. In addition, the system's context management capability is limited, and in multi-round interaction or long-period task execution, information forgetting or target deviation is likely to occur, making it difficult to maintain long-term semantic consistency and task controllability. Therefore, how to build an agent system with adaptive dynamic scheduling, hierarchical task decomposition and stable long-range context management capability to achieve efficient, reliable and user-controllable multi-task automation has become a key technical problem to be solved. SUMMARY

[0005] In view of the above problems, the embodiments of the present application provide a multi-task agent execution method and device based on a large language model and a storage medium. By introducing two-level task splitting and constraint explicit modeling, a task tree structure with clear hierarchy and explicit dependency is generated. By designing an adaptive scheduling algorithm that integrates real-time feedback and system state perception, the task priority and execution strategy are dynamically adjusted to improve system throughput and resource utilization. And by integrating feedback regulation and visual monitoring mechanism in the task execution process, the self-correction ability and user controllability of the system in the execution process are enhanced, and finally the efficient, stable and interpretable automation execution of cross-domain complex tasks is realized.

[0006] According to an aspect of an embodiment of the present application, a method for executing a multi-task intelligent agent based on a large language model is provided. The method comprises: receiving a natural language target task description and a constraint condition input by a user; inputting the target task description and the constraint condition to a task analysis module to generate a task tree having a hierarchical structure and a dependency relationship, wherein the task tree comprises a plurality of task nodes and a dependency edge representing an execution order between nodes; inputting the task tree to an adaptive scheduling module, calculating an initial priority for each task node based on a preset priority scoring model, and dynamically adjusting a real-time priority of each task node according to execution feedback of the task node to form a scheduling queue; executing each task node in the task tree in an asynchronous manner according to the scheduling queue, and calling a large language model to complete content generation of each node corresponding to a subtask; integrating execution results of each task node to generate a final output result for the target task, and visually displaying an execution state of the task tree and the final output result.

[0007] In an optional manner, the task tree having a hierarchical structure and a dependency relationship is generated, specifically comprising: performing semantic analysis on the natural language target task description to identify a task target and a constraint condition; adopting a two-level splitting strategy, first generating at least one stage main task to form a task skeleton; performing fine-grained splitting on each stage main task to generate at least one executable subtask node; adding a constraint label to related subtask nodes based on the constraint condition; inferring and constructing a dependency edge between the subtask nodes according to a logical relationship between the subtask nodes to form the task tree.

[0008] In an optional manner, after the task tree is generated, the task tree is further subjected to post-processing optimization, which comprises: performing normalization checking and correction on a format, executability and dependency relationship of a task node based on a rule; calculating semantic similarity between different task nodes, and merging a plurality of task nodes having a semantic similarity exceeding a preset threshold into one aggregated task node.

[0009] In an optional manner, the priority scoring model calculates an initial priority of a task node based on at least one of the following factors: a task category weight, a dependency depth in the task tree, a resource demand evaluation value, and a constraint weight specified by the user in the constraint condition.

[0010] In an optional manner, the real-time priority of the task node is dynamically adjusted according to the execution feedback of the task node by the following formula: ; wherein, is a real-time priority at time t, is an initial priority, is a parameter representing task urgency. a parameter representing task execution history risk penalty, and a hyperparameter; the parameter representing task urgency is determined based on at least one of the following factors: the remaining time to a preset deadline, and the number of downstream tasks affected by the task node; the parameter representing task execution history risk penalty is determined based on the number of failures, interruptions, or time-outs in the historical execution of the task node.

[0011] In an optional manner, when performing scheduling, the adaptive scheduling module further performs: monitoring system running states including the length of the to-be-executed queue, the number of running tasks, and the usage of external resources; dynamically adjusting the scheduling strategy for different types of tasks according to the system running states; setting an upper limit of parallelism to control the number of simultaneously executed tasks, and setting a maximum waiting time threshold to prevent low-priority tasks from being scheduled for a long time.

[0012] In an optional manner, after integrating the execution results of each task node, the method further includes a feedback adjustment step: dynamically updating the task tree according to the success or failure state of each task node, including supplementing new corrective sub-tasks to the task tree or adjusting the execution parameters of subsequent task nodes.

[0013] According to another aspect of the embodiments of the present application, a multi-task intelligent agent execution device based on a large language model is provided, which includes: a user interface module for receiving a natural language target task description and constraint conditions input by a user, and displaying an execution state and a final result; a task analysis and construction module for analyzing and constructing the target task description and constraint conditions into a task tree with a hierarchical structure and a dependency relationship; an adaptive task scheduling module for calculating and dynamically adjusting a priority for each node in the task tree based on a priority scoring model, to form a scheduling queue; a task execution and model calling module for asynchronously executing each task node according to the scheduling queue, and calling a large language model to generate task content; a feedback and result integration module for updating a task chain according to a task execution result, and integrating the results of each node to generate a final output; wherein the task analysis and construction module, the adaptive task scheduling module, the task execution and model calling module, and the feedback and result integration module are connected in sequence.

[0014] In an alternative mode, the task analysis and construction module further comprises: a semantic analysis unit for identifying task objectives and constraint conditions; a two-stage splitting unit for first generating a phased main task, and then refining each main task into executable subtask nodes; a constraint marking unit for adding marks to subtask nodes related to the constraint conditions; a dependency relationship construction unit for constructing dependency edges according to the logical relationships between subtask nodes to form a task tree; and a post-processing optimization unit for performing semantic merging and structural optimization on the generated task tree.

[0015] In an alternative mode, the adaptive task scheduling module further comprises: a priority calculation unit for calculating an initial priority based on task categories, dependency depths, resource requirements, and user constraints; a dynamic adjustment unit for updating the real-time priority of a task node according to real-time feedback information of task execution; a system state perception unit for monitoring system load and resource usage; and a scheduling decision unit for determining the execution order of a task node based on real-time priority, system state, parallelism control, and fairness constraints.

[0016] According to an aspect of an embodiment of the present application, an electronic device is provided, comprising: a controller; a memory for storing one or more programs, when the one or more programs are executed by the controller, to execute the above-mentioned method.

[0017] According to an aspect of an embodiment of the present application, a computer readable storage medium is also provided, which stores computer readable instructions, when the computer readable instructions are executed by a processor of a computer, the computer executes the above-mentioned method.

[0018] According to an aspect of an embodiment of the present application, a computer program product or computer program is also provided, the computer program product or computer program comprising computer instructions stored in a computer readable storage medium. A processor of a computer device reads the computer instructions from the computer readable storage medium, and the processor executes the computer instructions, so that the computer device executes the above-mentioned method.

[0019] The embodiment of the application first generates and post-processes the hierarchical task tree to make the task decomposition result more structured and executable, reduces redundant calculation and model calling times, and improves the accuracy and efficiency of task planning. Secondly, the adaptive dynamic scheduling mechanism can dynamically adjust the priority according to the real-time execution of the task and the system load, effectively alleviating the congestion problem in the multi-task environment, and improving the overall response speed and stability of the system. Thirdly, the system significantly enhances the observability and controllability of the agent execution process through the visual task state tracking and user interaction function, which facilitates user monitoring, intervention and adjustment of the task process. In addition, the feedback regulation mechanism enables the system to optimize and fault-tolerate itself during execution, improving the robustness and completion quality of complex long-chain tasks. Overall, the application provides a practical technical solution for building an efficient, reliable and user-friendly multi-task agent system, and broadens the application potential of large language models in the fields of automated programming, intelligent decision-making and personalized services.

[0020] The above description is only a summary of the technical solutions of the embodiments of the application. In order to more clearly understand the technical means of the embodiments of the application, the embodiments of the application can be implemented according to the content of the specification, and in order to make the above and other purposes, characteristics and advantages of the embodiments of the application more obvious and easy to understand, the following specific embodiments of the application are described. BRIEF DESCRIPTION OF DRAWINGS

[0021] The accompanying drawings incorporated in and forming a part of the specification illustrate embodiments consistent with the present application and, together with the description, serve to explain the principles of the application. It is apparent that the drawings in the following description are only some embodiments of the application, and other drawings can be obtained from these drawings without creative labor for those of ordinary skill in the art.

[0022] Figure 1 is an AgentGPT system structure diagram for executing a multi-task agent execution method based on a large language model according to an exemplary embodiment of the application.

[0023] Figure 2 is a flowchart of a multi-task agent execution method based on a large language model according to an exemplary embodiment of the application.

[0024] Figure 3 is a front-end interface diagram according to an exemplary embodiment of the application.

[0025] Figure 4 is a code generation diagram according to an exemplary embodiment of the application.

[0026] Figure 5 is a marketing scheme generation according to an exemplary embodiment of the application Figure 1 .

[0027] Figure 6 is a marketing scheme generation process shown by an example embodiment of the present application Figure 2 .

[0028] Figure 7 is a travel plan generation process shown by an example embodiment of the present application Figure 1 .

[0029] Figure 8 is a travel plan generation process shown by an example embodiment of the present application Figure 2 . DETAILED DESCRIPTION

[0030] The example embodiments will be described in detail below with reference to the attached drawings. In the following description, unless otherwise indicated, the same numbers in different drawings represent the same or similar elements. The implementation described in the following example embodiments is not meant to represent all implementations consistent with the present application. Rather, they are merely examples in accordance with some aspects of the present application as detailed in the appended claims.

[0031] The block diagrams in the drawings show only the functional entities and do not necessarily correspond to physically separate entities. That is, the functional entities can be implemented in software, or in one or more hardware modules or integrated circuits, or in different network and / or processor devices and / or microcontroller devices.

[0032] The flowcharts shown in the drawings are merely illustrative and do not necessarily include all contents and operations / steps, nor are they necessarily executed in the order described. For example, some operations / steps can be further divided, and some operations / steps can be combined or partially combined, so the actual execution order can be changed depending on the actual situation.

[0033] In the present application, "a plurality of" means two or more. The "and / or" describes the association between the associated objects, which means that there can be three relationships, for example, A and / or B can mean that A exists alone, A and B exist together, and B exists alone. The character " / " generally means that the associated objects before and after are in an "or" relationship.

[0034] With the rapid development of deep learning and large language models (LLMs), artificial intelligence has made significant progress in natural language understanding, reasoning, and task automation. In particular, the introduction of the Transformer architecture has enabled models to better model semantics, laying the technical foundation for language-based agent systems. The ability of LLMs to make autonomous decisions, decompose tasks, and generate operation sequences has driven the evolution from traditional rule-based automation to the agent paradigm.

[0035] Early task automation systems generally used rule-based logical reasoning frameworks, with task execution processes entirely dependent on manually set rules and knowledge bases. While these systems have strong controllability and stable response in specific scenarios, they have significant limitations when faced with complex natural language inputs, cross-task migration, or unknown environments. Their main shortcomings include weak generalization ability, high extension cost, and lack of autonomous planning ability. These shortcomings have driven the transition from rule-based systems to learning-based agent systems.

[0036] With the introduction of large models such as GPT-3 and GPT-4, language models have for the first time demonstrated the ability to decompose, plan, and generate complex tasks, leading to the emergence of new autonomous agent systems. Representative research includes open-source projects such as AutoGPT and BabyAGI, which combine LLMs with task chain mechanisms to achieve autonomous behavior in certain scenarios through cyclic task generation, execution, and reflection. Such systems have the following characteristics: (1) Can automatically infer task goals based on natural language descriptions; (2) Can continuously generate subtasks and update plans during execution; (3) Supports some degree of self-correction or result reflection.

[0037] However, these agent systems still have many limitations: the task chain generation process is unstable, the execution path lacks controllability, the system has weak support for error recovery and visualization, and it is difficult to maintain context consistency in long-chain tasks. These shortcomings limit their promotion in production-level applications.

[0038] Based on the aforementioned research, AgentGPT further enhances the LLM agent system. Through a web-based visualization interface, the system integrates task generation, scheduling execution, and result feedback, allowing users to intuitively monitor the execution process and status of the agent, significantly improving the observability and usability of traditional autonomous agents. Compared to systems such as AutoGPT, AgentGPT has improvements in the following areas: (1) Visualization of task chain construction and state monitoring: Users can view the generation, execution, and dependency structure of tasks in real-time, improving system transparency and controllability.

[0039] (2) Enhanced task scheduling mechanism: Introducing a more stable asynchronous execution and failure recovery mechanism, showing higher execution efficiency and fault tolerance in multi-task scenarios.

[0040] (3) Modular architecture design: Through front-end and back-end separation, API calling, and task tree generation mechanism, the agent system is more maintainable and extensible.

[0041] (4) Stronger user interactivity: The agent execution process supports dynamic interruption, restart, and supplementary instructions, making the system more suitable for research and application scenarios.

[0042] Therefore, AgentGPT has obvious practical potential in code generation, business analysis, and intelligent services, and has become an important reference framework for current agent system research.

[0043] Therefore, one aspect of the present application provides a multi-task agent execution method based on a large language model. In actual application, the method has the following positioning: (1) Based on the existing AgentGPT framework, experimental analysis is conducted for multi-task execution scenarios, including code generation, marketing analysis, and travel planning; (2) Verify the generalization ability, task decomposition ability, and execution stability of the agent system in cross-domain scenarios; (3) Propose optimization directions for practical applications, including task scheduling, reasoning efficiency, context management, and multi-agent collaboration improvement strategies.

[0044] In summary, the method of the present application not only supplements the empirical analysis of AgentGPT in multi-task scenarios, but also provides technical reference and path inspiration for subsequent construction of more efficient and controllable agent systems.

[0045] Based on the original system design, the key steps of the agent in natural language analysis, task planning, and multi-task scheduling are combined to further refine and algorithmize the system's running mechanism, making the technical solution more reproducible and engineering operable. At the same time, specific execution algorithms and processes are proposed for task generation, scheduling strategies, and context management, etc. to enhance the innovation and technical contribution of the system.

[0046] AgentGPT system constructs a closed-loop agent framework around the core process of natural language target → executable task chain → dynamic scheduling → result output. The system adopts front-end and back-end separation design and is composed of five core subsystems: User interface module: responsible for target input, parameter configuration, and result display; Natural Language Task Parsing Module: Converts user commands into a structured task tree; Task scheduling and execution module: Executes subtasks based on priority and dependencies; Feedback adjustment module: Dynamically updates the task chain based on the execution results; Data Management Module: Responsible for task status, logs, and context storage.

[0047] Compared to the original framework, this embodiment adds more detailed descriptions of input / output processes, task tree construction steps, and scheduling algorithms, enabling the system to move beyond simply listing modules and form a technical solution with clear execution logic. For example... Figure 1 As shown, the complete system workflow includes: target parsing → task splitting → task tree construction → scheduling and distribution → execution feedback → result output, as illustrated in subsequent embodiments with flowcharts and steps. The backend uses Python + FastAPI for asynchronous task scheduling; the frontend uses React + WebSocket to build a real-time visual interface; the database uses MySQL to store the task chain structure and execution logs; and the task generation and inference processes call the GPT-4 API to achieve semantic parsing and content generation. In summary, AgentGPT's overall structure forms a logically complete and dynamically adjustable chained task execution system.

[0048] based on Figure 1 The system shown, such as Figure 2 As shown, the multi-task intelligent agent execution method based on a large language model includes the following steps S10-S50.

[0049] S10: Receive the natural language target task description and constraints from user input.

[0050] Step S10 can be implemented based on the user interface module.

[0051] S20: Input the target task description and constraints into the task parsing module to generate a task tree with a hierarchical structure and dependencies. The task tree contains multiple task nodes and dependency edges that indicate the execution order between nodes.

[0052] Step S20 can be implemented based on the natural language task parsing module, which is one of the core innovations of the system. Its responsibility is to transform the user-input natural language target into a structured, executable, and schedulable task tree. This embodiment proposes the TaskTree-GPT task tree generation algorithm, which includes five steps: input preprocessing, prompt construction, model inference, and post-processing rules and dependency resolution.

[0053] Specifically, step S20 can generate a task tree through the following steps S201-S205.

[0054] S201: Input Pre-processing.

[0055] The input preprocessing module performs normalization processing on user text, including: text cleaning (removing noise symbols and special formats), key target identification (task objectives, constraints, and output formats), and semantic role labeling (identifying actions, objects, and conditional constraints); and outputs structured task semantic fragments (JSON).

[0056] S202: Task Decomposition Prompting based on Prompt.

[0057] For example, when a user inputs the goal of "generating a Hawaii travel plan," the sample task description is as follows: First, the system defines the overall task as "generating a Hawaii travel plan." Then, the system breaks down this goal into several sub-tasks with clear execution significance, including: Destination Overview Analysis: As the first step in the task chain, this sub-task is responsible for summarizing the basic characteristics of the Hawaii region and belongs to the analysis task type. Core Attraction Evaluation: This sub-task depends on the results of the destination overview analysis, so it must ensure that the preceding tasks have been completed before execution; its main function is to evaluate the main attractions in the area and select key recommended content. Subsequent Sub-tasks (such as itinerary planning, transportation mode recommendations, etc.): These can be further expanded according to the complexity of the task to form a complete travel planning chain.

[0058] In this example, each subtask includes information such as task name, task type, execution order, and dependencies, aiming to demonstrate a standardized task decomposition approach to the model and ensure that the model can generate a compliant task tree according to a unified structural format during actual inference.

[0059] S203: Execute the TaskTree-GPT task tree generation algorithm.

[0060] To achieve the automatic construction of an executable task tree from a natural language target, this embodiment proposes the TaskTree-GPT task tree generation algorithm. This algorithm combines the semantic understanding capabilities of a large language model with graph structure modeling, mapping the user-input text T to a task tree G=(V,E) with dependencies, where... For a set of task nodes, It is the set of directed dependency edges between tasks.

[0061] Unlike existing systems that list tasks linearly in a single round, TaskTree-GPT employs two key design features: a global-local hybrid splitting strategy and explicit constraint modeling. Global-Local Hybrid Decomposition Strategy: Upon the first call to GPT-4, the algorithm does not directly generate all subtasks. Instead, it first roughly divides the task into several phased main tasks (such as information gathering, scheme planning, and result processing) based on the overall goal, resulting in a global main path. Subsequently, GPT-4 is called again for each main task to perform fine-grained decomposition, expanding it into multiple executable subtasks. This two-level decomposition approach, starting with the main path and then refining, explicitly distinguishes between phased tasks and operational tasks, unlike the single-layer loop-based subtask generation method in systems like AutoGPT. Therefore, it is more suitable for constructing multi-step, hierarchically clear task tree structures.

[0062] Explicit constraint modeling: During task decomposition, the algorithm extracts constraints such as budget, time, and preferences from user input into separate constraint sets. The Prompt statement explicitly requires the model to mark task nodes strongly related to these constraints, such as budget-constrained subtasks or time-sensitive subtasks. Subsequently, during the scheduling phase, priority adjustments and execution path optimizations can be performed based on these markings.

[0063] In terms of specific process, the TaskTree-GPT algorithm includes the following stages: Phase 1: Semantic parsing and target normalization.

[0064] The input text T is cleaned and semantically extracted to obtain the task objective, key constraints, and expected output format, providing a unified representation for subsequent splitting.

[0065] Phase Two: Main Task Generation.

[0066] A global planning prompt is constructed to guide GPT-4 in generating several phased main tasks and clarifying their approximate execution order. At this stage, only the task skeleton is generated, and the granularity of execution is not required.

[0067] Phase 3: Subtask refinement.

[0068] For each main task, a refined Prompt is constructed to guide the model in generating specific operation steps, requiring each step to have a clear action, object, and expected output. This stage yields a set of candidate subtasks.

[0069] Phase Four: Structuring and Node Abstraction.

[0070] The model output is converted into a unified structured format (task ID, name, type, prerequisites, constraint tags, etc.) and abstracted into a node set V.

[0071] Phase 5: Dependency Inference and Graph Construction.

[0072] Based on the order descriptions, preconditions, and reference relationships in the model output, and combined with manually defined dependency rules, the set of dependency edges between tasks is inferred. After performing basic consistency checks, the task graph was finally obtained. .

[0073] Phase Six: Tree Formation and Redundancy Reduction.

[0074] The task graph is topologically sorted and hierarchically divided, and any possible cycles and redundant edges are pruned to ensure that the structure satisfies the directed acyclic property of the task tree, providing a clear hierarchical structure for the subsequent scheduling module.

[0075] Overall, TaskTree-GPT not only provides a mapping process from natural language to task trees, but also introduces a new structured design in terms of splitting strategies and explicit constraint modeling, making the generated task trees superior to existing schemes based on single-round task lists in terms of hierarchy, executability, and subsequent schedulability.

[0076] S204: Post-processing and semantic-driven task aggregation optimization.

[0077] To improve the compactness and execution efficiency of the task tree, this embodiment, in addition to basic format regularization and legality checks, further designs a semantic-driven task aggregation optimization mechanism, which automatically merges and reorganizes redundant or highly similar subtasks output by the large language model, making the task tree more concise while maintaining semantic integrity.

[0078] The entire post-processing process is divided into two levels: The basic rules layer (syntax and structure normalization) focuses on ensuring that the output results are formatted correctly and can be recognized by the system. It mainly includes: R1: Standardize the format, unify field names, data types and hierarchical structure; R2: Executability check, eliminating subtasks that are "descriptive only" and have no operational meaning; R3: Semantic merging and deduplication (based on keywords) merges obviously duplicate tasks; R4: Category labeling, assigning task type labels such as "analysis / planning / execution" based on keywords and location; R5: Depends on completion and conflict detection to verify the existence of prerequisite tasks and avoid the formation of loops or isolated nodes.

[0079] Semantic-driven layer (Semantic-Merge aggregation algorithm). After basic rule processing, there may still be task nodes that are semantically similar but have different names or whose splitting granularity is too fine. Therefore, this embodiment introduces a task aggregation algorithm based on semantic similarity, the specific idea of ​​which is as follows: First, each task node is mapped to a semantic vector representation using an embedding model or LLM to characterize the semantic content of the task. Then, the semantic similarity between any two nodes is calculated. When the similarity exceeds a set threshold, they are identified as candidate merge objects, and the system automatically generates an aggregated representative task, inheriting the dependency and constraint information of the two nodes. For tasks with excessively fine granularity that can be completed sequentially in one go (such as querying information about attraction A, querying information about attraction B, and querying information about attraction C), the algorithm merges them into a higher-level task of batch querying information about multiple attractions, in order to reduce the number of scheduling operations and model call costs.

[0080] Through the two post-processing layers described above, the system achieves structural normalization and semantic aggregation optimization of the original LLM output without relying on manual intervention. This mechanism makes the final task tree more reasonable in terms of the number of nodes, hierarchical structure, and dependencies, providing a higher-quality structural foundation for subsequent scheduling and execution. It also constitutes an algorithmic innovation that distinguishes this paper from existing intelligent agent systems.

[0081] S205: Task Tree Output.

[0082] The final task tree includes: node ID, node type, input and output formats, parent and child nodes and dependencies, and priority tag. This structure ensures that tasks can be executed directly in subsequent scheduling phases.

[0083] S30: Input the task tree into the adaptive scheduling module, calculate the initial priority for each task node based on the preset priority scoring model, and dynamically adjust its real-time priority according to the execution feedback of the task nodes to form a scheduling queue.

[0084] The adaptive scheduling module is responsible for sorting, distributing, and executing nodes in the task tree. This embodiment proposes an adaptive asynchronous scheduling mechanism (AdaptiveAsyncScheduler) to solve the congestion problem of traditional linear priority queues in multi-task scenarios. The scheduling process can be simply summarized as follows: initial priority allocation based on task attributes, asynchronous coroutine execution (asyncio), dynamic priority adjustment, failure recovery mechanism, and execution result write-back and task chain update.

[0085] For the priority scoring model, the system quantifies task priority as follows: P=w1T c+w2D+w3R+w4C Wherein: T c The weights are: task category weights (execution > analysis); D is dependency depth (shallower depth, higher priority); R is resource requirement assessment; C is user-specified constraint weights; w1, w2, w3, and w4 are weighting coefficients.

[0086] Based on this, this embodiment proposes to introduce feedback information during task execution to dynamically update the priority and obtain the time. Real-time priority: ; in: It describes the urgency of the task at the current moment, such as the remaining time until the user-set deadline and the number of downstream tasks it affects. Characterize the risks and instability of the task, such as the number of times the task has failed, been interrupted, or timed out in its historical execution. , : Hyperparameters that control the degree of impact of urgency and risk penalties.

[0087] Based on the aforementioned priority model, this embodiment designs an adaptive asynchronous scheduling algorithm, AdaptiveAsyncScheduler, to dynamically balance the fast response of high-priority tasks with the overall system throughput in a multi-tasking environment. Unlike traditional priority queues based on fixed weights, this algorithm continuously senses the system status and task feedback during the scheduling process and adjusts the task order accordingly.

[0088] The core ideas of AdaptiveAsyncScheduler can be summarized in the following three aspects: (1) State-aware scheduling decisions.

[0089] The scheduler periodically collects system runtime data, including the length of the current queue, the number of running tasks, the average wait time, and the usage of external resources (such as API call quotas). Based on this information, the scheduler adjusts its scheduling strategies differently for different types of tasks: when the queue is heavily congested, it prioritizes tasks with short execution times and low resource requirements to quickly clear the queue; when the system load is low, it prioritizes critical tasks with high dependency depth and a more significant impact on the overall result.

[0090] (2) Priority adaptive update based on feedback.

[0091] In each round of scheduling, the scheduler not only refers to the initial priority. Furthermore, the real-time priority Pt is updated based on the feedback from the most recent execution of the task: if the task succeeds multiple times and the execution time is stable, its risk penalty is reduced, making it more likely to be selected in subsequent rounds; if the task frequently times out or fails, its risk penalty is increased, its scheduling frequency is temporarily reduced if necessary, and it is marked as a candidate that requires manual intervention or downgrade execution.

[0092] In this way, the scheduler accumulates experience during operation and can gradually learn scheduling preferences suitable for the current application scenario.

[0093] (3) Parallelism control and fairness constraints.

[0094] In an asynchronous execution framework, the system can run multiple tasks concurrently. To prevent individual long-running tasks from consuming resources for extended periods, AdaptiveAsyncScheduler introduces a parallelism cap and a fairness constraint mechanism: the parallelism cap controls the number of tasks that can be executed simultaneously within the same time window, preventing excessive resource contention; the fairness constraint sets a maximum waiting time threshold to ensure that tasks that have been in a low-priority state for an extended period automatically have their priority increased if the waiting time becomes too long, thus avoiding starvation.

[0095] In summary, AdaptiveAsyncScheduler not only scores tasks based on multi-dimensional features before execution, but also continuously uses feedback information to adaptively adjust priorities during execution, and makes dynamic decisions based on overall system load and fairness requirements. This series of designs transforms the scheduling process from a traditional static rule-driven approach into an intelligent scheduling mechanism with a certain degree of self-regulation.

[0096] S40: Asynchronously execute each task node in the task tree according to the scheduling queue, and call the large language model to complete the generation of the subtask content corresponding to each node.

[0097] The core principle of step S40 lies in transforming the sequence of task nodes, which has undergone intelligent planning and scheduling and possesses clear dependencies and priority order, into concrete, deliverable subtask results. This step is not simply a linear execution of commands, but rather, based on an asynchronous concurrent programming paradigm, it coordinates system resources and Large Language Model (LLM) services to achieve sequential or parallel generation of the goals defined for each task node. Its implementation relies on an execution engine that receives queues from the scheduling module, creates an independent execution context for each task node, precisely constructs the prompts required to invoke the LLM, and manages the entire lifecycle of the invocation process, including initiating requests, processing responses, catching exceptions, and updating task status. Crucially, the execution process must strictly adhere to the dependency constraints defined in the task tree, ensuring that the results of preceding tasks can be passed as valid input to subsequent tasks, thereby maintaining the logical coherence and data consistency of the task chain.

[0098] The specific implementation is as follows: The system backend uses a Python-based asynchronous framework (such as asyncio) to build a task execution pool. When the scheduler allocates a ready task node, the execution engine extracts its preset attributes from that node, such as task type (analysis, planning, code generation, etc.), specific instruction description, and input data from previous tasks. Subsequently, the engine assembles a structured Prompt based on the task type and system configuration. This Prompt typically includes role settings, a specific task description, output format requirements, and relevant context information. The assembled Prompt is sent to the model by calling a pre-integrated LLM API (such as the OpenAI GPT-4 API). The execution engine asynchronously waits for the API to return results and parses and validates the returned text or structured data. Successful results are marked as completed, and their output is stored in a shared context storage (such as a database or memory cache) for subsequent tasks that depend on this node to read. If execution fails or times out, the engine processes it according to a preset retry strategy and feeds back the failure status to the scheduling module, which may trigger dynamic priority adjustment or an error correction process initiated by the feedback adjustment module. The status changes throughout the entire execution process, including start, in progress, success, and failure, are pushed to the front-end visualization interface in real time via WebSocket connection, providing users with transparent process monitoring.

[0099] S50: Integrate the execution results of each task node, generate the final output result for the target task, and visualize the execution status of the task tree and the final output result.

[0100] In specific implementation, such as Figure 3As shown, the system front-end, based on React, is responsible for task input, status display, and result visualization. WebSocket is used to establish real-time communication, implementing the following functions: 1. Task Tree Visualization: A tree structure is used to display each task node, its dependencies, and its execution status; node colors map the execution status.

[0101] 2. Real-time status synchronization mechanism: The backend pushes status update messages via WebSocket.

[0102] 3. User interaction operations: task interruption, restart, adding constraints; automatically triggering task chain structure updates and re-rendering the view.

[0103] 4. Visualized execution log: The execution process is displayed step by step, which facilitates debugging and review.

[0104] In one specific embodiment, such as Figure 1 The system shown, when running the method of this application, includes the following six steps in its operation process.

[0105] Step 1: The user inputs the natural language target. The system receives the user's task requirements, constraints, and expected output.

[0106] Step 2: Semantic parsing and target structuring. Perform input preprocessing, structured parsing, and key task extraction.

[0107] Step 3: TaskTree-GPT generates the task tree. An executable task tree is generated using Prompt + GPT-4 + post-processing.

[0108] Step 4: AdaptiveAsyncScheduler executes the task tree. All task nodes are executed based on priority, dependencies, and dynamic scheduling strategies.

[0109] Step 5: Execution Feedback and Task Chain Update. Based on the execution results, tasks are automatically corrected, subtasks are added, or self-correction is performed.

[0110] Step Six: Structured Result Output and Visualization. The final results are displayed in a structured manner on the front-end interface.

[0111] To further evaluate the performance of this multi-task agent execution method based on a large language model in different application scenarios, this paper designs an experimental set containing three representative tasks: (1) Task 1: Code generation task - taking the Fibonacci sequence algorithm as a typical example, examine the ability of the agent in automatic program generation, complexity analysis and self-optimization; (2) Task 2: Smart Wearable Device Marketing Plan Generation Task - Market analysis and marketing planning for smart wearable products, verifying the applicability of intelligent agents in business text generation, structured plan planning and multi-information integration; (3) Task 3: Travel plan generation task - Taking the Hawaii travel plan as an example, evaluate the performance of the agent in terms of itinerary planning, knowledge retrieval and integration and constraint handling.

[0112] The three task categories cover different fields such as algorithm programming, business decision-making, and tourism services. They can reflect the system's ability to generate accurate code at the code level, and also test its generalization performance in open-domain knowledge, long text planning, and multi-step reasoning. The experiment focuses on a comprehensive analysis from dimensions such as task completion, result structuring, semantic rationality, and interaction stability.

[0113] The experimental environment was based on the Ubuntu 22.04 operating system, with hardware including an Intel i7-12700 CPU and an NVIDIA RTX 3060 GPU. The system backend used the Fast API framework for asynchronous task scheduling, the frontend used React for the interactive interface, and MySQL was used to store task and log data. All code generation tasks called the OpenAIGPT-4 API, with the AgentGPT system autonomously parsing task instructions, generating various algorithm implementations, and performing performance analysis.

[0114] The code generation task is to implement three typical algorithms for generating the Fibonacci sequence: recursion, iteration, and dynamic programming. The task instruction is: "Write a function in Python to calculate the Fibonacci sequence and analyze the time complexity of the three algorithms." (1) Recursive implementation The system first generates a recursive version of the Fibonacci function: this method has a simple structure and clear logic, but its time complexity is high, at O(2ⁿ). Since each call generates two new function calls, its computational efficiency is low.

[0115] (2) Iterative implementation The system then generated an optimized iterative version: this version has a time complexity of O(n) and a space complexity of only O(1), enabling efficient computation of large-scale inputs. The system automatically added variable initialization and loop logic explanations during the generation process, demonstrating strong semantic understanding and structured generation capabilities.

[0116] (3) Implementation by dynamic programming The system further generates a dynamic programming version to strike a balance between time efficiency and space usage: the time complexity of the dynamic programming method is also O(n), but it avoids redundant computation by storing intermediate results. After generation, the system automatically performs a performance comparison analysis and outputs a summary of the complexity of the three algorithms, demonstrating its adaptive understanding of algorithm optimization. The running results are as follows... Figure 4 As shown.

[0117] For the task of generating marketing plans for smart wearable devices, AgentGPT automatically breaks down the objective into multiple sub-tasks: 1) Market environment and competitive landscape analysis; 2) Identification of target audience and market segments; 3) Marketing strategy and promotion channel design; 4) Analysis of digital marketing trends; 5) Analysis of successful product cases and extraction of experience.

[0118] The system generates structured text sequentially around the aforementioned sub-tasks, including market segmentation, competitor analysis, market trends and policy environment, target user characteristics, brand positioning, pricing strategy, channel and promotion strategy, and a summary of successful experiences for typical products (such as smartwatches and smart bracelets). The interface is displayed as follows: Figure 5 and Figure 6 As shown.

[0119] The main evaluation metrics for this task include: 1) Degree of structuring: Does the generated result form a complete solution framework that includes "market analysis - target audience - marketing strategy - digital trends - case analysis"? 2) Content rationality and professionalism: Does the analysis conclusion conform to classic marketing theory and the current status of the smart wearable industry, such as whether it takes into account key product selling points such as health monitoring, sports and fitness, and fashion attributes; 3) Logical consistency: Do the outputs of different subtasks maintain consistency in terms of target users, brand positioning, and strategy selection? 4) Feasibility: Does the plan provide feasible channel selection and operation suggestions, such as social media placement, content marketing and user community operation?

[0120] For the travel plan generation task, AgentGPT first automatically creates multiple subtasks based on the instructions: 1) Destination overview and recommended key attractions; 2) Analysis of the best travel time and peak / off-peak seasons; 3) Accommodation types and representative hotel recommendations; 4) Design of popular activities and unique experiences; 5) Planning of transportation modes within and between the island.

[0121] During execution, the system generates a comprehensive text solution for users, including pre-trip preparations, flight and hotel booking suggestions, recommendations for attractions in Honolulu and other islands (such as Volcanoes National Park and Maui beaches), activity arrangements for snorkeling and hiking, and options for car rentals, public transportation, and inter-island flights. The interface is displayed as follows: Figure 7 and Figure 8 As shown.

[0122] The evaluation metrics for this task include: 1) Completeness of the itinerary: Does it cover key elements such as "travel time - itinerary arrangement - accommodation - transportation - activity experience"? 2) Information accuracy and practicality: Are the descriptions of attractions, activities, and transportation methods basically consistent with publicly available tourism information? Are the suggestions valuable for reference? 3) Constraint handling capability: When additional constraints such as budget or number of travel days are imposed, can the agent consistently adjust the original plan? 4) Interactive experience: The response speed and stability of itinerary modification and supplementary information in multi-turn dialogues.

[0123] Experimental results show that AgentGPT exhibits high intelligence and stability in code generation tasks. After generating a recursive algorithm, the system can automatically optimize it into iterative and dynamic programming versions based on user-added instructions, and automatically generate complexity analysis. This process verifies that the system possesses task decomposition, semantic understanding, and self-optimization capabilities.

[0124] In the marketing plan task, AgentGPT successfully completed the entire process of generating a comprehensive strategy, from macro-market analysis to micro-strategy design. The system first described the segmented market of smart wearable devices across age groups, genders, occupations, and lifestyles. It then provided an analysis of competing brands and market share, and summarized market development trends in light of technological advancements and regulatory changes. Based on this, AgentGPT identified the target user group and brand positioning around core selling points such as health monitoring, activity tracking, and personalized design. It proposed a series of promotional strategies, including social media marketing, search engine optimization, content marketing, and KOL collaborations, and also provided pricing strategies and channel selection suggestions.

[0125] Comparing with marketing theories, the system-generated solutions generally conform to the STP (Market Segmentation – Target Market – Positioning) and 4P (Product, Price, Place, Promotion) framework, with clear logic and distinct levels of hierarchy. The outputs of each subtask maintain consistency in target audience profiling and brand positioning, without any significant conflicts, indicating that the agent possesses good context management capabilities in long-chain tasks. Overall, the generated results of this task have a high degree of structure and executability; only minor manual polishing of some expressions is required before they can be used directly as preliminary marketing plans.

[0126] In travel planning tasks, AgentGPT can automatically construct a travel planning chain containing multiple sub-tasks under a single high-level command. The system first provides an overall overview of Hawaii and recommendations for key attractions on representative islands. Next, it analyzes the advantages and disadvantages of different seasons from the perspectives of climate conditions, tourist density, and price factors, offering a comprehensive suggestion to "avoid peak season and choose months with suitable weather and relatively reasonable prices." Subsequently, based on different budgets and preferences, the agent recommends various accommodation types, including high-end resorts, brand chain hotels, and local guesthouses, and provides multi-day itinerary examples incorporating activities such as snorkeling, hiking, volcano sightseeing, and cultural activities.

[0127] In terms of transportation planning, the system comprehensively compares various modes of transportation, including car rental, public transportation, ride-hailing services, and inter-island flights, explaining their respective applicable scenarios and advantages and disadvantages. The overall recommendations are largely consistent with the travel methods commonly recommended in existing travel guides. Multiple rounds of interaction show that when users add conditions such as "family travel" and "limited stay," the intelligent agent can make coherent adjustments to the original itinerary, demonstrating a certain ability to handle constraints and restructure solutions.

[0128] This embodiment focuses on AgentGPT, an intelligent agent system built on OpenAI GPT-4, and conducts a systematic study on its system architecture design, task generation mechanism, execution scheduling process, and visualization interaction. By constructing a multi-module collaborative framework with separate front-end and back-end, AgentGPT achieves end-to-end intelligent processing capabilities, from natural language input, automatic task decomposition, subtask scheduling to result output.

[0129] In the multi-task experiment, the system completed three typical tasks: code generation, marketing plan planning for smart wearable devices, and travel plan development. The experiment showed that: In code generation tasks, AgentGPT can accurately generate implementations of various algorithms such as recursion, iteration, and dynamic programming, and can automatically perform complexity analysis, demonstrating high logical consistency and programming capabilities.

[0130] In the marketing plan generation task, the system can generate structured marketing plans that conform to professional logic based on factors such as market environment, target users, product characteristics and promotion channels, demonstrating good information synthesis and strategic reasoning capabilities.

[0131] In travel planning tasks, the system can generate highly practical itinerary plans based on attraction recommendations, best time of year, accommodation options, and transportation planning, and can dynamically adjust them according to additional conditions added by the user.

[0132] In summary, AgentGPT demonstrates reliable semantic understanding, task decomposition, and generation quality across multiple domains and task types, validating the feasibility and application value of agent systems based on large language models in task automation and knowledge-intensive applications.

[0133] Another aspect of this application provides a multi-task intelligent agent execution device based on a large language model, comprising: a user interface module for receiving a natural language target task description and constraints input by a user, and displaying the execution status and final result; a task parsing and construction module for parsing the target task description and constraints and constructing a task tree with a hierarchical structure and dependencies; an adaptive task scheduling module for calculating and dynamically adjusting the priorities of nodes in the task tree based on a priority scoring model to form a scheduling queue; a task execution and model invocation module for asynchronously executing each task node according to the scheduling queue and invoking the large language model to generate task content; and a feedback and result integration module for updating the task chain according to the task execution result and integrating the results of each node to generate the final output; wherein the task parsing and construction module, the adaptive task scheduling module, the task execution and model invocation module, and the feedback and result integration module are connected sequentially.

[0134] It should be noted that the apparatus provided in the above embodiments and the method provided in the foregoing embodiments belong to the same concept, and the specific way in which each module and unit performs operations has been described in detail in the method embodiments, and will not be repeated here.

[0135] Another aspect of this application provides an electronic device, including: a controller; and a memory for storing one or more programs, which, when executed by the controller, perform the methods described above.

[0136] Another aspect of this application provides a computer-readable storage medium having a computer program stored thereon that, when executed by a processor, implements the method as described above. This computer-readable storage medium may be included in the electronic device described in the above embodiments, or it may exist independently and not assembled into the electronic device.

[0137] Another aspect of this application provides a computer program product or computer program including computer instructions stored in a computer-readable storage medium. A processor of a computer device reads the computer instructions from the computer-readable storage medium and executes the computer instructions, causing the computer device to perform the methods provided in the various embodiments described above.

[0138] According to one aspect of the embodiments of this application, a computer system is also provided, including a Central Processing Unit (CPU), which can perform various appropriate actions and processes based on a program stored in read-only memory (ROM) or a program loaded from storage into random access memory (RAM), such as performing the methods described above. Various programs and data required for system operation are also stored in the RAM. The CPU, ROM, and RAM are interconnected via a bus. Input / output (I / O) interfaces are also connected to the bus.

[0139] The following components are connected to the I / O interface: input components including keyboards, mice, etc.; output components including cathode ray tubes (CRTs), liquid crystal displays (LCDs), and speakers; storage components including hard drives; and communication components including network interface cards such as LAN (Local Area Network) cards and modems. The communication components perform communication processing via networks such as the Internet. Drives are also connected to the I / O interface as needed. Removable media, such as disks, optical discs, magneto-optical discs, semiconductor memories, etc., are installed on the drive as needed so that computer programs read from them can be installed into the storage components as required.

[0140] The above content is merely a preferred exemplary embodiment of this application and is not intended to limit the implementation of this application. Those skilled in the art can easily make corresponding modifications or alterations based on the main concept and spirit of this application. Therefore, the scope of protection of this application should be determined by the scope of protection claimed in the claims.

Claims

1. A multi-task intelligent agent execution method based on a large language model, characterized in that, include: Receive user input of the natural language target task description and constraints; The target task description and constraints are input into the task parsing module to generate a task tree with a hierarchical structure and dependencies. The task tree contains multiple task nodes and dependency edges that indicate the execution order between nodes. The task tree is input into the adaptive scheduling module, which calculates the initial priority for each task node based on a preset priority scoring model, and dynamically adjusts its real-time priority according to the execution feedback of the task nodes to form a scheduling queue. The task nodes in the task tree are executed asynchronously according to the scheduling queue, and the large language model is called to generate the sub-task content corresponding to each node. The execution results of each task node are integrated to generate the final output result for the target task, and the execution status of the task tree and the final output result are visualized.

2. The method according to claim 1, characterized in that, The generation of a task tree with a hierarchical structure and dependencies specifically includes: Semantic parsing is performed on the natural language target task description to identify the task objective and constraints; A two-level splitting strategy is adopted. First, at least one phased main task is generated to form a task skeleton. For each of the aforementioned phased main tasks, fine-grained decomposition is performed to generate at least one executable sub-task node; Add constraint tags to the relevant subtask nodes based on the aforementioned constraints; Based on the logical relationships between the subtask nodes, their dependency edges are inferred and constructed to form the task tree.

3. The method according to claim 2, characterized in that, After generating the task tree, the process further includes post-processing optimization of the task tree, which includes: Based on rules, the format, executability, and dependencies of task nodes are standardized and corrected. Calculate the semantic similarity between different task nodes, and merge multiple task nodes whose semantic similarity exceeds a preset threshold into an aggregated task node.

4. The method according to claim 1, characterized in that, The priority scoring model calculates the initial priority of a task node based on at least one of the following factors: task category weight, dependency depth in the task tree, resource requirement assessment value, and user-specified constraint weights in the constraints.

5. The method according to claim 1 or 4, characterized in that, The dynamic adjustment of real-time priority based on the execution feedback of task nodes is achieved through the following formula: ； in, For the real-time priority at time t, As the initial priority, As a parameter characterizing the urgency of the task, To characterize the parameters of historical risk penalties for task execution, and For hyperparameters; The parameter characterizing the urgency of the task The time remaining until the preset deadline and the number of downstream tasks affected by the task node are determined based on at least one of the following factors: the remaining time until the preset deadline and the number of downstream tasks affected by the task node. The parameters for the historical risk penalty applied to the characterization task. The number of times the task node failed, was interrupted, or timed out during its historical execution is determined.

6. The method according to claim 1, characterized in that, When performing scheduling, the adaptive scheduling module also performs the following: The system operates under monitoring status, which includes the length of the queue to be executed, the number of tasks currently running, and the usage of external resources. Based on the system's operating status, dynamically adjust the scheduling strategy for different types of tasks; Set a maximum parallelism limit to control the number of tasks that can be executed simultaneously, and set a maximum wait time threshold to prevent low-priority tasks from going unscheduled for an extended period.

7. The method according to claim 1, characterized in that, After integrating the execution results of each task node, a feedback adjustment step is also included: The task tree is dynamically updated based on the success or failure status of each task node, including adding new corrective subtasks to the task tree or adjusting the execution parameters of subsequent task nodes.

8. A multi-task intelligent agent execution device based on a large language model, used to implement the method as described in any one of claims 1 to 7, characterized in that, include: The user interface module is used to receive the natural language target task description and constraints input by the user, and to display the execution status and final result. The task parsing and construction module is used to parse the target task description and constraints and construct a task tree with a hierarchical structure and dependencies. An adaptive task scheduling module is used to calculate and dynamically adjust the priorities of nodes in the task tree based on a priority scoring model, forming a scheduling queue. The task execution and model invocation module is used to asynchronously execute each task node according to the scheduling queue and invoke the large language model to generate task content; The feedback and result integration module is used to update the task chain based on the task execution results and integrate the results of each node to generate the final output; The task parsing and construction module, the adaptive task scheduling module, the task execution and model invocation module, and the feedback and result integration module are connected in sequence.

9. An electronic device, characterized in that, include: Controller; A memory for storing one or more programs, which, when executed by a controller, cause the controller to perform the method of any one of claims 1 to 7.

10. A computer-readable storage medium, characterized in that, It stores computer-readable instructions that, when executed by the computer's processor, cause the computer to perform the method of any one of claims 1 to 7.

Images