Computer task processing system and method with self-lifting capability

Abstract

The invention discloses a computer task processing system and method with self-lifting capability, and the system comprises a planner which is used for obtaining a user demand, and decomposing a task into a plurality of subtasks according to the user demand; the configurator is used for carrying a task execution tool, retrieving the task execution tool or generating a new tool according to a user demand and a plurality of subtasks, and generating task configuration information; the executor is used for respectively executing the decomposed sub-tasks according to task configuration information to complete task operation; the checker is used for optimizing task processes and tools according to execution feedback of the executor on the sub-tasks; according to the method, comprehensive interaction of an operating system level can be realized through a unified interface, and application limitation is broken; the adaptive capacity is improved by dynamically expanding tasks and tools; a self-driven learning mechanism is introduced to quickly respond to new requirements; based on efficient feedback optimization, the failure rate is reduced, and the task accuracy and efficiency are improved.

Description

Technical Field

[0001] The present invention relates to the field of computer technology, and particularly to a computer task processing system and method with self-improving capabilities. Background Art

[0002] Currently, the heterogeneity of the operating system ecosystem poses significant challenges to the development of operating system-level language agents. Firstly, the agent requires a unified interface to achieve seamless interaction with the operating system, covering various methods such as code execution, input device control, and API calls. Secondly, the diverse application programs in the operating system make the generalization and scalability of the agent face severe tests, and it is impractical to manually customize control mechanisms and tools for each application. Although large language models (LLMs) have promoted the development of language agents, existing agents are mostly limited to specific applications (such as browsers or command-line terminals) and are difficult to effectively interact with the entire operating system.

[0003] Specifically, Chinese Patent Publication No. CN119128062A proposes an automated process generation method, an agent, and an automated process generation system. This patent parses user input through a large language model and matches a process component library to generate a task process. However, this method relies on a static component library, has limited scalability, is difficult to cope with new task requirements, and lacks the ability of autonomous learning.

[0004] Specifically, Chinese Patent No. CN118885688A proposes an information processing method, device, electronic device, and agent based on a large model. This patent uses a large language model for problem expansion and target generation, and generates a task strategy through semantic analysis. Although this solution has advantages in complex problem parsing, its tool expansion ability is also limited and it is difficult to flexibly cope with new scenarios. These limitations highlight the urgent need to develop efficient and scalable language agents at the operating system level. Summary of the Invention

[0005] The object of the present invention is to provide a computer task processing system and method with self-improving capabilities for the above problems in the prior art, and thus solve all or one of the above problems existing in the prior art.

[0006] To solve the above technical problems, the specific technical solution of the present invention is as follows: On the one hand, the present invention provides a computer task processing system with self-improving capabilities, including: A planner for: obtaining user requirements and decomposing a task into several subtasks according to the user requirements; A configurator for: loading task execution tools, retrieving the task execution tools or generating new tools according to the user requirements and the several subtasks, and generating task configuration information; An executor, configured to: respectively execute several decomposed subtasks according to the task configuration information to complete task operations; An inspector, configured to: optimize the task process based on self-driven learning ability according to the execution feedback of the executor on several subtasks, and expand or adjust the task execution tools.

[0007] As an improved solution, the planner includes: a task acquisition unit, a task decomposition unit, and a task relationship organization unit; The task acquisition unit is configured to: acquire a task request input by a user through voice, text, or an API interface; The task decomposition unit is configured to: perform semantic parsing on the task request and decompose the task into several operable subtasks; The task relationship organization unit is configured to: organize the nodes of multiple subtasks according to the dependency relationship.

[0008] As an improved solution, the configurator includes: a declarative memory unit, a procedural memory unit, and a working memory unit; The declarative memory unit is configured to: store and manage static knowledge, where the static knowledge includes: user preferences, operation trajectories, and system environment information; The procedural memory unit is configured to: manage the task execution tools and dynamically generate the new tools according to task requirements; The working memory unit is configured to: allocate the task execution tools or the new tools according to the execution process of the subtasks, and perform information integration and dynamic feedback processing.

[0009] As an improved solution, the executor includes: an execution unit, an interaction mode support unit, and a monitoring unit; The execution unit is configured to: schedule the subtasks one by one and call the corresponding tools to complete actual task operations; The interaction mode support unit is configured to: implement interaction functions in a command-line mode, a graphical interface simulation mode, and an API call mode; The monitoring unit is configured to: monitor the running status of the tools during task execution, record logs when an error occurs in the tools, and notify the inspector.

[0010] As an improved solution, the inspector includes: a verification unit, a result analysis unit, a result feedback unit, and a self-driven learning unit; The verification unit is configured to: verify the execution results of each subtask; The result analysis unit is configured to: when the execution result is a failure, analyze the reason for the failure of the task execution, trigger corresponding fallback operations, and optimize the task result based on the fallback operations; The result feedback unit is configured to: return the verified and optimized task result to the planner; The self-driven learning unit includes: a refinement and iteration unit and a guided practice unit; the refinement and iteration unit is configured to: during the task execution, learn and execute a number of tentative operations, and store other feasible strategies that can complete the task; the guided practice unit is configured to: when the application scenario is a new scenario that is contacted for the first time, create progressive learning tasks, and expand the task execution ability based on the progressive learning tasks.

[0011] As an improved solution, the declarative memory unit is further configured to: collect the user's conversation style, tool usage habits, and multimedia preference information as a user profile when the user uses it for the first time; the declarative memory unit records the task execution operation trajectory during the task execution, obtains the operating system related information, and stores the task execution operation trajectory and the operating system related information as semantic knowledge; The procedural memory unit is further configured to: configure the task execution tool during system initialization; when the task execution tool cannot meet the task processing requirements, use natural language processing technology to generate the new tool according to the task requirements; The working memory unit is further configured to: when the executor executes the task, retrieve the available tool list from the tool library of the procedural memory unit, screen the appropriate tool from the available tool list according to the task requirements, and provide the relevant information of the appropriate tool to the executor; the working memory unit generates the task configuration information about the subtask according to the semantic knowledge.

[0012] As an improved solution, the fallback operations include: requesting the configurator to generate an alternative tool, adjusting the task execution process, and updating the dependency relationship or input data of the subtask.

[0013] As an improved solution, the refinement and iteration unit is further configured to: perform different API call attempts or different interaction step simulation attempts, store the successful tools that complete the task in the procedural memory unit, and record error logs for the failed tools that do not complete the task; The guided practice unit is further configured to: sequentially solve the progressive learning tasks, and during the task solving process, explore and try different operation methods, and accumulate task execution tools and strategies.

[0014] As an improved solution, the planner is further configured to: after all subtasks are completed, integrate the execution results of all subtasks and present them to the user in a visual form or a data file form.

[0015] On the other hand, the present invention further provides a computer task processing method with self-improving ability, including the following steps: Planning step: Obtain user requirements and decompose the task into several subtasks according to the user requirements; Configuration step: Load task execution tools, retrieve the task execution tools or generate new tools according to the user requirements and several of the subtasks, and generate task configuration information; Execution step: Execute the decomposed several subtasks respectively according to the task configuration information to complete the task operation; Inspection step: Optimize the task process based on the self-driven learning ability according to the execution feedback of the executor for several of the subtasks, and expand or adjust the task execution tools.

[0016] The beneficial effects of the technical solution of the present invention are: 1. The computer task processing system with self-improving ability according to the present invention can achieve comprehensive interaction at the operating system level through a unified interface, breaking application limitations; improve adaptability by dynamically expanding tasks and tools; introduce a self-driven learning mechanism to quickly respond to new requirements; and optimize based on efficient feedback to reduce the failure rate and improve task accuracy and efficiency.

[0017] 2. The computer task processing method with self-improving ability according to the present invention can orderly call system modules, thereby implementing the system logic of the computer task processing system with self-improving ability according to the present invention. BRIEF DESCRIPTION OF THE DRAWINGS

[0018] In order to more clearly illustrate the specific embodiments of the present invention or the technical solutions in the prior art, the following will briefly introduce the drawings required for the description of the specific embodiments or the prior art. Obviously, the following drawings are some embodiments of the present invention. For those of ordinary skill in the art, other drawings can be obtained based on these drawings without creative efforts.

[0019] Figure 1 is a schematic diagram of the architecture of the computer task processing system with self-improving ability described in Embodiment 1 of the present invention; Figure 2 is a schematic diagram of the construction of the DAG in the computer task processing system with self-improving ability described in Embodiment 1 of the present invention; Figure 3It is a schematic diagram of the working logic of the configurator in the computer task processing system with self-improving ability described in Embodiment 1 of the present invention; Figure 4 It is a schematic diagram of an operation example of the executor in the computer task processing system with self-improving ability described in Embodiment 1 of the present invention; Figure 5 It is a schematic diagram of the simple architecture of the computer task processing system with self-improving ability described in Embodiment 1 of the present invention; Figure 6 It is a schematic flowchart of the computer task processing method with self-improving ability described in Embodiment 2 of the present invention. Detailed implementation manners

[0020] The following elaborates on the preferred embodiments of the present invention in conjunction with the accompanying drawings, so that the advantages and features of the present invention can be more easily understood by those skilled in the art, thereby making the protection scope of the present invention more clearly defined.

[0021] In the description of the present invention, it should be noted that the embodiments described in the present invention are part of the embodiments of the present invention, rather than all of the embodiments; based on the embodiments in the present invention, all other embodiments obtained by those of ordinary skill in the art without creative efforts belong to the protection scope of the present invention.

[0022] The terms "first", "second", etc. in the specification, claims and above-mentioned drawings of this article are used to distinguish similar objects, and do not necessarily need to be used to describe a specific order or sequence. It should be understood that such data can be interchanged under appropriate circumstances, so that the embodiments described in this article can be implemented in an order other than those illustrated or described here. In addition, the terms "including" and "having" and any variations thereof are intended to cover non-exclusive inclusion. For example, a process, method, device, product or equipment that includes a series of steps or units does not necessarily have to be limited to those steps or units clearly listed, but may include other steps or units not clearly listed or inherent to these processes, methods, products or equipment. Embodiment 1

[0023] This embodiment provides a computer task processing system with self-improving ability, as Figures 1 to 5 shown, including: The present invention provides a "Gen-pilot" framework. Through this framework, a general intelligent agent Genesis that interacts with all elements of the OS is constructed. Through this intelligent agent, computer tasks are automatically processed, significantly improving the task execution and learning efficiency. This intelligent agent combines a unified operation interface and adaptive learning, supports multi-task parallelism, and can self-drive to learn new application control skills. The specific framework architecture is as Figure 1As shown in the figure, it specifically includes: A planner for obtaining user requirements and decomposing tasks according to the user requirements; A configurator for retrieving existing tools, generating new tools or configuring the execution environment according to the tasks and their requirements decomposed by the planner, and finally returning executable task configuration information, including tool codes, parameters, context information, etc., for the executor to execute, as Figure 3 shown; An executor for executing the decomposed subtasks according to the execution result of the configurator to complete the task operation; An inspector for optimizing the task process and tools based on the self-driven learning method according to the execution feedback of the executor for the task.

[0024] The functional logic of the above framework is described in detail below: (1) The planner includes: a task acquisition unit, a task decomposition unit, and a task relationship organization unit; (1.1) The task acquisition unit is used to: obtain the task request input by the user to the system through voice, text, or API interface (such as "organize the folder", "analyze data", or "batch modify pictures", etc., and this request includes but is not limited to natural language descriptions or explicit operation instructions).

[0025] (1.2) The task decomposition unit is used to: combine the current context information of the system (including but not limited to the file system structure and the running program status, etc.) to perform semantic parsing on the obtained task; in this process, the task is decomposed into multiple subtasks, and each subtask belongs to a specific operation step in the overall task.

[0026] (1.3) The task relationship organization unit is used to: organize multiple subtask nodes according to the dependency relationship by constructing a directed acyclic graph (DAG) (as Figure 2 shown); among them, each subtask is associated with relevant input data, expected output, and its context information.

[0027] In an implementation example, when the task request is "organize the documents and back them up to the cloud", the planner can decompose this request into the following multiple subtasks: 1. Subtask 1 - Retrieve documents: Retrieve all document files from the local file system, organize the local file system paths corresponding to the document files, and output a list containing the above local file system paths.

[0028] 2. Subtask 2 - Filter documents: Filter specific types of files (such as PDF) from the retrieved documents, and filter the path list of specific type files in the document path list.

[0029] 3. Sub-task 3 - Compress Documents: Input a list of paths of specific types of files, compress the files within the paths, and output the path of the compressed file.

[0030] 4. Sub-task 4 - Connect to Cloud Storage: Input the user's cloud storage API key and URL, and output the cloud storage connection status.

[0031] 5. Sub-task 5 - Upload Documents: Input the path of the compressed file and the cloud connection status, upload the compressed document, and finally output the status of the upload completion.

[0032] (2) The configurator includes: a declarative memory unit, a procedural memory unit, and a working memory unit; (2.1) The declarative memory unit is used to: store and manage static knowledge such as user preferences, operation trajectories, and system environment information.

[0033] Specifically, in response to the user's first use of Genesis, the declarative memory unit collects information from the user in terms of conversation style (such as concise or detailed explanations, etc.), tool usage habits (such as commonly used file format processing tools, etc.), and music / video preferences (such as favorite music types or video playback settings, etc.) through a series of guiding questions, and stores this information in the user configuration file.

[0034] Specifically, during the use of Genesis, the declarative memory unit continuously optimizes and updates the above configuration file according to the user's operations and feedback.

[0035] Specifically, when the agent executes tasks (such as browsing the web to obtain information, operating files, or using applications, etc.), record relevant operation trajectories (including but not limited to the accessed URLs, file paths of operations, usage records of applications, etc.), obtain relevant information of the operating system (such as the version number after system updates and changes in the current working directory, etc.), and store this information as semantic knowledge for reference in subsequent tasks.

[0036] (2.2) The procedural memory unit is used to manage the tool library and dynamically generate new tools that meet the task requirements; Specifically, when the system is initialized, configure some basic task processing tools for Genesis (including but not limited to web browsing tools that can open web pages, search for keywords, and obtain web page content, speech-to-text translation tools that can convert voice input into a processable text format, etc.), and store the task processing tools in the tool library in the form of API services or Python files.

[0037] Specifically, in response to the agent finding that the current tool cannot meet the requirements during the task execution process (for example, a new conversion tool is needed when processing files in a specific format), the procedural memory unit activates the tool generation mechanism, analyzes the task requirements, generates corresponding Python code according to the task requirements using natural language processing technology, defines a new tool class, implements the tool configuration for the new specific function, and adds it to the tool library.

[0038] (2.3) Working memory unit, which is used to realize tool allocation, information integration and dynamic feedback processing during task execution; Specifically, in response to the actuator needing to execute a certain task, the working memory unit retrieves the available tool list from the tool library of the procedural memory unit, filters the appropriate tool according to the task requirements, and provides the relevant information of the tool (including but not limited to the usage method and parameter requirements of the tool, etc.) to the actuator.

[0039] Specifically, in response to the need to update the tool code during the task execution process (for example, when it is necessary to fix errors in the tool or optimize the tool performance), the working memory unit obtains the original tool code from the tool library, transfers it to the relevant module for code modification, and updates the updated and modified code back to the tool library.

[0040] Specifically, in response to receiving the subtasks decomposed by the planner, the working memory unit obtains information such as the current working directory and user preferences from the declarative memory unit, integrates the obtained information with the subtask information, forms the complete task configuration information and transfers it to the actuator.

[0041] Specifically, in response to the actuator finishing executing the subtask, the working memory unit receives the execution feedback from the actuator (including but not limited to the execution result and error information, etc.), the working memory unit associates the execution feedback with the original task information, and judges whether the task is successfully completed; when the task is not completed, the working memory unit determines the next operation according to the feedback information (including but not limited to re-executing the task, adjusting the task parameters or starting the self-correction mechanism).

[0042] (3) Actuator, including: execution unit, interaction mode support unit and monitoring unit; (3.1) Execution unit, which is used to: schedule subtasks one by one and call the corresponding tools to complete the actual task operation.

[0043] (3.2) Interaction mode support unit, which is used to: support multiple interaction modes, including but not limited to: command line mode applicable to processing batch tasks, graphical interface simulation mode for completing GUI tasks by operating the mouse and keyboard, and API call mode for directly interacting with the application program interface.

[0044] (3.3)Monitoring unit, for: during the execution of a task, monitoring the running status of the real-time monitoring tool in real time; when an error occurs in the tool (such as the tool crashing or being interrupted unexpectedly, etc.), recording the error log and notifying the checker for processing.

[0045] In an implementation example, when the subtask is "Move a specific file to the target folder", the executor can perform the operation through the file system API and return the result to the main task chain.

[0046] In an implementation example, when the subtask is "Switch the system to the dark (dark color) mode (Dark mode) / Change the system into the Dark mode", as Figure 4 shown, the working principle of the executor is as follows: 1. First, the subtask title is "Change the system into the Dark mode", indicating that the task needs to switch the system to the dark mode.

[0047] 2. At this time, the tool generator of the procedural memory unit generates a tool class named "change_system_appearance(BaseAction)", which contains a script for setting the dark mode, and the corresponding script content is "script='tell app \"System Events\" to tell appearance preferences to set darkmode to true'".

[0048] 3. Based on the above content, the executor performs the following steps: (i) The executor saves the tool as the "change_system_appearance.py" file.

[0049] (ii) The executor executes the saved tool, and the command is "python change_system_appearance.pydark" to complete the execution of the task.

[0050] (4) Checker, including: verification unit, result analysis unit, result feedback unit, and self-driven learning unit; (4.1) Verification unit, for: verifying the execution result of each subtask; Specifically, in response to a file operation task, the verification unit checks whether the target file exists in the target folder.

[0051] Specifically, in response to a data analysis task, the verification unit checks whether the output data meets the expected format or range.

[0052] (4.2) Result analysis unit, configured to: when the task execution fails, analyze the reason for the task execution failure and trigger corresponding fallback operations; Specifically, the first fallback operation includes: requesting the configurator to generate an alternative tool.

[0053] Specifically, the second fallback operation includes: adjusting the task execution process (such as adjusting the execution order of subtasks).

[0054] Specifically, the third fallback operation includes: updating the dependency relationship or input data of the subtasks.

[0055] (4.3) Result feedback unit, configured to: return the verified and optimized task result to the planner for subsequent result integration and display; (4.4) Self-driven learning unit, including: a refinement and iteration unit and a guided practice unit; (4.4.1) Refinement and iteration unit, configured to: during the task execution, learn to generate and execute multiple tentative operations and record the results; In an implementation example, different API calls are tried or different interaction steps are simulated, the successful tools for completing the task are stored in the procedural memory unit, and the failed tools for the uncompleted tasks are recorded in the error log for subsequent analysis and improvement; In an implementation example, taking the adjustment of the system display settings (such as switching the system to the dark / dark mode) as an example, when Genesis receives the corresponding task, the configurator obtains information such as the system version and user preferences from the declarative memory unit, and searches in the procedural memory unit to see if there are any available tools; when no suitable tool is found, the tool generator is called to generate a new tool according to the task requirements (such as a Python class that uses AppleScript in the Mac system to set the system appearance to the dark mode); the executor is called to execute the tool, convert it into executable Python code and run it in the system; the checker evaluates the task completion situation after the execution, and when the task execution is successful, scores the tool according to the evaluation criteria; when the score of the tool is higher than the set threshold (such as 8 points), the tool is used as a successful tool and saved in the tool library for direct call in subsequent similar tasks; when the task execution fails, the tool or the execution process is corrected according to the feedback of the checker, and the task is re-executed; the maximum number of times to re-execute the task is three times, and this iterative operation continues until the task is successful or the upper limit of the task re-execution times is reached.

[0056] (4.4.2)Guided Practice Unit, used for: when the system first encounters a new scenario (for example, the user requests to control a device that has never been connected or operated before), automatically create progressive learning tasks, which are from simple to complex and gradually cover the main functions and features of the new device; In an implementation example, when the new learning task is "learning spreadsheet operations (such as Excel)", the operating principle of the Guided Practice Unit is as follows: 1. Call the Guided Practice Unit to set the learning goal as mastering various data processing and chart-making functions in Excel; based on this, call the Guided Practice Unit to generate a series of tasks using self-guidance technology, including but not limited to: (i) Create a worksheet in Excel that contains specific data.

[0057] (ii) Sort the data in the worksheet.

[0058] (iii) Create a bar chart, etc. based on the data.

[0059] 2. Call the Guided Practice Unit to solve the above tasks in sequence. During the task-solving process, accumulate relevant task execution tools by exploring and trying different operation methods, including but not limited to tools for data reading, writing, calculation, and chart creation, etc.; these tools are implemented in the form of Python classes and interact with Excel using libraries such as openpyxl.

[0060] 3. After completing a certain number of tasks (such as 10 tasks), Genesis' ability in spreadsheet operation tasks is significantly improved. At this time, Genesis can already handle various corresponding spreadsheet tasks through various tools; based on this self-driven active learning mechanism, this system can continuously accumulate new tools and new skills, and expand its applicable range and task processing ability.

[0061] (5) In addition, the Planner is also used for: after all subtasks are completed, integrate the task results of each stage and present them to the user in the form of visualization or data files; for example, the Planner outputs the data analysis task as an Excel report, and the Planner directly displays the processed pictures in the image processing task.

[0062] It should be noted that in this system, users are supported to perform further operations on the task results; when the results do not meet expectations, users are supported to redefine the task goals, and the system will repeat the adjustment process until the results meet the requirements; in addition, all the above examples are only for explaining the present invention and cannot limit the protection scope of the present invention accordingly. Embodiment 2

[0063] This embodiment is based on the same inventive concept as the computer task processing system with self-improving ability described in Embodiment 1, and provides a computer task processing method with self-improving ability, as Figure 6 shown, which includes the following steps: S100. Planning step: Obtain user requirements, and decompose the task into several subtasks according to the user requirements; S200. Configuration step: Load task execution tools, retrieve the task execution tools or generate new tools according to the user requirements and several subtasks, and generate task configuration information; S300. Execution step: Execute the decomposed several subtasks respectively according to the task configuration information to complete the task operation; S400. Inspection step: Optimize the task process based on the self-driven learning ability according to the execution feedback of the actuator for several subtasks, and expand or adjust the task execution tools.

[0064] Different from the prior art, by using the computer task processing system and method with self-improving ability of the present application, it is possible to achieve full interaction at the operating system level through a unified interface, break application limitations; improve adaptability by dynamically expanding tasks and tools; introduce a self-driven learning mechanism to quickly respond to new requirements; and optimize based on efficient feedback to reduce the failure rate and improve task accuracy and efficiency.

[0065] It should be understood that in various embodiments of this article, the magnitudes of the sequence numbers of the above processes do not mean the order of execution. The execution order of each process should be determined according to its function and internal logic, and should not constitute any limitation to the implementation process of the embodiments of this article.

[0066] It should also be understood that in the embodiments of this article, the term "and / or" is only a description of the association relationship of associated objects, indicating that three relationships can exist. For example, A and / or B can represent three situations: A exists alone, A and B exist simultaneously, and B exists alone. In addition, the character " / " in this article generally represents an "or" relationship between the front and back associated objects.

[0067] Those of ordinary skill in the art can realize that the units and algorithm steps of each example described in combination with the embodiments disclosed in this article can be implemented by electronic hardware, computer software, or a combination of the two. To clearly illustrate the interchangeability of hardware and software, the composition and steps of each example have been generally described according to functions in the above description. Whether these functions are executed in a hardware or software manner depends on the specific application and design constraints of the technical solution. Professional technicians can use different methods to implement the described functions for each specific application, but this implementation should not be considered to exceed the scope of this article.

[0068] Those skilled in the art can clearly understand that, for the convenience and brevity of description, the specific logical processes of the methods described above can refer to the corresponding working processes of the systems, devices, and units in the foregoing method embodiments, and will not be elaborated herein.

[0069] In the several embodiments provided in this article, it should be understood that the disclosed systems, devices, and methods can be implemented in other ways. For example, the device embodiments described above are merely illustrative. For example, the division of the units is only a logical function division, and there can be other division methods in actual implementation. For example, multiple units or components can be combined or integrated into another system, or some features can be ignored or not executed. In addition, the displayed or discussed couplings, direct couplings, or communication connections to each other can be indirect couplings or communication connections through some interfaces, devices, or units, and can also be in electrical, mechanical, or other forms of connection.

[0070] The units described as separate components may or may not be physically separated, and the components displayed as units may or may not be physical units, that is, they can be located in one place, or can be distributed to multiple network units. Some or all of the units can be selected according to actual needs to achieve the purpose of the solution of the embodiments in this article.

[0071] In addition, the functional units in the various embodiments of this article can be integrated into one processing unit, or each unit can exist physically alone, or two or more units can be integrated into one unit. The above-mentioned integrated units can be implemented in the form of hardware or in the form of software functional units.

[0072] If the above-mentioned integrated unit is implemented in the form of a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on such an understanding, the essence of the technical solution in this article, or the part that contributes to the prior art, or all or part of the technical solution can be embodied in the form of a software product. The computer software product is stored in a storage medium and includes several instructions for causing a computer device (which can be a personal computer, a server, or a network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of this article. The foregoing storage medium includes: USB flash drives, mobile hard disks, read-only memories (ROM, Read-Only Memory), random access memories (RAM, Random Access Memory), magnetic disks, or optical disks and other various media that can store program codes.

[0073] The above are only embodiments of the present invention, and thus do not limit the patent scope of the present invention. Any equivalent structure or equivalent process transformation made by using the content of the specification and drawings of the present invention, or directly or indirectly applied in other related technical fields, shall be similarly included in the patent protection scope of the present invention.

Claims

1. A computer task processing system with self-improvement capability, characterized in that: include: A planner is used to: obtain user requirements and decompose the task into a number of subtasks according to the user requirements; A configurator is used to: carry a task execution tool, retrieve the task execution tool or generate a new tool according to the user requirements and the plurality of subtasks, and generate task configuration information; An executor is used to: execute the decomposed subtasks respectively according to the task configuration information to complete the task operation; The checker is used to optimize the task process based on the self-driven learning capability according to the execution feedback of the executor on the plurality of subtasks, and to expand or adjust the task execution tool.

2. The computer task processing system with self-improvement capability according to claim 1, characterized in that: The planner includes: a task acquisition unit, a task decomposition unit and a task relationship organization unit; The task acquisition unit is used to: acquire a task request input by a user via voice, text or API interface; The task decomposition unit is used to: perform semantic analysis on the task request and decompose the task into a number of operable subtasks; The task relationship organizing unit is used to organize the nodes of the plurality of subtasks according to dependency relationships.

3. The computer task processing system with self-improvement capability according to claim 1, characterized in that: The configurator includes: a declarative memory unit, a procedural memory unit and a working memory unit; The declarative memory unit is used to store and manage static knowledge, including user preferences, operation trajectories, and system environment information; The program memory unit is used to manage the task execution tool and dynamically generate the new tool according to task requirements; The working memory unit is used to: deploy the task execution tool or the new tool according to the execution process of the subtask, and perform information integration and dynamic feedback processing.

4. The computer task processing system with self-improvement capability according to claim 1, characterized in that: The executor comprises: an execution unit, an interaction mode support unit and a monitoring unit; The execution unit is used to schedule the subtasks one by one and call corresponding tools to complete the actual task operation; The interactive mode support unit is used to: implement interactive functions using a command line mode, a graphical interface simulation mode, and an API call mode; The monitoring unit is used to monitor the running status of the tool during the task execution process, and to log and notify the checker when an error occurs in the tool.

5. The computer task processing system with self-improvement capability according to claim 1, characterized in that: The checker comprises: a verification unit, a result analysis unit, a result feedback unit and a self-driven learning unit; The verification unit is used to: verify the execution result of each subtask; The result analysis unit is used to: when the execution result is execution failure, analyze the cause of the task execution failure, trigger the corresponding backup operation, and optimize the task result based on the backup operation; The result feedback unit is used to: return the verified and optimized task results to the planner; The self-driven learning unit includes: an improvement iteration unit and a guided practice unit; the improvement iteration unit is used to: learn and execute a number of trial operations during task execution, and store other feasible strategies that can complete the task; the guided practice unit is used to: create progressive learning tasks when the application scenario is a new scenario encountered for the first time, and expand the task execution capability based on the progressive learning tasks.

6. The computer task processing system with self-improvement capability according to claim 3, characterized in that: The declarative memory unit is further used to: collect the user's conversation style, tool usage habits and multimedia preference information as a user profile when the user uses it for the first time; the declarative memory unit records the task execution operation track when the task is executed, obtains the operating system related information, and stores the task execution operation track and the operating system related information as semantic knowledge; The program memory unit is further used to: configure the task execution tool when the system is initialized; when the task execution tool cannot meet the task processing requirements, the program memory unit generates the new tool according to the task requirements using natural language processing technology; The working memory unit is further used to: when the executor performs a task, retrieve a list of available tools from the tool library of the procedural memory unit, select a suitable tool from the list of available tools according to the task requirements, and provide relevant information of the suitable tool to the executor; The working memory unit generates the task configuration information about the subtask according to the semantic knowledge.

7. The computer task processing system with self-improvement capability according to claim 5, characterized in that: The backup operation includes: requesting the configurator to generate a replacement tool, adjusting the task execution process, and updating the dependency or input data of the subtask.

8. The computer task processing system with self-improvement capability according to claim 5, characterized in that: The improvement iteration unit is further used to: perform different API call attempts or different interaction step simulation attempts, store successful tools that complete the task in the program memory unit, and record error logs for failed tools that do not complete the task; The guided practice unit is also used to: solve the progressive learning tasks in sequence, explore and try different operation methods in the task solving process, and accumulate task execution tools and strategies.

9. The computer task processing system with self-improvement capability according to claim 1, characterized in that: The planner is further used to: after all subtasks are completed, integrate the execution results of all subtasks and present them to the user in a visual form or a data file form.

10. A computer task processing method with self-improvement capability, characterized in that: The following steps are involved: Planning step: Obtain user requirements and decompose the task into several subtasks according to the user requirements; Configuration step: carrying a task execution tool, retrieving the task execution tool or generating a new tool according to the user requirements and the plurality of subtasks, and generating task configuration information; Execution step: executing the decomposed subtasks respectively according to the task configuration information to complete the task operation; Checking step: According to the execution feedback of the executor on the several subtasks, the task process is optimized based on the self-driven learning capability, and the task execution tool is expanded or adjusted.

Images