Problem processing method and device based on evolutionary agent, equipment and storage medium

Abstract

The invention provides a problem processing method and device based on an evolutionary agent, equipment and a storage medium, and relates to the technical field of artificial intelligence such as large models, agents and evolutionary algorithms. The method comprises the steps of determining a task demand and a current evolution round of a to-be-processed problem, and executing an evolution solving step: determining an improvement strategy of the current evolution round compared with a previous evolution round based on the task demand and historical evolution experience summary; generating a current solution for processing the to-be-processed problem based on the improved strategy; in response to the situation that the current solution does not meet the task demand, generating an evolution experience containing evolution directivity and corresponding to the current evolution round based on the improvement strategy and the actual satisfaction degree of the current solution to the task demand; updating the historical evolutionary experience summary by using the evolutionary experience of the current evolutionary round; and taking the next evolution round as a new current evolution round, and repeatedly executing the evolution solving step until a target solution meeting the task requirement is obtained. The method can bring higher evolution efficiency.

Description

Technical Field

[0001] This disclosure relates to the field of data processing technology, specifically to the fields of artificial intelligence technology such as large models, intelligent agents, and evolutionary algorithms, and particularly to a problem-solving method, apparatus, electronic device, computer-readable storage medium, and computer program product based on an evolutionary intelligent agent. Background Technology

[0002] With the deep application of artificial intelligence technology in scenarios such as complex task optimization and automatic algorithm iteration, traditional algorithm evolution schemes that rely on manual design or single-mode generation are gradually revealing problems such as low generation efficiency, high cost, and insufficient stability of effects.

[0003] Furthermore, as hardware capabilities continue to evolve, software also requires continuous algorithm optimization to maximize hardware performance. Therefore, developing intelligent agents capable of self-evolution and adapting to environmental changes is of paramount importance. Summary of the Invention

[0004] This disclosure presents a problem-solving method, apparatus, electronic device, computer-readable storage medium, and computer program product based on evolutionary intelligent agents.

[0005] In a first aspect, embodiments of this disclosure propose a problem-solving method based on an evolutionary agent, comprising: determining the task requirements and current evolutionary stage of the problem to be solved, and performing the following evolutionary solution steps: determining an improvement strategy for the current evolutionary stage compared to the previous evolutionary stage based on the task requirements and a summary of historical evolutionary experience, wherein the summary of historical evolutionary experience is obtained by summarizing different evolutionary experiences generated from different historical solutions in different historical evolutionary stages; generating a current solution for solving the problem to be solved based on the improvement strategy; in response to the current solution not meeting the task requirements, generating evolutionary experience with evolutionary orientation corresponding to the current evolutionary stage based on the improvement strategy and the actual degree to which the current solution meets the task requirements; and updating the summary of historical evolutionary experience using the evolutionary experience of the current evolutionary stage. The next evolutionary round is taken as the new current evolutionary round, and the evolutionary solution steps are repeated until the target solution that meets the task requirements is obtained.

[0006] Secondly, embodiments of this disclosure propose a problem-solving apparatus based on an evolutionary agent, comprising: an evolutionary solving unit configured to determine the task requirements and current evolutionary round of the problem to be processed, and to execute the following evolutionary solving steps: determining an improvement strategy for the current evolutionary round compared to the previous evolutionary round based on the task requirements and a summary of historical evolutionary experience, wherein the summary of historical evolutionary experience is obtained by summarizing different evolutionary experiences generated from different historical solutions in different historical evolutionary rounds; generating a current solution for processing the problem to be processed based on the improvement strategy; in response to the current solution not meeting the task requirements, generating evolutionary experience with evolutionary orientation corresponding to the current evolutionary round based on the improvement strategy and the actual degree to which the current solution meets the task requirements; updating the summary of historical evolutionary experience using the evolutionary experience of the current evolutionary round; and a repeat execution unit configured to take the next evolutionary round as the new current evolutionary round and repeat the evolutionary solving steps until a target solution that meets the task requirements is obtained.

[0007] Thirdly, embodiments of this disclosure provide an electronic device comprising: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, the instructions being executed by the at least one processor to enable the at least one processor to implement the problem-solving method based on evolutionary intelligent agents as described in the first aspect.

[0008] Fourthly, embodiments of this disclosure provide a non-transitory computer-readable storage medium storing computer instructions that enable a computer to implement the problem-solving method based on evolutionary intelligent agents as described in the first aspect when executed.

[0009] Fifthly, embodiments of this disclosure provide a computer program product including a computer program that, when executed by a processor, can implement the steps of the problem-solving method based on an evolutionary intelligent agent as described in the first aspect.

[0010] The problem-solving scheme based on evolutionary agents disclosed herein determines improvement strategies in each round of evolution based on task requirements and historical evolutionary experience. This allows the improvement strategies to fully utilize effective historical experience, avoiding blind exploration and improving the targeting of the improvement strategies. Furthermore, when the generated current solution does not meet the task requirements, it also generates evolutionary experience containing evolutionary direction by combining the improvement strategy and the actual degree of satisfaction of the current solution, and updates this experience to the historical evolutionary experience summary, achieving cyclical accumulation and reuse of evolutionary experience. Through this cyclical mechanism of "planning-execution-experience summarization based on summarized experience," each round of evolution can adjust its direction based on the experience of the previous round, gradually approaching the task requirements, significantly improving evolutionary efficiency, reducing ineffective evolutionary rounds, and quickly converging to the target solution that meets the task requirements, while ensuring the accuracy of the target solution's performance in meeting the task requirements.

[0011] It should be understood that the description in this section is not intended to identify key or essential features of the embodiments of this disclosure, nor is it intended to limit the scope of this disclosure. Other features of this disclosure will become readily apparent from the following description. Attached Figure Description

[0012] Other features, objects, and advantages of this disclosure will become more apparent from the following detailed description of non-limiting embodiments with reference to the accompanying drawings: Figure 1 This is an exemplary system architecture to which this disclosure can be applied; Figure 2 A flowchart of a problem-solving method based on an evolutionary intelligent agent provided in this disclosure embodiment; Figure 3 A flowchart illustrating a method for determining the current solution based on an improved strategy, provided in this embodiment of the disclosure; Figure 4 A flowchart illustrating a method for determining a target solution generation mode provided in this embodiment of the disclosure; Figure 5 A flowchart of a hierarchical memory storage method provided in this disclosure embodiment; Figure 6 A flowchart illustrating a method for determining the current parent solution based on an improvement strategy, provided in this embodiment of the disclosure; Figure 7 A flowchart illustrating a method for generating evolutionary experience provided in this embodiment of the disclosure; Figures 8-1 to 8-7 These are all schematic diagrams of different structural processes provided in specific application scenarios according to the embodiments of this disclosure; Figure 9 A structural block diagram of a problem processing device based on an evolutionary intelligent agent provided in this disclosure embodiment; Figure 10 This is a schematic diagram of the structure of an electronic device suitable for executing a problem-solving method based on an evolutionary agent, provided as an embodiment of the present disclosure. Detailed Implementation

[0013] The exemplary embodiments of this disclosure are described below with reference to the accompanying drawings, including various details of the embodiments to aid understanding; these should be considered merely exemplary. Therefore, those skilled in the art will recognize that various changes and modifications can be made to the embodiments described herein without departing from the scope and spirit of this disclosure. Similarly, for clarity and brevity, descriptions of well-known functions and structures are omitted in the following description. It should be noted that, unless otherwise specified, the embodiments and features described in this disclosure can be combined with each other.

[0014] The collection, storage, use, processing, transmission, provision, and disclosure of user personal information involved in the technical solution disclosed herein comply with the provisions of relevant laws and regulations and do not violate public order and good morals.

[0015] Figure 1 An exemplary system architecture 100 is shown that can be applied to embodiments of the problem-solving methods, apparatuses, electronic devices, and computer-readable storage media based on evolutionary intelligent agents disclosed herein.

[0016] like Figure 1 As shown, system architecture 100 may include terminal devices 101, 102, and 103, a network 104, and a server 105. Network 104 serves as the medium for providing communication links between terminal devices 101, 102, and 103 and server 105. Network 104 may include various connection types, such as wired or wireless communication links, or fiber optic cables, etc.

[0017] Users can use terminal devices 101, 102, and 103 to interact with server 105 via network 104 to receive or send messages, etc. Various applications for enabling information communication between the terminal devices 101, 102, and 103 and server 105 can be installed. These applications include problem-solving applications, evolutionary intelligent agent framework applications, and instant messaging applications.

[0018] Terminal devices 101, 102, and 103 and server 105 can be either hardware or software. When terminal devices 101, 102, and 103 are hardware, they can be various electronic devices with displays, including but not limited to smartphones, tablets, laptops, and desktop computers. When terminal devices 101, 102, and 103 are software, they can be installed in the aforementioned electronic devices, and can be implemented as multiple software programs or software modules, or as a single software program or software module; no specific limitation is made here. When server 105 is hardware, it can be implemented as a distributed server cluster composed of multiple servers, or as a single server. When server 105 is software, it can be implemented as multiple software programs or software modules, or as a single software program or software module; no specific limitation is made here.

[0019] Server 105 can provide various services through its built-in applications. Taking a problem-solving application using an evolutionary agent framework as an example, when running this application, server 105 can achieve the following: First, it receives the problem to be processed from terminal devices 101, 102, and 103 via network 104. Then, it determines the task requirements and current evolutionary round of the problem and executes the following evolutionary solution steps: Based on the task requirements and historical evolutionary experience summary, it determines the improvement strategy for the current evolutionary round compared to the previous evolutionary round. This historical evolutionary experience summary is obtained by summarizing different evolutionary experiences generated from different historical solutions in different historical evolutionary rounds. Based on the improvement strategy, it generates a current solution for processing the problem. In response to the current solution not meeting the task requirements, based on the improvement strategy and the actual degree to which the current solution meets the task requirements, it generates evolutionary experience with evolutionary direction corresponding to the current evolutionary round. It updates the historical evolutionary experience summary using the evolutionary experience of the current evolutionary round. It takes the next evolutionary round as the new current evolutionary round and repeats the evolutionary solution steps until the target solution that meets the task requirements is obtained.

[0020] Furthermore, the server 105 can return the calculated target solution to the terminal devices 101, 102, and 103 via the network 104.

[0021] It should be noted that, in addition to being temporarily obtained from terminal devices 101, 102, and 103 via network 104, the pending issues can also be pre-stored locally on server 105 through various means. Therefore, when server 105 detects that this data is already stored locally (e.g., when starting to process previously stored pending tasks), it can choose to directly obtain this data from locally. In this case, the exemplary system architecture 100 may also exclude terminal devices 101, 102, and 103 and network 104.

[0022] Since using the evolutionary agent framework to handle problems requires significant computing resources and power, the problem-solving methods based on evolutionary agents provided in the subsequent embodiments of this disclosure are generally executed by a server 105 with strong computing power and abundant computing resources. Correspondingly, the problem-solving device based on evolutionary agents is also generally located within the server 105. However, it should also be noted that when terminal devices 101, 102, and 103 also possess sufficient computing power and resources, they can also perform the aforementioned calculations performed by the server 105 through the problem-solving applications installed on them, thereby outputting the same results as the server 105. Especially when multiple terminal devices with different computing capabilities exist simultaneously, but the problem-solving application determines that its terminal device has strong computing power and abundant remaining computing resources, it can allow the terminal device to perform the aforementioned calculations, thereby appropriately reducing the computing pressure on the server 105. Accordingly, the problem-solving device based on evolutionary agents can also be located within terminal devices 101, 102, and 103. In this case, the exemplary system architecture 100 may also exclude the server 105 and the network 104.

[0023] It should be understood that Figure 1 The number of terminal devices, networks, and servers shown is merely illustrative. Depending on implementation needs, any number of terminal devices, networks, and servers can be included.

[0024] Please refer to Figure 2 , Figure 2 A flowchart of a problem-solving method based on an evolutionary intelligent agent provided in this disclosure embodiment, wherein process 200 includes the following steps: Step 201: Determine the task requirements and current evolutionary round of the problem to be addressed, and execute the evolutionary solution steps; This step is intended for the implementation of problem-solving methods based on evolutionary agents (e.g., Figure 1 The server 105 shown or any problem-solving application installed on it determines the task requirements of the problem to be solved and the current evolutionary round, so as to execute the preset evolutionary solution steps for the current evolutionary round (corresponding to step 202, which includes steps 2021 to 2024 below). This step serves as the foundation for initiating the evolutionary solution, and its core function is to provide a clear goal orientation and progress tracking benchmark for each subsequent evolutionary round, ensuring that the evolutionary process always revolves around the actual needs of the system or user.

[0025] The problem to be addressed refers to the specific problem type that needs to be solved, such as algorithm optimization (e.g., optimizing the classification accuracy of a random forest model), mathematical reasoning (e.g., proving the correctness of the Pythagorean theorem), or code generation (e.g., generating Python code for sorted arrays). Different problem types typically correspond to different optimization dimensions. For example, algorithm optimization focuses on "accuracy" and "running time," while mathematical reasoning focuses on "logical correctness" and "completeness of reasoning steps." If the problem to be addressed is unclear, subsequent evolution may deviate from the actual needs (e.g., misjudging "code generation" as "algorithm optimization," leading to an incorrect evolutionary strategy). The aforementioned execution entity can determine the problem to be addressed through user input parsing (e.g., extracting the keyword "classification model optimization" from the user's problem description), system preset tags (e.g., the "recommendation algorithm optimization" tag for internal tasks), or contextual association (e.g., shifting from "accuracy optimization" to "running time optimization" in multiple rounds of tasks).

[0026] The task requirements are the specific goals of the problem to be addressed, which can be divided into quantitative requirements (such as "classification accuracy ≥ 90%" and "running time ≤ 10 seconds") and qualitative requirements (such as "reasoning process conforms to mathematical logic" and "code can be executed correctly"). These requirements serve as the endpoint benchmark for evolution. All evolutionary steps (such as improving strategy formulation and generating the current solution) aim to meet these task requirements. If the task requirements are unclear, evolution may fall into "infinite optimization" (such as constantly pursuing higher accuracy without setting a stopping threshold) or "deviate from the goal" (such as misjudging "code correctness" as "code conciseness"). The aforementioned execution entity can extract task requirements from user input (such as "target: accuracy ≥ 0.9" in the task configuration file), natural language parsing (such as extracting the "correct execution" requirement from "generating correctly sorted code"), or system configuration (such as the internal task's preset "recall rate ≥ 80%)).

[0027] The current evolutionary round is a progress counter for the evolutionary process, representing the evolutionary cycle that the aforementioned executor has completed (e.g., the 3rd evolutionary round). Each evolutionary round actually corresponds to the complete process of "improvement strategy formulation → current solution generation → evaluation → experience summary". The higher the round, the richer the accumulated historical evolutionary experience (e.g., the 3rd round can refer to the experience of the 1st and 2nd rounds). At the same time, the round is also the basis for judging whether the evolution needs to be adjusted (e.g., if the round exceeds the preset upper limit and still does not meet the requirements, the aforementioned executor may change the improvement strategy generation method). The aforementioned executor can manage the round through a counter: the counter is set to "1" when the task starts (the 1st round is about to begin), and the counter is incremented by 1 after each evolutionary round is completed (e.g., updated to "2" after the 1st round is completed). The counter value is read before each evolutionary round to determine the current round.

[0028] This step establishes the basic framework for evolutionary problem-solving by considering the problem to be addressed, the task requirements, and the current evolutionary round. The problem determines the direction of evolution, the task requirements set the endpoint, and the current round tracks the evolutionary progress. Only when these elements are clearly defined can the implementing entities develop targeted improvement strategies in subsequent stages (e.g., based on the "algorithm optimization" problem type and the requirement of "accuracy ≥ 90%", develop an improvement strategy of "optimizing feature engineering"), avoiding blind exploration.

[0029] Step 2021: Based on task requirements and historical evolutionary experience, determine the improvement strategy for the current evolutionary round compared to the previous evolutionary round; This step aims to have the aforementioned implementing entity determine the improvement strategy for the current evolutionary round compared to the previous evolutionary round, based on task requirements and historical evolutionary experience. This historical evolutionary experience summary is obtained by summarizing the different evolutionary experiences generated from different historical solutions in different historical evolutionary rounds. In other words, the purpose is to adjust the evolutionary direction by reusing past evolutionary experience and combining it with the specific goals of the current task, so as to avoid repeated and ineffective exploration.

[0030] The historical evolution experience summary comprises reusable knowledge compiled by the aforementioned implementing entities from different historical evolutionary cycles, including "historical solutions," performance evaluations, and improvement suggestions. "Historical solutions" refer to intermediate results or methods used in previous cycles to handle the problem, such as "substitution method solution steps" or "elimination method solution results" in mathematical problems. "Performance evaluation" assesses whether historical solutions meet task requirements, such as "correct results but cumbersome steps" or "feasible methods but prone to errors." "Improvement suggestions" address shortcomings in historical solutions, such as "simplifying step logic" or "changing the solution method." The implementing entities use language analysis techniques or rule engines to summarize this information into structured experience fragments, such as "substitution method is suitable for systems of equations with few variables, but attention must be paid to the accuracy of the calculation steps; elimination method is concise, but if symbol processing is incorrect when merging equations, it can easily lead to result deviations," and store this information in a dedicated experience database.

[0031] This improvement strategy represents the optimization direction of the current evolutionary round compared to the previous one, and its generation logic can fully follow the principle of "inheriting effective experience + correcting past shortcomings + meeting current needs." For example, the previous evolutionary round used the "elimination method" to solve the system of equations, which yielded correct results and was concise, but it did not check the correctness of the equation combination and merging (a past shortcoming). Historical experience shows that "the elimination method is concise, but it is necessary to ensure the correctness of the signs when merging equations" (effective experience), and the current task requires "correct results and concise steps" (current needs). Combining this information, the improvement strategy generated by the above-mentioned execution entity can be: "continue to use the elimination method to solve the problem, and add a step to check the correctness of the equation combination and merging," such as verifying whether "x+y+2x-y" equals "3x" before adding the two equations, to avoid result deviation due to sign errors.

[0032] Taking the solution of the system of equations "x + y = 5, 2x - y = 1" as an example: The aforementioned executor can retrieve historical solutions from previous rounds from the experience database: In the first round, the "substitution method" was used, with the steps being "substituting x = 5 - y into the second equation to calculate y = 3, x = 2," which yielded the correct result but was cumbersome; in the second round, the "elimination method" was used, with the steps being "adding the two equations to get 3x = 6, solving for x = 2, y = 3," which yielded the correct result and was concise, but no correctness check was performed. Historical experience summarizes that "both substitution and elimination methods can solve the problem correctly, but elimination is more concise; the elimination method requires attention to the correctness of the signs in the equation combination and combination." The current task requirement is "correct result and concise steps," and the previous round's strategy was "elimination method." Based on this information, the aforementioned executor generates an improved strategy for the current round: "Continue using the elimination method, but add a correctness check step for the equation combination and combination."

[0033] It is worth noting that this summary of historical evolutionary experience can include not only successful experiences but also unsuccessful ones. For example, "trial and error methods for solving systems of equations are prone to errors in guessing, leading to biased results." The aforementioned implementing entity will avoid using such methods. If the improvement strategy for the current round does not meet the task requirements, such as "elimination methods are simple but produce incorrect results," the implementing entity can adjust the weight of task requirements, for example, increasing the weight of "correct results" and decreasing the weight of "simple steps," and regenerating the improvement strategy, such as "using the substitution method to ensure correct results." In addition, the improvement strategy will be translated into executable operational instructions, such as "calling the 'equation combination and correctness check' function in the elimination method" to ensure accurate execution when generating the current solution in subsequent iterations.

[0034] Step 2022: Generate a current solution for handling the problem based on the improved strategy; Building upon step 2021, this step aims to generate a current solution for the problem to be addressed by the aforementioned implementing entity based on the improved strategy. This is a core step in the evolutionary solution process, transforming abstract optimization directions into concrete solutions. The overall implementation approach is as follows: based on the improved strategy determined in the previous step (e.g., "solving the system of equations using the elimination method and adding a correctness check"), specific and executable solutions for the problem to be addressed (e.g., "specific solution steps of the elimination method + correctness check process") are generated through technologies such as natural language processing, knowledge retrieval, and strategy fusion.

[0035] In this context, the improvement strategy is an abstract optimization direction, such as "adopting a simpler method" or "adding a correctness check," while the current solution is a specific executable plan. The aforementioned implementing entity can first use natural language processing technology to break down the key instructions in the improvement strategy, such as "elimination method" being the method framework and "correctness check" being an additional requirement. Then, it can retrieve the corresponding specific method templates from the domain knowledge base (such as the "equation system solution method library" for mathematical problems). For example, the steps of the elimination method are usually merging equations, solving for variables, and back-substituting for verification. Then, the additional requirements in the improvement strategy are integrated into the template, such as adding a step of "verifying whether the merged result is correct" after the "merging equations" step. Finally, a generative model (such as a natural language generation model) is used to output a specific solution that meets the requirements of the strategy.

[0036] Taking the solution of the system of equations "x+y=5, 2x-y=1" as an example, if the improved strategy is "to continue using the elimination method and add a correctness check step for combining equations", then the process by which the above-mentioned execution entity generates the current solution can be as follows: First, analyze the key instructions in the strategy to determine to use the elimination method and add a correctness check; then find the step template for the elimination method from the mathematical knowledge base, namely, merging equations, solving for variables, and back substitution verification; then integrate the correctness check into the template, and the adjusted steps are: merge equations (x+y+2) / ( ... The steps are: x-y=5+1→3x=6), check the correctness of the merging (the left side is 3x after merging, the right side is 6, confirming it is correct), solve for x (3x=6→x=2), substitute back to find y (2+y=5→y=3), verify the result (2+3=5, 2×2-3=1); finally, generate the specific solution steps and results, such as "1. Add the two equations to get 3x=6; 2. Check the correctness of the merging; 3. Solve for x=2; 4. Substitute back to get y=3; 5. Verify the result is correct", the result is x=2, y=3.

[0037] In practice, the aforementioned execution entity may generate multiple candidate solutions that conform to the improvement strategy. For example, some may add checks after merging equations, while others may add checks after back substitution. Then, the optimal candidate solution is selected as the current solution through simple evaluation (such as the comprehensiveness of the checks). If a candidate solution does not meet the strategy requirements, such as omitting a correctness check step, the aforementioned execution entity can also correct it in real time through a rule engine, automatically inserting the check step. For problems in different domains, such as code generation, the aforementioned execution entity can also use a syntax rule engine to generate code that conforms to the strategy; while for algorithm optimization problems, it can also use a machine learning model to generate parameter configurations, but the core logic is to transform the abstract strategy into a concrete solution.

[0038] Step 2023: In response to the current solution not meeting the task requirements, based on the improvement strategy and the actual degree to which the current solution meets the task requirements, generate evolutionary experience with evolutionary orientation corresponding to the current evolutionary round; Building upon step 2022, this step aims to generate evolutionary experience with evolutionary direction based on the improvement strategy and the actual degree to which the current solution meets the task requirements when the aforementioned implementing entity fails to meet the task requirements. Specifically, when the current solution fails to achieve the task objective (e.g., "the result is correct but the steps are cumbersome," or "the result is incorrect"), the root cause of the unmet requirements is analyzed by comparing the expected performance of the improvement strategy with the actual performance of the current solution, thereby generating specific improvement directions to guide the next round of evolution.

[0039] The execution of this step depends on several key inputs, including: unmet task requirements (triggering conditions), the improvement strategy of the current round (reference framework), and the actual degree to which the current solution meets the requirements (evaluation criteria). First, the executing entity can assess whether the current solution meets the task requirements. For example, if the task requirement is "the solution to the system of equations is correct and the number of steps is ≤3," and the current solution is correct but has 4 steps, then the condition of unmet requirements is triggered. Next, the improvement strategy of the current round (e.g., "using elimination and simplifying steps") is reviewed to confirm whether the current solution follows the strategy framework. For example, whether elimination was used and whether steps were attempted to be simplified. If the improvement strategy requires "simplifying steps" but the current solution still uses 4 steps, it indicates that the simplification goal of the strategy has not been fully achieved. Then, the actual degree to which the current solution meets the task requirements can be calculated using a multi-dimensional evaluation model. The evaluation dimensions include quantitative indicators (such as the number of steps, the result...). The task requirement is weighted as "correct result (60%) + concise steps (40%)". The current solution is correct and scores 60 points, and the 4 steps score 30 points. The actual satisfaction level is 90 points, but the task requirement is not met because the concise steps do not reach the threshold of ≤3 steps. Finally, the root cause of the unmet requirement can be analyzed through the causal reasoning model (such as the cumbersome steps are because the elimination method retains redundant back-substitution verification steps). Combined with the unimplemented part of the improvement strategy, experience containing evolutionary orientation can be generated (such as "the elimination method is effective but the steps can be optimized. It is recommended to directly calculate the variable coefficients when merging equations to reduce intermediate steps").

[0040] Taking the solution of the system of equations "x+y=5, 2x-y=1" as an example, if the task requirement is "correct result and ≤3 steps", the current round's improvement strategy is "to use the elimination method and simplify the steps". If the current solution is solved using the elimination method, the steps are 4 (merging equations → solving x → substituting back to find y → verifying the result). The result is correct, but the steps exceed the requirement, failing to meet the task requirement. In this case, the implementing entity can review the improvement strategy to confirm that the current solution follows the elimination method framework, but the goal of simplifying the steps has not been achieved. When assessing the actual degree of satisfaction, 60 points are awarded for the correct result and 30 points for the 4 steps, for a total score of 90 points, but the simplification of the steps does not meet the standard. Therefore, causal reasoning suggests that the cumbersome steps are due to the retention of redundant back-substitution verification steps, leading to evolutionary experience: "The current solution yields the correct result using elimination (meeting the requirement of using elimination in the improvement strategy), but the steps are 4 (not meeting the goal of simplifying the steps); the reason for not meeting the requirement is the retention of redundant back-substitution verification steps. Therefore, the evolutionary guidance suggestion obtained at this time can be specifically: optimize the elimination steps, remove the back-substitution verification steps (if the merging equations are correct, the solution result can directly satisfy the original equation system), and simplify the steps to 3 steps."

[0041] It is worth noting that evolutionary experience should be as specific and actionable as possible, avoiding ambiguity. For example, if the current solution result is incorrect due to a sign error when merging equations in the elimination method, the evolutionary experience should be "The elimination method needs to pay attention to the correctness of signs; it is recommended to add a sign checking step (such as verifying whether the coefficients of the merged equations are correct)", rather than "Improve the elimination method". For situations where multiple task requirements are not met (such as "incorrect result + cumbersome steps"), the aforementioned execution entity can prioritize the reasons (such as solving the result error problem first, and then optimizing the steps) and generate corresponding evolutionary experience. In addition, evolutionary experience can also be linked to the improvement strategy of the current round and the specific performance of the current solution (such as "Improvement strategy: Use the elimination method and simplify the steps; Current solution: Step 4, result is correct; Experience: Remove the back-substitution verification step"), ensuring accurate reference in the next round of evolution.

[0042] Step 2024: Update the historical evolutionary experience summary using the evolutionary experience of the current evolutionary cycle; Building upon step 2023, this step aims to have the aforementioned implementing entity update the historical evolutionary experience summary using the evolutionary experience of the current evolutionary round. This involves integrating the specific improvement experiences of the current round for a particular problem (such as "elimination methods can remove the back-substitution verification step") into the historical experience base, transforming them into domain-general knowledge for direct reference in subsequent evolutionary rounds, thus avoiding redundant exploration.

[0043] This step essentially provides a transformation logic from specific experience to general knowledge, which can be achieved through the following technical steps: First, it can involve experience extraction. For example, natural language processing techniques can be used to extract a triple of key information—"method, improvement point, and effect"—from current evolutionary experience. For instance, the current experience "When solving by elimination, if merging equations is correct, the back-substitution verification step can be removed, simplifying the steps to 3" would be extracted as "method = elimination, improvement point = removing the back-substitution verification step, effect = the steps are simplified from 4 to 3 and the result is correct." Next, it can involve knowledge fusion, which can be achieved through a knowledge graph engine. The extracted key information is compared with existing entries in the historical experience summary. For example, the original entry for "elimination method" in the historical summary was "simple steps (merging equations → solving variables → back substitution verification), but attention should be paid to the correctness of the merged equations." After the update, improvements and effects of the current experience will be added, changing it to "simple elimination steps (back substitution verification can be removed, simplifying to 3 steps), but attention should be paid to the correctness of the merged equations." Finally, weight adjustments can be made. The reliability of the current experience can be judged through the experience validity evaluation model (such as whether it is verified to be effective in subsequent rounds), and its weight in the historical summary can be adjusted accordingly. For example, the weight of the first generated experience is set to "medium." If it is verified to be effective in subsequent rounds (simplified steps and correct results), the weight will be increased to "high," and vice versa.

[0044] Taking the solution of the system of equations "x+y=5, 2x-y=1" as an example, if the evolutionary experience of the current round is "when solving by elimination, if the merging of equations is correct, the back-substitution verification step can be removed, simplifying the steps to 3", the above-mentioned execution entity can first extract the key information triplet: method = elimination, improvement point = removal of back-substitution verification step, effect = simplified steps and correct result. Then, it can retrieve the "elimination method" entry in the historical summary. The original content was "simple steps (merging equations → solving variables → back-substitution verification), but attention should be paid to the correctness of merging equations". The improvement point and effect of the current experience are added to update it to "simple elimination steps (back-substitution verification can be removed, simplifying to 3 steps), but attention should be paid to the correctness of merging equations". Finally, since the current experience has not been verified by subsequent rounds, the weight is set to "medium". If the solution generated by this experience in subsequent rounds meets the task requirements, the weight will be increased to "high".

[0045] The historical evolution experience summary can be updated incrementally, adding or modifying only the experience from the current round while avoiding overwriting existing knowledge (e.g., the experience of the "substitution method" is still retained). The experience can be stored in a knowledge graph structure, with nodes representing methods (e.g., elimination), edges representing improvement suggestions (e.g., removing back-substitution verification), and attributes representing effects (e.g., simplifying steps), facilitating subsequent retrieval and reuse. Other storage methods can also be used. If multiple rounds generate experience on the same method (e.g., "elimination requires adding sign checks"), these experiences can be merged into a single entry to form more comprehensive knowledge (e.g., "elimination can remove back-substitution verification and requires adding sign checks to ensure the merged equations are correct").

[0046] Step 203: Take the next evolutionary round as the new current evolutionary round, and repeat the evolutionary solution steps until the target solution that meets the task requirements is obtained.

[0047] This step builds upon the fact that the evolutionary solution steps described in step 202 for each evolutionary round have been completed once. The aim is for the aforementioned executor to treat the next evolutionary round as the new current evolutionary round and repeatedly execute the evolutionary solution steps until the target solution that meets the task requirements is obtained. The purpose is to use a built-in round management and real-time checking mechanism to allow the aforementioned executor to continuously repeat the process of "formulating improvement strategies—generating current solutions—evaluating task requirements—summarizing evolutionary experience—updating historical knowledge" until a solution that meets the task objectives is found.

[0048] This step can be executed using two key mechanisms: round tracking and loop triggering. Round tracking is achieved through a built-in counter. After each complete evolutionary cycle (from determining the improvement strategy to updating historical experience), the counter automatically increments by one, setting "next cycle" as the new "current cycle." For example, after the first cycle, the counter changes from "1" to "2," and the second cycle becomes the new current cycle. Loop triggering is driven by a real-time checking mechanism, which constantly checks whether the current solution meets the task requirements (such as "correct result" or "no more than 3 steps"). If not, it triggers the next iteration, starting from the new current cycle and re-executing the entire evolutionary process. If the requirements are met (such as the steps are simplified to 3 and the result is correct), it stops iterating and outputs the target solution.

[0049] Taking the solution of the system of equations "x+y=5, 2x-y=1" as an example, if the task requirement is "the result is correct and the number of steps does not exceed 3", the iterative process can be specifically as follows: Round 1: Taking "Round 1" as the current round, based on the initial historical experience ("Elimination method steps include merging equations, solving for variables, and back substitution verification"), determine the improvement strategy ("Use elimination method and simplify the steps"). The generated current solution is a 4-step elimination process (merging equations → solving for x → back substitution to find y → verifying the result), the result is correct but the steps exceed the limit. Summarize the experience ("Elimination method can remove the back substitution verification step, simplifying to 3 steps"), and update the historical experience ("Elimination method steps can be simplified to merging equations → solving for variables → substituting to find y"). Increment the counter and proceed to Round 2.

[0050] Round 2: Taking "Round 2" as the current round, based on the updated historical experience ("Elimination method can eliminate the back-substitution verification step"), an improvement strategy is determined ("Use elimination method, eliminate the back-substitution verification step"). The generated current solution is a 3-step process (merging equations → solving x → substituting to find y), and the result is correct and the steps meet the requirements. A real-time checking mechanism determines that the task requirements are met, stops the iteration, and outputs the target solution ("x=2, y=3").

[0051] Furthermore, to avoid infinite loops, multiple termination conditions can be set: in addition to the priority condition of "meeting task requirements," there are also "maximum number of iterations" (e.g., a maximum of 10 iterations; if the requirement is still not met, the current optimal solution is output) and "experience reuse rate threshold" (if the improvement strategy in a certain round completely reuses historical experience and there are no new optimization directions, the iteration stops); even further, the above-mentioned execution entity can also dynamically adjust the evolution process: if the improvement strategies in the previous rounds have not effectively improved (e.g., using elimination methods without simplifying the steps), the strategy will be adjusted in the next round (e.g., trying the substitution method and comparing the steps of the two methods); if the requirements are not met in the previous rounds due to "incorrect results," the weight of "correct results" will be increased in the next round (e.g., from 60% to 80%), prioritizing the resolution of result issues.

[0052] The problem-solving method based on evolutionary agents provided in this disclosure determines improvement strategies in each round of evolution based on task requirements and historical evolutionary experience summaries. This allows the improvement strategies to fully draw on effective historical experience, avoiding blind exploration and improving the targeting of the improvement strategies. Simultaneously, when the generated current solution does not meet the task requirements, it also generates evolutionary experience containing evolutionary direction by combining the improvement strategy and the actual degree of satisfaction of the current solution, and updates this experience to the historical evolutionary experience summary, realizing the cyclical accumulation and reuse of evolutionary experience. Through this cyclical mechanism of "planning based on summarized experience—execution—experience summarization," each round of evolution can adjust its direction based on the experience of the previous round, gradually approaching the task requirements, significantly improving evolutionary efficiency, reducing ineffective evolutionary rounds, and quickly converging to the target solution that meets the task requirements, while ensuring the accuracy of the target solution's performance in meeting the task requirements.

[0053] To further understand step 2022, please refer to [the relevant documentation / reference]. Figure 3 , Figure 3 A flowchart of a method for determining the current solution based on an improved strategy is provided for embodiments of this disclosure, wherein process 300 includes the following steps: Step 301: Based on the improved strategy, select the current parent solution from the memory evolution library that stores all historical solutions; This memory evolution library is a structured database that stores all historical solutions (such as the steps, results, and evaluation information of solving the system of equations using elimination and substitution methods in previous rounds) in the aforementioned execution entity. Its core function is to provide a "basic template" (i.e., parent solution) for the improvement of the current round.

[0054] The selection of a parent solution can be based on the matching degree between the improvement strategy and historical solutions. For example, the aforementioned executor can retrieve historical solutions consistent with the strategy theme from the memory evolution library based on the current round's improvement strategy (such as "simplifying the elimination process"), and use them as the current parent solution. For instance, if the improvement strategy is "optimizing the simplicity of the elimination process," historical solutions related to "elimination" (such as "4 steps, correct result") can be selected from the memory evolution library as parent solutions, because subsequent improvements need to be adjusted based on the framework (elimination) of that solution.

[0055] Step 302: Based on the current parent solution and task requirements, determine the target solution generation mode; The objective solution generation mode determines how the current solution is generated (i.e., through a single interaction or multiple interactions), and its determination process can depend on a combination of the satisfaction level of the parent solution and the inherent properties of the problem. One possible implementation, including but not limited to, can be found in [reference needed]. Figure 4 The specific implementation method shown is as follows: Step 401: Determine the first information based on the actual degree to which the current parent solution meets the task requirements; Step 402: Determine the second information based on the problem to be processed, the problem type, and the difficulty of the task requirements; Step 403: Determine the solution generation cost based on the first and second information; Step 404: Determine the solution generation mode corresponding to the solution generation cost as the target solution generation mode.

[0056] Regarding step 403, when the solution generation cost is less than a preset generation cost threshold, a single-turn dialogue can be determined as the target solution generation mode, where a single-turn dialogue refers to generating a solution through one interaction; while when the solution generation cost is not less than the preset generation cost threshold, a multi-turn dialogue can be determined as the target solution generation mode, where a multi-turn dialogue refers to generating a solution through at least two interactions or at least two execution steps.

[0057] The determination process of the solution generation cost can be further understood by referring to the following two examples. For instance, when the first information is that the actual degree of satisfaction of the current parent solution with the task requirements is lower than a preset satisfaction threshold, and the second information contains a problem type of mathematical algorithm evolution and a difficulty level of finding an effective solution, then a value less than the preset generation cost threshold can be determined as the solution generation cost. This indicates that the overall difficulty of the current problem is not high, and only a value less than the preset generation cost threshold needs to be determined as the solution generation cost so that a solution can be generated through a single-turn dialogue. As another example, when the first information is that the actual degree of satisfaction of the current parent solution with the task requirements is lower than a preset satisfaction threshold, and the second information contains a problem type of mathematical algorithm evolution and a difficulty level of breaking through the target limit, then a value not less than the preset generation cost threshold can be determined as the solution generation cost. This indicates that the overall difficulty of the current problem is relatively high, and therefore a value not less than the preset generation cost threshold needs to be determined as the solution generation cost so that a solution can be generated better through a multi-turn dialogue.

[0058] Taking mathematical algorithm evolution as an example, the types of problems to be processed require algorithmic optimization to solve. The difficulty level of the task requirements can range from simple tasks like "finding an effective solution" that only need to meet basic requirements, to more difficult tasks like "breaking through the target limit value" that require reaching the optimal state. The aforementioned execution entity can transform this information into "solution generation cost" (e.g., the cost of "finding an effective solution" is low, while the cost of "breaking through the limit value" is high) through a solution generation cost model (e.g., the time and computational cost of calculating the solution generation). If the cost is less than a preset threshold (e.g., "low cost"), a single-turn dialogue is used (generating a solution once, such as "directly outputting the simplified elimination steps"); if the cost is not less than the threshold (e.g., "high cost"), a multi-turn dialogue is used (multiple interactive optimizations, such as "first generating preliminary steps, then gradually simplifying").

[0059] For example, if the parent solution is "elimination method in 4 steps, result is correct" (low satisfaction level), the problem type is "mathematical algorithm evolution", and the task requirement is "find an effective solution (steps ≤ 3)" (low difficulty level), then the solution generation cost is low (less than the threshold), and a single-turn dialogue mode is adopted; if the task requirement is "break through the target limit value (steps ≤ 2)" (high difficulty level), then the solution generation cost is high (not less than the threshold), and a multi-turn dialogue mode is adopted (such as "first generate 3 steps, then optimize to 2 steps").

[0060] Step 303: Based on the current parent solution, generate multiple candidate sub-solutions according to the target solution generation mode and improvement strategy; One specific implementation method is as follows: based on the current parent solution, M candidate sub-solutions are generated in the dialogue provided by the target solution generation mode according to the improvement strategy; wherein, the method of generating M candidate sub-solutions will be retried a maximum of N times if the actual satisfaction level of any candidate sub-solution does not exceed the actual satisfaction level of the current parent solution, and the size of M increases with the increase of the actual number of retries.

[0061] Among them, the candidate sub-solution is a variant of the parent solution (e.g., the parent solution is a 4-step elimination method, and the sub-solution is a 3-step elimination method, a 2-step elimination method, etc.). Its generation logic can be "parent solution framework + improvement strategy + target mode". The parent solution framework retains the core method of the parent solution (e.g., elimination method) to ensure the coherence between the sub-solution and the parent solution. The improvement strategy is to incorporate the improvement direction (e.g., "simplification steps") into the sub-solution (e.g., removing the back substitution verification step). The target mode is a single-round dialogue mode, which generates M candidate sub-solutions (e.g., M=3, and simultaneously generates "3 steps to remove back substitution verification", "3 steps to merge equations", and "3 steps to optimize calculation"). If none of the candidate sub-solutions exceed the parent solution (e.g., they are all still 4 steps), then it is retried N times (e.g., N=2), and M increases with the number of retrievals (e.g., M=3 the first time, M=5 the second time) until a sub-solution exceeds the parent solution.

[0062] For example, the parent solution is "4-step elimination", the improvement strategy is "simplified steps", the target mode is single-turn dialogue, and 3 candidate sub-solutions can be generated in parallel: Sub-solution 1: Remove back substitution verification, steps = 3 steps (merge equations → solve x → substitute to find y); Sub-solution 2: Directly calculate the coefficients when merging equations. Steps = 3 steps (merge → solve → substitute). Sub-solution 3: Optimize the calculation order, steps = 4 (unimproved). If sub-solution 1 and sub-solution 2 have 3 steps (exceeding the parent solution's 4 steps) in the first 3 generated sub-solutions, then no retry is needed; if neither exceeds the parent solution's 4 steps (e.g., both still have 4 steps), then retry, increase M to 5, generate more sub-solutions, until a sub-solution exceeds the parent solution.

[0063] Step 304: Determine the actual degree to which each candidate sub-solution satisfies the task requirements, and determine the candidate sub-solution that has a higher degree of satisfaction with the task requirements than the current parent solution as the current solution for processing the problem in the current evolution round.

[0064] This step can be performed by the aforementioned executing entity using a task requirement assessment model (such as a rule engine) to calculate the actual degree to which each candidate sub-solution meets the task requirements (such as "number of steps" and "correctness of result"), and compare it with the degree to which the parent solution meets the requirements.

[0065] Then, the candidate sub-solutions that exceed the parent solution (e.g., sub-solution 1 has 3 steps, which is greater than the parent solution's 4 steps, and the result is correct) are determined as the current solution. For example, if the parent solution satisfies the condition of "4 steps, correct result", candidate sub-solution 1 satisfies the condition of "3 steps, correct result" (exceeding the parent solution), sub-solution 2 satisfies the condition of "3 steps, correct result" (exceeding the parent solution), and sub-solution 3 satisfies the condition of "4 steps, correct result" (not exceeding the parent solution), then either sub-solution 1 or sub-solution 2 (preferably the one with more concise steps) is determined as the current solution.

[0066] This embodiment, through steps 301-304, provides a method for selecting an effective method to inherit history from a parent solution, matching the problem difficulty by determining the target solution generation pattern, exploring innovative directions by generating candidate child solutions, and ensuring evolutionary progress by filtering the current solution. This process avoids redundant exploration while ensuring optimization efficiency.

[0067] To make full use of the memories generated in each round of evolution, please also refer to Figure 5 , Figure 5 A flowchart of a hierarchical memory storage method provided in this disclosure embodiment is included in process 500, which includes the following steps: Step 501: Store the content of each round of dialogue as instantaneous memory; Instantaneous memory is the original content of each round of dialogue, such as "the 4-step elimination method generated in the first round" and "the improvement suggestion in the second round 'remove back substitution verification'" in a math problem. It is used to cache the dialogue information of the current round for a short period of time. The storage period is short (e.g., only the current and previous rounds are retained) and the capacity is limited (e.g., the upper limit of the above information is preset to "5 rounds of dialogue content").

[0068] Step 502: In response to the cumulative storage of transient memory exceeding the preset upper limit of the amount of preceding information, aggregate all currently accumulated transient memories and historical intermediate memories, and generate a semantic summary for the aggregation result as a new intermediate memory; Intermediate memory is an aggregated summary of immediate memory and historical intermediate memory, such as "the process of simplifying the elimination steps from 4 steps to 3 steps in rounds 1-3", which is used for intermediate reuse (such as referring to "the path of step simplification" in subsequent rounds) and has a medium storage period (such as retaining the aggregated results of the most recent 10 rounds).

[0069] Step 503: Transfer intermediate memories that have been retained more than a preset number of times and / or whose importance exceeds a preset level to long-term memories.

[0070] Long-term memory is medium-term memory that is highly important or frequently reused, such as "the best practice for simplifying the elimination process: removing back-substitution verification". It is used for long-term knowledge accumulation (such as as the core content of a domain knowledge base) and has a long storage period (such as permanent retention).

[0071] The three can be linked through metadata tags (such as each memory entry containing "corresponding historical solution ID" and "generation round"), for example, "intermediate memory 'elimination simplification process' corresponds to the first round of historical solution 'elimination 4 steps'", ensuring that the corresponding historical solution can be quickly linked when querying later.

[0072] Taking the evolutionary process of solving the system of equations "x+y=5, 2x-y=1" as an example, its memory management process can be specifically described as follows: The aforementioned executing entity stores the content of each round of dialogue as instantaneous memory. For example, in the first round, "Generate elimination steps: merge equations → solve x → substitute back to find y → verify the result (steps = 4 steps, result is correct)", in the second round, "improvement suggestion: remove the back-substitution verification step and simplify to 3 steps", and in the third round, "Generate simplified elimination steps: merge equations → solve x → substitute to find y (steps = 3 steps, result is correct)".

[0073] When the transient memory accumulates to 3 rounds (exceeding the preset limit of "2 rounds"), these transient memories and historical intermediate memories (such as "round 0: initial elimination steps") are aggregated, and the key information "the elimination steps are simplified from 4 steps to 3 steps, and the improvement is to remove back-substitution verification" is extracted. A semantic summary is generated as a new intermediate memory, and the corresponding historical solution ID (001, 002, 003) is marked.

[0074] If the intermediate memory is referenced multiple times in subsequent rounds (e.g., the “simplified path” is referenced in rounds 4, 5, and 6), the number of times it is retained exceeds the preset “5 times”, and the importance assessment (judged by the machine learning model as “this memory is of great help to subsequent evolution”) exceeds the preset level of “high importance”, then it is transferred to long-term memory, such as “best practice for simplifying steps using elimination: remove back-substitution verification, reduce the steps from 4 to 3 (result is correct)”, and can be directly reused in subsequent rounds (e.g., when generating a solution in round 7, the long-term memory is directly referenced without re-deriving).

[0075] Memory associations can be achieved through metadata tags. For example, the metadata for the ephemeral memory "steps of the first round of elimination" includes "history_solution_id=001". When querying this memory later, the corresponding historical solution (solution 001: elimination in 4 steps) can be quickly found. Semantic summarization relies on natural language summarization techniques (such as the TextRank algorithm) to extract key information from the ephemeral memory (such as "changes in the number of steps", "improvements", and "results") and generate a concise summary (such as "elimination was simplified from 4 steps to 3 steps, and the improvement is the removal of back-supplication verification"). Retention counts are counted through access counters (such as the number of times a certain intermediate memory is queried in subsequent rounds), and importance is evaluated through machine learning models (such as inputting memory content and historical evolution effects, and outputting an "importance score"). For example, if a certain intermediate memory has "access count = 6 times > 5 times" and "importance score = 0.8 > 0.7", it will be transferred to long-term memory.

[0076] This embodiment provides a hierarchical memory management mechanism through steps 501-503. Its core value lies in transforming the original dialogue content into reusable structured knowledge: short-term memory caches short-term dialogues, medium-term memory summarizes medium-term processes, and long-term memory accumulates long-term experience. The hierarchical design achieves efficient storage and retrieval of memory (e.g., rapid caching of short-term memory and rapid reuse of long-term memory); the association between memory and historical solutions ensures the traceability of experience (e.g., when querying "elimination method simplification steps," the corresponding historical solution and evolutionary process can be quickly found). For example, in the case of solving a system of equations, the long-term memory "best practice for elimination method simplification steps" can be directly reused in subsequent rounds, avoiding repeated derivations (e.g., directly using the 3-step elimination method when generating a solution in the 7th round), significantly improving evolutionary efficiency.

[0077] Based on any of the above embodiments, to deepen the understanding of this evolutionary memory bank, the memory evolution bank and the evolutionary memory system in which it resides are also specifically described here: This evolutionary memory bank uses a tree diagram to record all historical solutions. It is a memory storage unit in an evolutionary memory system based on a multi-population island parallel model and a multi-dimensional phenotypic elite archiving algorithm. The multi-population island parallel model has a ring topology, which is formed by splicing ring strips corresponding to the number of islands. Each ring strip is used to store the historical solutions belonging to the corresponding population on the corresponding island. The elite solutions of each population are recorded by a multi-dimensional table provided by the multi-dimensional phenotypic elite archiving algorithm.

[0078] This evolutionary memory bank records all historical solutions in a tree diagram. The root node is the initial solution (e.g., the 4-step elimination solution generated in the first round of a mathematical problem), the child nodes are improved solutions from subsequent rounds (e.g., the 3-step elimination solution in the second round, and the 3-step substitution solution in the third round), and the branches represent different directions of improvement (e.g., "simplifying the elimination steps" or "switching to the substitution method"). This structure clearly traces the evolutionary path of the solution, such as the simplification process from 4 steps to 3 steps. In subsequent rounds, if a solution wants to know "which path is effective," it can quickly locate the corresponding branch.

[0079] This multi-population island parallel model divides the memory into multiple independent islands (such as "elimination population islands" and "substitution population islands"), with each island corresponding to a circular strip that stores the historical solutions of that population. The circular topology connects the islands in a ring, facilitating information exchange between populations. For example, the simplification experience of the elimination population can be passed to the substitution population, and the computation time optimization experience of the substitution population can also be passed to the elimination population. This design achieves both load balancing (each island processes the solutions of one population) and reduces information transmission latency (the circular structure makes information transmission more efficient).

[0080] The multi-dimensional phenotypic elite archiving algorithm is used to preserve excellent historical solutions. "Elite solutions" are those that perform well, such as "≤3 steps, correct result, short computation time." "Multi-dimensional phenotyping" evaluates the performance of a solution from multiple dimensions, including the number of steps, computation time, result accuracy, and method generality. "Archiving" stores these elite solutions in a multi-dimensional table. For example, an elite solution for elimination might be "3 steps, 2 seconds computation time, correct result," while an elite solution for substitution might be "3 steps, 1.5 seconds computation time, correct result." This approach preserves diverse excellent solutions, avoiding optimization of only one dimension (e.g., pursuing only step simplicity while ignoring computation time). Subsequent evolution can select appropriate elite solutions based on task requirements; for example, to shorten computation time, the elite solution for substitution can be chosen; to simplify steps, the elite solution for elimination can be selected.

[0081] Taking the solution of the system of equations "x+y=5, 2x-y=1" as an example, the root node of the tree diagram is the 4-step solution of the first round of elimination, and the child nodes are the 3-step solution of the second round of elimination (branched as "simplification steps") and the 3-step solution of the third round of substitution (branched as "method switching"). In the multi-population islands, the historical solutions of the elimination population exist in circular strip 1, and the substitution population exists in circular strip 2. Every two rounds, the two islands migrate elite solutions to each other. The 3-step solution of elimination is passed to the substitution population, and the 3-step solution of substitution is passed to the elimination population. The multi-dimensional table retains the elite solutions of these two populations. During subsequent evolution, the aforementioned execution entities can select the elite solution of substitution as the parent solution according to task requirements (such as "prioritizing shortening computation time"), or select the elite solution of elimination according to "prioritizing simplification steps", ensuring the diversity of solutions.

[0082] To facilitate information exchange in the circular topology, the aforementioned implementing entities can periodically execute population migration strategies. For example, every two rounds, 10% of the elite solutions from one island can be migrated to an adjacent island. This allows each population to learn from the best practices of other populations, avoiding "reinventing the wheel." The selection of dimensions for the multi-dimensional table depends on the task requirements. For instance, in mathematical problems, "result accuracy" is the core dimension, while "number of steps" and "computation time" are optimization dimensions. The implementing entities can determine the weights of these dimensions using feature selection algorithms (such as mutual information) to ensure that the elite solutions recorded in the multi-dimensional table align with the core objectives of the task.

[0083] The evolutionary memory system and evolutionary memory bank design provided in this embodiment achieve "structured, parallel, and diversified" storage of historical solutions. Specifically, the tree diagram makes evolutionary paths traceable, the circular topology allows for the exchange of experience, and the multi-dimensional elite archive ensures the diverse retention of excellent solutions. These designs collectively support the formulation of improvement strategies for subsequent evolutionary rounds, such as referencing effective paths in the tree diagram, reusing exchanged experiences between populations, and selecting multi-dimensional elite solutions as parent solutions, thereby improving evolutionary efficiency and avoiding repeated exploration of ineffective paths. For example, in solving a system of equations, the tree diagram can find effective paths to simplify steps using elimination, the circular topology can obtain computational time optimization experience for the substitution method, and the multi-dimensional table can select elite solutions with "simple steps and short computation time" as parent solutions, ultimately generating the target solution that meets the task requirements.

[0084] Based on the above embodiments describing the specifics of evolutionary memory banks and evolutionary memory systems, please also refer to... Figure 6 , Figure 6 A flowchart of a method for determining the current parent solution based on an improvement strategy, provided in this embodiment of the disclosure, includes the following steps in process 600: Step 601: Determine the selection weights of each annular strip constituting the link topology based on the improvement strategy; The purpose of this step is to determine the selection weights of each ring strip in the segmented topology based on the improved strategy. The calculation of the selection weights can be determined by several key factors. For example, the magnitude of the selection weight is directly proportional to the probability that a historical solution in the population is used as a historical parent solution to produce an effective solution, and the magnitude of the selected effective solution is directly proportional to the degree to which the produced effective solution meets the task requirements compared to the corresponding historical parent solution. The magnitude of the selection weights can also be directly proportional to the magnitude of the population entropy, and the magnitude of the population entropy is directly proportional to the degree of diversity of historical solutions in the population.

[0085] These key factors correspond to different evolutionary needs: First, the probability of an effective solution refers to the probability that a historical solution in a circular strip will generate an effective solution as a parent solution (for example, in an elimination strip, if 80% of the historical solutions are parent solutions, the subsequent generated child solutions will meet the task requirements). This factor ensures the reliability of experience, and selecting strips with successful records makes it more likely to generate effective solutions. Second, the degree of satisfaction refers to the improvement of the effective solution in terms of task requirements compared to the parent solution (for example, if the parent solution has 4 steps and the effective solution has 3 steps, the step simplification rate is 25%). This factor ensures the significance of evolution, and selecting strips that can bring significant improvements avoids wasting resources on "minor improvements". Third, the population entropy refers to the diversity of historical solutions within the circular strip (the greater the entropy, the richer the types, methods, and characteristics of solutions, for example, in an elimination strip, there are different variations such as "removal of back-substitution verification" and "merging equations for optimization"). This factor ensures the diversity of evolution, and selecting strips with high diversity avoids getting trapped in "local optima" (for example, if the elimination method is used continuously, a better solution than the substitution method cannot be found).

[0086] These three factors are weighted (e.g., 40% for the probability of an effective solution, 30% for the increase in satisfaction, and 30% for the population entropy) to form the selection weight. The larger the weight, the higher the evolutionary potential of the strip (it is effective, can improve, and can maintain diversity).

[0087] Step 602: Determine the segment with the highest selection weight as the target selection segment; Step 603: Select the current parent solution from the historical solutions stored in the target selection strip.

[0088] The two steps described above involve the executing entity first determining the segment with the highest selection weight as the target selection segment, and then selecting the current parent solution from the target selection segment. For example, the elite solutions stored in the target selection segment can be determined as the current parent solution to increase the probability that the current parent solution will produce a better solution.

[0089] Taking the solution of the system of equations "x+y=5, 2x-y=1" as an example, assume there are two circular strips in the evolutionary memory: strip A (elimination population) stores historical solutions using the elimination method, and strip B (substitution population) stores historical solutions using the substitution method. When calculating the selection weights of the two strips, the probability of an effective solution in strip A is 80% (8 out of 10 historical solutions generate effective solutions), the satisfaction level increases by 25% (4 steps for the parent solution, 3 steps for the effective solution), and the population entropy is 0.8 (variants such as "removing back-substitution verification" and "merging equations for optimization" exist); the probability of an effective solution in strip B is 60%, the satisfaction level increases by 25%, and the population entropy is 0.9 (variants such as "simplifying variable substitution" and "optimizing the calculation order" exist). If the weighting coefficients are 40% for the probability of an effective solution, 30% for the satisfaction level, and 30% for the population entropy, then the weight of strip A is 0.8×0.4 + 0.25×0.3 + 0.8×0.3 = 0.635, and the weight of strip B is 0.6×0.4 + 0.25×0.3 + 0.9×0.3 = 0.585. The aforementioned execution entity can choose strip A, which has a larger weight, as the target strip, and then select a parent solution from the elite solutions of strip A (such as "3-step elimination method, correct result, 25% step simplification rate"). The elite solution is the solution with the best overall performance in the strip (considering steps, time, and accuracy), and as the parent solution, it is more likely to generate child solutions that surpass the current level (such as "3 steps, 1.5 seconds of calculation time, correct result").

[0090] Furthermore, the aforementioned implementing entities can adjust the weighting coefficients according to task requirements: for example, when the task requirement is "quickly finding an effective solution," the weight of the probability of an effective solution is increased (e.g., increased to 50%), and the weight of population entropy is decreased (e.g., decreased to 20%), prioritizing strips with successful experience; when the task requirement is "breaking through the current limit," the weight of population entropy is increased (e.g., increased to 40%), prioritizing strips with high diversity to avoid evolutionary stagnation. The practical significance of population entropy is that strips with high diversity can provide more directions for improvement (e.g., there are variations such as "removing back-substitution verification" and "merging equations for optimization" in the elimination method strips), and there is a greater possibility of new breakthroughs in subsequent evolution (e.g., "merging equations for optimization + removing back-substitution verification," simplifying the steps from 3 steps to 2 steps). The selection logic for elite solutions is to select the solution with the best overall performance from the multi-dimensional phenotypic elite archive of the target strip (e.g., "3 steps, 2 seconds of computation time, correct result"). Such solutions serve as parent solutions, inheriting the successful experience of the strips and possessing the potential for further improvement.

[0091] The core objective of the solution provided in this embodiment is to select the right source of experience. This involves selecting the most promising strips by choosing weights, and then selecting the best elite solutions as parent solutions. This ensures both the effectiveness of the evolution (based on successful experience) and the diversity (avoiding local optima). In the mathematical problem example, selecting the elite solutions of the elimination strips as parent solutions inherits the successful experience of "step simplification." Furthermore, due to the diversity within the strips, better sub-solutions may be generated subsequently (such as "further optimizing computation time"), laying a solid foundation for the development of improvement strategies in subsequent evolutionary rounds.

[0092] To further understand how evolutionary experience is generated, in addition to any of the above embodiments, please refer to [link to relevant documentation]. Figure 7 , Figure 7 A flowchart of a method for generating evolutionary experience provided in this disclosure embodiment is included in process 700, comprising the following steps: Step 701: Determine the expected improvement based on the improvement strategy, and determine the actual improvement based on the actual degree to which the current solution meets the task requirements; The expected improvement refers to the specific goals set according to the improvement strategy of the current round (such as "simplifying the elimination process from 4 steps to 3 steps" or "reducing the computation time from 2 seconds to 1 second"). It is the "target anchor" of evolution, clarifying "what should be improved" and "to what extent." The actual improvement refers to the actual change of the current solution in terms of task requirements compared to the parent solution (such as the historical solution of the previous round) (such as the parent solution being a 4-step elimination process and the current solution being a 3-step elimination process, the actual improvement is "reducing the number of steps by 1"; the parent solution's computation time is 2 seconds and the current solution's computation time is 1.5 seconds, the actual improvement is "reducing the time by 0.5 seconds").

[0093] Step 702: Determine the degree of matching based on the difference between the actual improvement and the expected improvement; The matching degree refers to the degree of fit between the actual improvement and the expected improvement (e.g., if the expected steps are reduced by 1 step and the actual steps are reduced by 1 step, the matching degree is 100%; if the expected time is shortened by 0.5 seconds and the actual time is shortened by 0.2 seconds, the matching degree is 40%). It reflects the effectiveness of the improvement strategy. A high matching degree indicates that the strategy is effective, while a low matching degree indicates that the strategy needs to be adjusted.

[0094] Step 703: Determine the positive and negative contributions based on the matching degree; Positive contributions refer to the parts of the actual improvement that meet the improvement expectations (such as the expected simplification of steps, but the actual number of steps is reduced, which is a "correct" action); while negative contributions refer to the parts of the actual improvement that do not meet the improvement expectations or bring new problems (such as the expected simplification of steps, but the actual number of steps is reduced, but the computation time increases, and "increased computation time" is a "wrong" action).

[0095] Step 704: Based on the positive and negative contributions, generate improvement suggestions for the current solution to at least maintain the positive contribution and to minimize the negative contribution as much as possible.

[0096] This improvement recommendation refers to specific optimization measures for the generation of positive and negative contributions (e.g., if the positive contribution is "reduced steps", it is recommended to "keep the step of removing back-supplication verification"; if the negative contribution is "increased computation time", it is recommended to "optimize the computation logic of the merging equations"). Its goal is to "keep the positive and mitigate the negative" to ensure that subsequent evolution deepens in the "correct direction".

[0097] Taking the solution of the system of equations "x+y=5, 2x-y=1" as an example, if the improvement strategy for the current round is "to simplify the steps from 4 steps to 3 steps using the elimination method", the parent solution is the 4-step elimination method of the first round (merging equations → solving x → substituting back to find y → verifying the result), and the current solution is the 3-step elimination method of the second round (merging equations → solving x → substituting into the first equation to find y). In step 701, the expected improvement is to reduce the number of steps from 4 to 3, while the actual improvement is to reduce the number of steps by 1 but increase the computation time from 1 second to 1.5 seconds. In step 702, the "step simplicity" dimension has a 100% match (the expectation matches the actual result), while the "computation time" dimension has a 0% match (the implicit expectation of "time reduction" is not achieved). In step 703, the positive contribution is "reducing the number of steps by 1" (from the action of "removing back-substitution verification"), and the negative contribution is "increasing the computation time by 0.5 seconds" (from the action of "adding coefficient verification when merging equations"). In step 704, the improvement suggestions can be "maintain the step design of 'removing back-substitution verification' and continue the direction of step simplification" (for the positive contribution) and "optimize the 'coefficient verification logic' of merging equations and adopt a more efficient calculation method (such as caching coefficient values ​​in advance) to reduce time consumption" (for the negative contribution).

[0098] Furthermore, this matching degree can be calculated using multi-dimensional weighted averages. For example, step simplicity accounts for 60%, and computation time accounts for 40%. If the expected result is "one less step + 0.5 seconds less time," but the actual result is "one less step + 0.2 seconds more time," then the matching degree is (100% × 60%) + (0% × 40%) = 60%, reflecting that the strategy is effective in terms of "steps" but ineffective in terms of "time." Positive and negative contributions can also be incorporated into dimensions such as "result accuracy" and "method generality." For example, if the current solution has fewer steps but the result accuracy drops from 100% to 90%, then "decreased result accuracy" is a negative contribution and needs to be addressed first (because "correctness" is the core of the task requirements). Improvement suggestions can be generated through rule engines (e.g., "if the negative contribution is 'increased computation time,' then 'optimize the computation logic'") or machine learning models (e.g., learning from historical data, recommending "optimizing the coefficient calculation of the merged equations by using vector operations") to ensure accuracy.

[0099] This embodiment provides a specific implementation method for generating evolutionary experience through steps 701 to 704. Essentially, it compares expected improvements with actual improvements, breaks down "effective actions" and "ineffective / negative actions" in the evolutionary process, and generates targeted improvement suggestions, providing a clear direction for strategy adjustments in subsequent evolutionary rounds. This process retains "successful experiences" (positive contributions) while avoiding the repetition of "failure lessons" (negative contributions), and is a key driver of the "spiral upward" evolutionary process.

[0100] Building upon the above embodiments, considering that the solutions generated may sometimes contain unexpected situations or behaviors, in such cases, when the current solution contains unexpected behaviors that exceed improvement expectations, the improvement suggestions can be adjusted based on these unexpected behaviors. This allows the unexpected behaviors to be incorporated into the experience through the adjusted improvement suggestions. This approach is actually a key supplement to "adaptation" and "opportunity capture" in the evolutionary process. Its core logic is: when the current solution exhibits behaviors that are not covered by the improvement strategy or exceed expectations (whether it is a positive "additional improvement" or a negative "new problem"), the aforementioned implementing entity can identify the nature of the unexpected behaviors (whether they are beneficial to the task requirements) and adjust the original improvement suggestions, transforming the "unexpected" into a "new direction for subsequent evolution," ensuring that evolution not only "procesce as planned" but also "copes with change."

[0101] The so-called "unexpected performance" is actually the performance of the current solution that exceeds the expected improvement in terms of task requirements. For example, the expected improvement is to "simplify the elimination process from 4 steps to 3 steps," but the current solution not only simplifies the steps to 3 but also reduces the computation time from 2 seconds to 1 second; the "reduction in computation time" is an unexpected improvement. Or, the current solution simplifies the steps to 3, but the accuracy of the result drops from 100% to 95%; the "decline in accuracy" is also an unexpected improvement. These performances are essentially "side effects" or "additional benefits" that the improvement strategy did not consider, reflecting the "uncertainty" of evolution. Based on the impact on task requirements, unexpected performances are divided into two categories: positive unexpected performances are those that exceed expectations and improve the degree of fulfillment of task requirements (such as reduced computation time, if the task requirements include the dimension of "computational efficiency"); negative unexpected performances are those that exceed expectations and reduce the degree of fulfillment of task requirements (such as decreased result accuracy, if "accuracy" is a core dimension). Adjustments to improvement suggestions must be based on this property: positive unexpected performances should be "preserved and strengthened," while negative unexpected performances should be "corrected or avoided."

[0102] Taking the solution of the system of equations "x+y=5, 2x-y=1" as an example, suppose the improvement strategy is to "simplify the steps from 4 to 3 using elimination," and the expected improvement is "no more than 3 steps, with a correct result" (calculation time not mentioned). The parent solution uses a 4-step elimination method (calculation time 2 seconds, 100% correct result), and the current solution uses a 3-step elimination method (calculation time 1 second, 100% correct result). In this case, "reduced computation time" is a positive surprise (exceeding expectations and improving computational efficiency). The original improvement suggestion was to "keep the step of removing back-substitution verification," but the adjusted suggestion would be to "keep the step of removing back-substitution verification, while optimizing the computational logic of merging equations (such as using vector operations) to further reduce computation time." Another example of a negative surprise: if the current solution is simplified to 3 steps, but the accuracy drops to 95% (the parent solution is 100% correct), and "accuracy" is the core requirement of the task. At this point, the "decline in accuracy" is a negative surprise. The original improvement suggestion was to "keep the step of removing back-substitution verification". After adjustment, it will be revised to: "Keep the direction of simplifying the steps, but restore the 'back-substitution verification' step (only verify whether the result satisfies the original equation system) to improve accuracy."

[0103] Furthermore, considering that unexpected performance often originates from dimensions not covered by the improvement strategy (e.g., focusing only on step simplification without considering computation time) or environmental changes (e.g., a slight change in the coefficients of the equation system leading to a reduction in computation time), for uncertain unexpected events (e.g., reduced computation time but a slight increase in steps), the implementing entity can verify the performance multiple times (e.g., repeatedly generating the solution in subsequent rounds and observing whether the performance is stable) before adjusting the recommendations. If, after multiple verifications, the "reduction in computation time" is stable and the "increase in steps" is acceptable, it is classified as a positive unexpected event, and the recommendations are adjusted to retain this advantage. Furthermore, the long-term impact of unexpected performance is also worth noting: positive unexpected events may change the evolutionary objective (e.g., originally focusing on "step simplification," now adding "reduction in computation time"); negative unexpected events may correct blind spots in the strategy (e.g., originally believing "removing back-generation verification" was safe, now finding it necessary to "retain some verification steps"). For example, if multiple negative unexpected events occur where "step simplification leads to a decrease in accuracy," the implementing entity may adjust the strategy priority, placing "result accuracy" before "step simplification."

[0104] The core idea of ​​the solution provided in this embodiment is to fully leverage uncertainty. In evolution, improving strategies cannot cover all outcomes; unexpected results represent unplanned opportunities or risks. Therefore, by identifying their nature and adjusting suggestions, unexpected events can be transformed into new driving forces for evolution. Positive unexpected events reinforce successful experiences, while negative unexpected events prevent the repetition of mistakes, allowing subsequent evolution to more closely align with the optimal solution required by the task. This adaptive capability further distinguishes the general evolutionary agent from fixed-policy systems.

[0105] Based on the above embodiments, to deepen the understanding of how to summarize different evolutionary experiences generated from different historical solutions at different historical evolutionary stages, this embodiment also provides a specific implementation method: First, identify parent-child historical solutions with parent-child relationships among different historical solutions, and generate a summary of parent-child solution evolutionary experiences based on the differences between the different evolutionary experiences corresponding to the parent-child historical solutions. Then, identify different child historical solutions corresponding to the same parent historical solution among different historical solutions, and generate a summary of parallel child solution evolutionary experiences based on the differences between the evolutionary experiences corresponding to each child historical solution in a parallel relationship. The historical evolutionary experience summary includes: the parent-child solution evolutionary experience summary and the parallel child solution evolutionary experience summary.

[0106] The parent-child relationship refers to the "inheritance" in the evolutionary path (e.g., the "4-step elimination method" in the first round is the parent solution, and the "3-step elimination method" improved upon it in the second round is the child solution). The difference in evolutionary experience between parent and child solutions is essentially the "effectiveness of the improvement strategy." For example, the expected improvement of the parent solution is "simplifying the steps," while the actual improvement of the child solution is "reducing the steps by one and obtaining the correct result." This difference indicates that the action of "removing back-swapping verification" is effective from the parent solution to the child solution.

[0107] Parallel sub-solutions are sub-solutions generated from the same parent solution but with "different improvement directions" (e.g., in round 2, the "3-step elimination method" (removing back-substitution verification) and the "3-step substitution method" (switching methods) generated from the "4-step elimination method"). The differences in the evolutionary experience of parallel sub-solutions reflect the "advantages and disadvantages of different improvement directions." For example, the improvement of sub-solution 1 is "step simplification," while the improvement of sub-solution 2 is "method switching." By comparing the computation time and step coherence of the two, it can be seen which direction is more suitable for the current problem.

[0108] Taking the solution of the system of equations "x+y=5, 2x-y=1" as an example, the process of summarizing the parent and child solutions can be as follows: Comparing the evolutionary experience of the parent solution (4-step elimination method) and the child solution (3-step elimination method), we find that the expected improvement of the parent solution is "simplification of steps," and the actual improvement of the child solution exactly achieves this expectation without reducing the accuracy of the result. Therefore, we conclude that: "In the improvement from 4-step elimination to 3-step elimination, 'removing back-substitution verification' is an effective simplification method that can reduce steps without affecting the result." The process of summarizing the parallel child solutions can be as follows: Comparing the "3-step elimination method" and the "3-step substitution method" generated by the same parent solution, we find that the calculation time of child solution 1 (elimination method) is 1.5 seconds, and the calculation time of child solution 2 (substitution method) is 1 second. Both achieve step simplification, but the substitution method has a shorter calculation time. Therefore, we conclude that: "Switching to the substitution method can shorten the calculation time more than simplifying the elimination method steps, but the simplification of the elimination method steps is more in line with the consistency of the original method."

[0109] The value of these summaries lies in finding patterns among differences: parent-child solution summaries help discover the "effectiveness of evolutionary paths" (e.g., whether the improvement from parent to child solutions is successful), while parallel child solution summaries help discover the "advantages and disadvantages of different improvement directions" (e.g., which method is more suitable for the current problem). For example, the parent-child solution summary's finding that "removing back-substitution verification is effective" can guide the next round of improvement on the substitution method parent solution—trying to remove redundant steps of the substitution method one by one; the parallel child solution summary's finding that "the substitution method is more time-efficient" can guide the next round of selection of "switching methods" as the improvement direction (if the task requires more computational efficiency). In addition, as the number of historical solutions increases (e.g., the "2-step elimination method" in the 3rd round), the experience summaries will be dynamically updated. For example, the newly added "2-step elimination method" (further merging equations) will update the parent-child solution summaries to "'removing back-substitution verification' is an effective way from 4 steps to 3 steps, and 'merging equations for optimization' is an effective way from 3 steps to 2 steps," ensuring that the experience conforms to the latest evolutionary state.

[0110] To enhance understanding, this disclosure also attempts to provide a complete implementation solution, starting from some specific shortcomings of existing technologies: Some projects are currently attempting to explore the design of self-evolving and iterative intelligent agents, but the following problems still exist: 1) High-cost exploration: Large models often involve a large number of random attempts during the generation process, resulting in a large number of invalid generation. The consumption of tokens (the basic unit of content generated by large models) and time costs remain high, and the evolution effect is unstable. 2) Complexity of mode selection: Evolution tasks of different difficulties have significantly different requirements for generation modes. A single generation mode is difficult to balance the rapid implementation of simple tasks with the in-depth breakthrough of complex tasks, which may lead to waste of resources or low generation efficiency. 3) Lack of effective feedback mechanism: Without feedback, the generation process is difficult to continuously optimize and cannot form a positive cycle of "experience accumulation - effect improvement".

[0111] To construct a general-purpose algorithmic evolution agent that is stable, efficient, and has strong generalization ability, this paper proposes a General Evolve Agent. This agent is developed based on a self-developed evolutionary framework (hereinafter referred to as the X framework). It aims to achieve the following goals through expert-guided generation strategies, intelligent generation mode selection, effective weight feedback mechanisms, and cross-iteration shared context design: 1) Reduce generation costs: By providing clear and high-quality expert generation guidance, the scope of random attempts in large models is reduced, thereby improving generation efficiency and quality; 2) Improve generation efficiency: By intelligently switching between different generation modes to adapt to tasks of varying difficulty, the highest quality algorithm code is generated in the shortest time with the fewest number of tokens; 3) Form a feedback loop: Through an effective summary and feedback mechanism, the generation quality of multiple stages is continuously optimized, accelerating the overall evolution process.

[0112] Figure 8-1 The diagram illustrates the structure of the X framework, which adopts a layered and modular architecture. Based on the domain of abstraction and generality, the framework is divided from bottom to top into a Component Layer, a Framework Layer, and an Application Layer. Component Layer: Serving as the foundation of the entire framework, this layer provides general-purpose basic components for agent development. These components employ a strictly modular design, exhibiting low coupling and high cohesion, facilitating flexible expansion and integration. These include: Model (Model Components): Contains LLM (Large Language Model), Embedding (Embedding Model, converting text to vectors), and Formatter (Formatter, unifying input and output formats); Memory (Memory Components): Contains evolve_mem (Evolutionary Memory, storing the evolutionary hierarchy), and grade_mem (Graded Memory, managing the flow of STM / MTM / LTM); Tools (Tool Components): Contains func_tool (Function Tools, such as mathematical calculations and file operations), Agent_tool (Agent Tools, such as calling other agents), and Toolkit (Toolkit, an entry point for integrating various tools); Message (Message Components): Contains message (basic message structure), token (Token management, calculating context length), and msg_hub (Message Hub, routing messages from different modules); Observability (Observability Components): Contains logger (Logger, recording agent behavior), and tracing (Tracer, tracking task execution trajectories).

[0113] Framework layer: For the development of intelligent agents with different working paradigms, it provides development frameworks for the main paradigms of intelligent agents. By pre-setting different paradigm development frameworks in a modular way, it reduces the complexity of developing a single intelligent agent, while facilitating the flexible combination of different paradigms to develop complex intelligent agents that integrate multiple paradigms. These include: Evolve Paradigm: corresponding to EvolveAgent, whose core components include: Planner (generates evolutionary strategies), Executor (generates and verifies solutions), Evaluator (calculates the fitness of solutions), Summary (summarizes experience), Finalizer (determines the termination of evolution), and Database (stores evolutionary data); ReAct Paradigm: corresponding to ReActAgent, whose core components include: Reasoner (generates logic chains), Actor (executes tool calls), Toolkit (provides usable tools), Context (saves interaction history), Observer (monitors action results), and Finalizer (determines task completion); and BaseAgent: the underlying abstraction of all agents, supporting hooks (inserting custom logic) and interrupts (handling exceptional situations).

[0114] Application Layer: Based on the fundamental capabilities provided by the component and framework layers, this layer develops high-quality, ready-to-use intelligent agents for typical, challenging evolutionary tasks, while simultaneously validating the effectiveness of the framework and components. Specifically: General Evolutionary Intelligent Agent: For general tasks, this layer provides a CLI (command-line interface), a visual interface, and three core modules: evolve-planner, evolve-executor, and evolve-summary.

[0115] At the component layer, a series of atomic components are provided to support the basic capabilities required for agent development. These components can be flexibly integrated and used while supporting the construction of the X framework. Common components for agent development, such as Model, Memory, Tools, Message, and Observability, are provided to meet core requirements in the process of building evolutionary agents, including large model invocation and parsing, context memory management, tool implementation and pre-configuration, unified message format, and observability. In other words, the X framework, through its highly layered and modular architecture, allows for flexible selection of building blocks, like Lego bricks, to build high-quality evolutionary agents for various problem scenarios. It provides comprehensive coverage, from high-quality atomic components to innovative paradigm agent development frameworks for effect verification, and agents for highly complex task scenarios, flexibly meeting the needs of developers at all levels.

[0116] The design philosophy of this general evolutionary agent is based on the core evolutionary principle that prioritizes effectiveness and efficiency. Effectiveness means the agent can autonomously and continuously evolve, ultimately achieving breakthroughs that surpass or approach those of human experts. Efficiency means achieving relatively consistent evolutionary results with as few iterations as possible. The core workflow of this general evolutionary agent is as follows: it maintains historical trial experiences using genetic islands or variant structures such as trees / graphs, and iterates through multiple rounds of historical sampling, generation, and evaluation to select the optimal performance solution.

[0117] To achieve efficient evolutionary breakthroughs, the core lies in: 1) utilizing historical experience: scientifically managing historical attempts, making full use of historical experience, guiding evolutionary efficiency, and avoiding getting trapped in local optima; 2) generating evolutionary efficiency: improving the quality of each iteration, reducing ineffective trial and error, increasing evolutionary certainty, and stably generating breakthrough optimizations.

[0118] To improve evolutionary efficiency, the X framework, referencing the exploratory research model of human researchers—designing, experimenting, summarizing, and iterating multiple times—proposes a three-stage generative architecture, abstracting a single round of evolutionary generation into three stages: "planning-execution-summarization." 1. Planning: Responsible for fully understanding the task and the global evolutionary state, combining sampling and relevant historical evolutionary experience, generating improvement guidance for the current iteration, and providing expert-level guidance for the current iteration; 2. Execution: Responsible for implementing the generation of new solutions, evaluating solutions, debugging errors, and performing targeted and sufficient linear optimization to produce the optimal solution guided by the planning scheme; 3. Summary: Responsible for conducting a comprehensive analysis of newly generated solutions, summarizing successful and unsuccessful experiences, providing guidance for the next evolution, and publishing the evolution information of this round to the evolution memory.

[0119] Through planning, without relying on evaluation calculations, we fully draw on the experience of previous iterations to produce lightweight improvement guidance for this iteration, reducing invalid and low-quality generation evaluation trial and error; through execution, we accurately implement the clear improvement plan and optimize it to the best performance, reducing errors and improving the generation quality of each iteration; through summarization, we conduct a comprehensive summary and analysis of the new solution and release it to the evolutionary memory to efficiently guide subsequent iterations.

[0120] Regarding the utilization of historical experience, the X framework designs a multi-structure fusion evolutionary memory component: combining genetic islands with MAP-Elites (Multi-dimensional Archive of Phenotypes, an optimization algorithm based on evolutionary computation whose core goal is to explore the search space and generate a set of high-performance, diverse solutions) elite archives to manage high-quality solutions, and achieving efficient exploration through dynamic weighted sampling; at the same time, it introduces phylogenetic trees to maintain a complete evolutionary trajectory, supporting the reuse of experience based on evolutionary chains and cross-branch fusion optimization, improving search efficiency while maintaining population diversity and avoiding premature convergence.

[0121] In global evolutionary memory management, the X framework combines memory components in multiple modes to ensure global diversity while fully leveraging the tracing flexibility of the tree structure. This allows for the full absorption of historical experience, resulting in higher evolutionary efficiency, while avoiding getting trapped in local optima. In addition to global evolutionary memory, memory components also need to manage the context in multi-round inference during a single round of evolution. Therefore, a compression-based hierarchical memory component was designed and developed to address the problem of excessively long contexts in multi-round inference by performing hierarchical compression of the context.

[0122] See Figure 8-2 The core generation phase is abstracted into five major components: Planner, Executor, Summary, Evaluator, and Database (evolutionary memory). Planner, Executor, and Summary correspond to the three stages of "planning-execution-summarizing" mentioned above. Their implementation can be a defined function or a sub-Agent, allowing for flexible selection based on the specific scenario. The Evaluator is responsible for uniformly encapsulating evaluation capabilities, invoked by the Executor to evaluate newly generated solutions. It can adapt to different task evaluations through custom evaluation functions and can also be flexibly extended through custom Evaluators. The Database provides an abstraction for evolutionary memory components, making them pluggable and allowing for flexible customization to adapt to different domain evolutionary tasks. It uses the X framework's pre-built evolutionary memory components by default.

[0123] In each evolutionary sub-iteration, the Planner generates an improvement guideline for the current iteration; the Executor generates a new solution based on the Planner's improvement guideline and evaluates the new solution; the Summary performs in-depth analysis and summarization of the new solution generated by the Executor and stores the new solution in the evolutionary memory using the Database. This evolutionary loop drives multiple rounds of iterative optimization, continuously accumulating historical experience in the evolutionary memory. Through sampling and evolutionary link analysis, it guides the evolutionary search direction, ultimately leading to breakthrough improvements. Considering the time-consuming generation and evaluation process, the framework also supports parallel generation to accelerate the evolutionary process.

[0124] The workflow is as follows: Figure 8-3 As shown, Planner, Executor, and Summary are explained in detail: 1. Planner For most tasks, there can be many possible solutions. However, if the task evaluation criteria are strictly limited, such as exploring boundary values, some algorithms, due to their inherent limitations, will be unable to find the optimal solution no matter how many times they try. Therefore, in the evolutionary process, it is necessary to generate high-quality expert guidance strategies in advance. This helps LLM shorten the range of random attempts and complete the evolutionary process in a more efficient way. The question then becomes: how can we generate high-quality expert guidance strategies? By stimulating curiosity-driven exploration, LLM can pre-generate N solution outlines based on the task objective, explore and predict the task evolution effect of different solutions, use comparative analysis to select the candidate solution with the best effect, and finally fill in the details. This mechanism not only stimulates the diversity of the candidate set in the evolutionary scenario and eliminates a batch of invalid solutions through comparative filtering, but also provides problem-solving ideas for the Executor stage, reduces the reasoning complexity of the Executor itself, and improves the stability and quality rate of the overall evolutionary process.

[0125] In terms of implementation, the architecture integrates workflow and ReactAgent, solidifying deterministic processes into a workflow. ReactAgent is only used for direct text generation in the content generation stage of the Plan, ensuring the success rate and quality of each generation of expert-guided generation strategies. 1) Sampling Parent Reference Programs: The problem of high evolutionary randomness stems from insufficient contextual information in large models. This leads to numerous ineffective or unguided attempts at generation, resulting in highly randomized generation results, uncontrollable evolutionary effects, and ultimately, low evolutionary efficiency. Therefore, to alleviate the lack of contextual information, a validated parent program is sampled from the database. This parent program guides ReactAgent to analyze and generate a higher-quality offspring program based on this parent program. The parent program serves as the baseline for this iterative evolution, ensuring continuous improvement in evolutionary performance.

[0126] 2) Generating High-Quality Expert-Guided Generation Strategies: A high-quality generation strategy is born from continuous optimization based on historical experience feedback. This process itself involves multiple cycles of thinking, design, and observation. Given this characteristic, building a ReactAgent is undoubtedly an excellent choice. The evolutionary process can be viewed as a continuously growing tree, with each iteration's child program being a branch node on this tree. These represent valuable historical exploration experiences. The ReactAgent prioritizes acquiring a global perspective on the evolutionary process, observing and reflecting on the performance evaluations of other sibling programs, and then conducting critical comparative analysis. Ultimately, it generates a new, more effective child program generation strategy, bringing a completely new possibility to child evolution and solving the problem of low evolutionary efficiency caused by repeated generation.

[0127] 3) Saved as files. To improve the stability and quality rate of LLM generation, maintaining high-quality context content is a recognized effective method in the industry. Therefore, expert-guided generation strategies will be saved locally and passed on to other users in the form of filenames. Other users can view and read them when necessary, reducing generation instability caused by context pollution.

[0128] 2. Executor

[0129] Based on the expert-guided generation strategy generated by Planner and the parent reference program, the Executor only needs excellent instruction compliance and bug-fixing capabilities. The key is choosing the most suitable generation method for the child program. Specifically, it supports various generation modes such as single-turn dialogue (Chat mode) and multi-turn dialogue (React mode). The Executor can dynamically adopt the most cost-effective and efficient mode to generate the child program based on task information and the parent program. This mechanism saves computational costs in the overall evolution process and shortens the evolution time of a single iteration, improving evolution efficiency. Another key point is that because the generated content of LLM has randomness, it cannot be guaranteed that the child program will be better than the parent program in just one generation. By generating multiple times and selecting the best result, the probability of generating the optimal solution in a single iteration is increased, achieving continuous improvement in evolution performance.

[0130] In terms of implementation, the architecture employs an N×M layered design to progressively increase the number of parallel child programs generated, finding the optimal child program with as few generation attempts as possible. It compares the evaluation score of the parent program with the generation mode switching threshold, using either Chat or React mode to generate the child program, ensuring the total computational and time costs of child program generation are minimized. 1) Step-by-step concurrent generation. To ensure continuous evolution and reduce the likelihood of unexpected results due to randomness, the Agent is given N rounds of retrying. To shorten the total generation time, M child programs are generated concurrently in each round. The best-performing child program is then selected from these N×M programs. Once a child program outperforms its parent program is generated, the retry loop automatically terminates, and the best program is immediately returned, thus increasing the evolution speed. M increases in a step-by-step manner with the number of retries, which fully utilizes generation randomness while also representing a cost-effective compromise.

[0131] 2) Intelligent Generation Mode Switching. For different parent programs, the system intelligently selects the most cost-effective child program generation mode. For example, simple tasks can be completed using the simplest Chat mode with a single-turn dialogue, while complex tasks require multi-turn dialogue using the React model. Furthermore, in the scenario of mathematical algorithm evolution, if only a valid solution is found, the Chat mode is sufficient; however, if a limit needs to be exceeded, the React mode is usually required. To find this optimal balance, the sampled parent program evaluation score is used as the judgment standard. If it exceeds the system threshold, the React mode is used to generate the child program; otherwise, the Chat mode is used. Users can adjust the threshold according to the task difficulty.

[0132] 3. Summary

[0133] Since the expert-guided generation strategy produced in the Planner phase is a pure prediction without verification, in order to continuously improve the generation quality of the Plan in subsequent iterations, the Summary generates a key summary with evolutionary direction based on task information. This summary supplements the Planner phase with effective feedback, constructing an effective self-evolutionary closed loop of design-execution-feedback. Meanwhile, new child programs will become parent programs in subsequent iterations. How then to select the optimal parent program in subsequent iterations? Through an effective sampling weight allocation mechanism, child programs are analyzed from multiple perspectives, and reasonable sampling weights are set for them. This allows high-quality child programs to receive a greater probability of being sampled, driving continuous improvement in evolutionary performance.

[0134] In terms of implementation, the architecture remains a hybrid design of workflow and ReactAgent: 1) Generating Iterative Summaries: The slow evolution speed is fundamentally due to insufficient contextual information in large models. This results in a lack of ability for large models to quickly correct errors in the absence of feedback, causing them to repeat the same path twice and ultimately find the optimal solution only through multiple retries. Therefore, to avoid repetitive and ineffective iterations, the Summary analyzes the iterative paths of other sibling programs generated by the same parent program based on a global database perspective. It generates a final summary of the optimal child program generated in this iteration and provides guidance on strategies for generating this child program as the grandchild of the parent program. This enables cross-iteration sharing of contextual information, allowing the Planner in the next iteration to be aware of the generation feedback from the historical Plan and optimize its own generation performance.

[0135] 2) Sampling Weight Setting: In evolutionary scenarios, the simplest sampling method is to sort the programs by evaluation score from highest to lowest and select a few from the Top N as parent programs. However, this strategy has a drawback: if it gets stuck in a local optimum, the Top N programs become homogeneous algorithms, severely hindering the potential breakthrough of offspring programs. Furthermore, a high score does not necessarily indicate a high probability of generating the optimal solution; some programs with low scores may have good algorithms but suffer from poor parameter configurations, yet these programs still offer valuable guidance for evolution. Therefore, this paper proposes adding sampling weights, considering them in addition to the evaluation score sampling. The sampling weights are calculated using the following formula: child_weight=parent_weight+(α score_diff step_size)+β complete_ratio; Where α is the scaling factor; score_diff is the difference in evaluation scores between the offspring program and the parent program; step_size is the amplitude of the score difference fluctuation; β is the scaling factor 2; and complete_ratio is the proportion of evolutionary task completion. This formula ensures that offspring programs with higher evaluation scores than their parents receive higher sampling weights, thereby increasing the sampling probability of high-quality offspring programs; conversely, it reduces the sampling probability of low-quality offspring programs.

[0136] In agent frameworks designed for evolution in general algorithmic tasks, the memory module not only needs to process massive amounts of interaction data but also needs to maintain long-term coherence under the constraints of a limited LLM context window. Traditional single-memory storage schemes struggle to simultaneously meet the high-fidelity requirements of short-term interactions and the persistence requirements of long-term knowledge.

[0137] To address this, the X framework also proposes a hierarchical memory architecture based on protocol abstraction. The core design of this architecture lies in completely decoupling the logical control, state detection, and information compression of memory from the underlying storage modules. By defining standardized interface specifications, it achieves high system scalability and service pluggability.

[0138] The overall system architecture is as follows: Figure 8-4 As shown, from top to bottom, it is divided into control layer, memory layer, and protocol layer: Control Layer: The core is the GradeMemory controller, which is the central hub of the entire memory system. The controller is responsible for coordinating data read / write requests, executing hierarchical strategies, and triggering memory consolidation processes. To precisely manage context windows, the control plane uses a separate Token counter service to monitor token consumption at each level of memory in real time and make decisions to ensure that the Agent always operates within a safe context.

[0139] Memory layer: Information is managed in layers based on its timeliness, fidelity, and persistence requirements. Immediate Short-Term Memory: Stores the most recent original conversation content, emphasizing high fidelity and real-time performance; Mid-term contextual memory: Stores compressed contextual summaries, acting as a bridge linking short-term memory interactions and long-term knowledge, balancing contextual integrity with token consumption; Long-term semantic memory: mainly realizes persistent knowledge management, stores factual information across sessions, and usually connects to a vector database with semantic retrieval capabilities.

[0140] Protocol Layer: Implements storage media-independent data storage capabilities and customizable information compression capabilities, including: 1) Unified Storage Interface: Standardized data operation and search capabilities. Any implementation conforming to the specification, such as memory-based In-Memory Storage, file-based data storage, or a semantic retrieval engine based on a vector database, can be injected into different memory layers at runtime; 2) Compression Abstraction Strategy: Abstracts memory compression algorithms through the Compressor interface (a functional interface for calling data compression algorithms), allowing developers to flexibly connect different compression strategies, such as simple truncation strategies or LLM-based generative compression.

[0141] Based on the above architecture, an automated memory transfer mechanism was also implemented; please refer to [link / reference]. Figure 8-5 When a new message arrives, the controller first requests the token counter to calculate the current total number of tokens. Once the accumulated context length exceeds a preset threshold, the system automatically triggers a memory compression and integration process: first, it aggregates the original messages in the medium and short-term memories, extracts them into a semantic digest using a custom compressor, then clears the current medium and short-term memories, and saves the digest to the medium-term memory. This mechanism ensures that the Agent can continue to operate efficiently within a limited token budget.

[0142] Furthermore, in the intelligent agent framework for general algorithmic task evolution, traditional dialogue memory storage schemes maintain historical information about a single topic through short-term, medium-term, and long-term memory, enabling users to maintain their persona while engaging in continuous dialogue. In evolutionary scenarios, however, evolutionary memory is an intelligent state management mechanism specifically designed for evolutionary algorithms, responsible for recording, managing, and reusing optimal solutions throughout the evolutionary process. Unlike traditional memory management, evolutionary memory not only focuses on data storage but also on the iterative evolution history of solutions, performance evaluation, and multi-dimensional feature analysis.

[0143] Furthermore, in the evolution of AI agents, the effective management and utilization of historical experience is a key factor determining evolutionary efficiency. The main challenges faced by traditional evolutionary algorithms include: 1) Premature convergence and the trap of local optima: A single population structure is prone to convergence to a local optimum within a finite number of iterations due to overexploitation. While elite preservation strategies protect high-quality solutions, they also accelerate population homogenization and suppress key innovative mutations. 2) Difficulty in reusing valuable historical experience: Successful experiences and lessons learned during the evolutionary process are difficult to systematically preserve and reuse, leading to high repetition in population evolution, suppressing the possibility of innovative breakthroughs, and wasting computational resources. 3) The dynamic balance problem of exploration-exploitation: The system struggles to dynamically adjust the search pressure based on the population state at different stages of the search. Overemphasizing fitness can lead to population aggregation, while overemphasizing diversity may reduce search efficiency and waste computational resources.

[0144] To address these issues, this embodiment also proposes an innovative "Evolutionary Memory System," which deeply integrates a multi-island parallel model, the MAP-Elites elite archiving algorithm, and an adaptive Boltzmann selection mechanism within the X framework. By structuring historical experience into a self-organizing memory network, this architecture effectively solves the problems of premature convergence and knowledge forgetting in populations.

[0145] This evolutionary memory system employs a hierarchical modular design (see below). Figure 8-6 This system aims to achieve highly cohesive and loosely coupled memory management. It consists of an application layer, a core implementation layer, and a data storage layer. The core implementation layer supports the continuous evolution of the agent through four sub-modules: the "MAP-Elites Manager," the "Multi-Island Manager," the "Boltzmann Selector," and the "Feature Calculation Module." The core components are described in detail below: 1. Multi-island adaptive parallel mechanism This evolutionary memory system employs a multi-island parallel architecture, dividing the total population into N independent subpopulations (islands). The islands are connected by a ring topology, effectively preventing premature homogenization by limiting the frequency and scale of migrations. Each island maintains an independent optimal solution and feature map to achieve fine-grained state management. This approach offers two advantages: enhanced parallelism: different islands can simultaneously search different regions of the solution space, significantly improving search breadth; and improved robustness: performance degradation or local optima traps on a single island do not rapidly spread to the entire system.

[0146] In addition, intelligent migration strategies between multiple islands enable the integration and synergy of different population algorithms, stimulating continuous evolutionary innovation. The migration mechanism is no longer based on fixed time intervals, but rather adaptively triggered based on the state differences between islands (such as capacity differences and diversity differences). The migration process follows the logic below (see below). Figure 8-7 ): 1) Source selection: Select the top 20% of elite solutions in terms of fitness from the source islands; 2) Deduplication detection: Perform content hash matching on the target island to prevent invalid migration of duplicate solutions; 3) Topology: A ring topology is used to promote the unidirectional flow of genes between different islands and maximize differentiated development.

[0147] 2. Deep integration of MAP-Elites

[0148] This system uses MAP-Elites as the core component for diversity maintenance. The system maps each solution to a multi-dimensional feature space, with typical feature dimensions F including: f1: Complexity, based on the length of the solution or the depth of the structure; f2: Diversity, based on a measure of difference from the reference set; f3: Score, based on the fitness of the objective function; For any solution x, its coordinates C(x) in the feature grid are determined by the following equation: C(x) = bin(f1(x)),bin(f2(x)),…,bin(fn(x)) The bin() function dynamically adjusts the boundaries based on the statistical distribution of eigenvalues. Each grid cell (i,j,k) retains only the solution with the highest fitness at that location, ensuring that each region in the feature space is occupied by the optimal individual.

[0149] 3. Adaptive Boltzmann Selection Based on Diversity

[0150] To achieve a balance between "exploration" and "expitation," the system incorporates an adaptive temperature control Boltzmann selection mechanism.

[0151] The specific process steps can be as follows: 1) Input population state: Receive the current population state S (e.g., population size, feature distribution, fitness score); 2) Calculate population diversity: Calculate population entropy H(P) (an indicator of population diversity; the larger H(P), the higher the diversity); 3) Determine the diversity threshold: If H(P) is higher than the threshold (e.g., H(P)>0.8), it indicates high population diversity. Lower the temperature τ (e.g., τ=0.1) to encourage utilization (greedy selection, prioritizing individuals with high scores); If H(P) is lower than the threshold (e.g., H(P)<0.5), it indicates population convergence. Increase the temperature τ (e.g., τ=1.0) to promote exploration (random selection, prioritizing novel individuals); 4) Calculate Boltzmann probability: For each individual i, calculate its probability of being selected P(i) (based on temperature τ and fitness score); 5) Normalization and sampling: Normalize the probability (ensuring the sum is 1), and use Roulette Wheel Selection to select the parent individual (e.g., selecting the individual with the highest probability as the parent).

[0152] In hybrid evolutionary memory systems, a key failure mode for evolutionary agents is premature convergence, where the population gets trapped in a single local optimum, thus hindering innovation. The X framework addresses this issue through a multi-layered memory architecture: 1. Multi-island distributed topology Single-population models are prone to generating "advantages," where a successful strategy outperforms all others, thus eliminating genetic diversity. The X framework employs a multi-island model with a ring topology. The population is divided into N isolated islands. Each island evolves independently, allowing for the development of different algorithmic "species." Migration occurs only when the diversity difference ΔD between adjacent islands exceeds a threshold. The top k% of elite individuals are replicated to adjacent islands as "invasive species" to break stagnation. This spatial isolation ensures the maintenance of global diversity. It enables the system to explore multiple disjoint attraction basins simultaneously, preventing the system from getting trapped in a single local optimum.

[0153] 2. MAP-Elites with Featured Mesh

[0154] Objective-based selection (ranking solely by score) often overlooks novel but insufficiently refined solutions ("stepping stones") that are essential for reaching the global optimum. Within each island, the X framework utilizes a MAP-Elites (phenotypic multidimensional archive) container. Solutions are mapped to a feature grid A based on behavioral descriptors Φ(s) (e.g., code complexity × memory usage). The system preserves the best individual for each cell in the grid, not just the global optimum. This guarantees niche preservation. A "slow but highly concise" solution is not superseded by a "fast but verbose" one. This provides the planner with a diverse "gene pool" for cross-pollination.

[0155] 3. Adaptive Boltzmann Selection

[0156] The balance between exploration and exploitation is dynamic. Fixed hyperparameters (such as a fixed mutation rate) inevitably lead to inefficiencies at different stages of evolution. The X framework implements entropy-regularized Boltzmann selection. The selection temperature τ is dynamically adjusted based on the population entropy H(P). τ(t) ∝ exp(-λ·H(Pt)). When the population has diversity (high H), the value of τ decreases to encourage exploitation (greedy). When the population converges (low H), the value of τ increases to promote exploration (stochastic). This achieves adaptive control. The system automatically switches between "finding new ideas" and "refining existing ideas" without human intervention.

[0157] Further reference Figure 9 As an implementation of the methods shown in the above figures, this disclosure provides an embodiment of a problem-solving device based on an evolutionary intelligent agent. This device embodiment is similar to... Figure 2 Corresponding to the method embodiments shown, this device can be specifically applied to various electronic devices.

[0158] like Figure 9As shown, the problem-solving device 500 based on evolutionary agents in this embodiment may include: an evolutionary solving unit 901 and a repetition execution unit 902. The evolutionary solving unit 901 is configured to determine the task requirements and the current evolutionary round of the problem to be processed, and to execute the following evolutionary solving steps: based on the task requirements and a summary of historical evolutionary experience, determine an improvement strategy for the current evolutionary round compared to the previous evolutionary round; the summary of historical evolutionary experience is obtained by summarizing different evolutionary experiences generated from different historical solutions in different historical evolutionary rounds; generate a current solution for processing the problem to be processed based on the improvement strategy; in response to the current solution not meeting the task requirements, generate evolutionary experience with evolutionary direction corresponding to the current evolutionary round based on the improvement strategy and the actual degree to which the current solution meets the task requirements; update the summary of historical evolutionary experience using the evolutionary experience of the current evolutionary round; the repetition execution unit 902 is configured to take the next evolutionary round as the new current evolutionary round and repeatedly execute the evolutionary solving steps until a target solution that meets the task requirements is obtained.

[0159] In this embodiment, the specific processing of the evolutionary solving unit 901 and the repeated execution unit 902 in the problem processing device 900 based on evolutionary intelligent agents, and the resulting technical effects, can be found by referring to [reference needed]. Figure 2 The relevant descriptions of steps 201-203 in the corresponding embodiments will not be repeated here.

[0160] In some other alternative implementations of this example, the evolutionary solving unit 901 includes a current solution generating subunit configured to generate a current solution for processing the problem based on an improvement strategy. The current solution generating subunit includes: The current parent solution selection module is configured to select the current parent solution from the memory evolution library that stores all historical solutions based on an improved strategy; The target solution generation mode determination module is configured to determine the target solution generation mode based on the current parent solution and task requirements; The multi-candidate sub-solution generation module is configured to generate multiple candidate sub-solutions based on the current parent solution, according to the target solution generation mode and improvement strategy; The current solution determination module is configured to determine the actual degree to which each candidate sub-solution meets the task requirements, and to determine the candidate sub-solution that has a higher degree of meeting the task requirements than the current parent solution as the current solution for processing the problem in the current evolution round.

[0161] In some other alternative implementations of this example, the target solution generation mode determination module includes: The first information determination submodule is configured to determine the first information based on the actual degree to which the current parent solution meets the task requirements. The second information determination submodule is configured to determine the second information based on the problem to be processed, the problem type, and the difficulty of the task requirements. The solution generation cost determination submodule is configured to determine the solution generation cost based on the first information and the second information. The target solution generation module determines the submodule, which is configured to determine the solution generation mode corresponding to the solution generation cost as the target solution generation mode.

[0162] In some other alternative implementations of this example, the target solution generation module determination submodule is further configured to: In response to a solution generation cost being less than a preset generation cost threshold, single-turn dialogue is determined as the target solution generation mode; where single-turn dialogue refers to generating a solution through a single interaction. In response to the solution generation cost being no less than a preset generation cost threshold, multi-turn dialogue is determined as the target solution generation mode; where multi-turn dialogue refers to generating a solution through at least two interactions or at least two execution steps.

[0163] In some other alternative implementations of this example, the solution generation cost determination submodule is further configured to: In response to the first information being that the actual degree of satisfaction of the task requirements by the current parent solution is lower than the preset satisfaction threshold, and the second information containing the problem type being mathematical algorithm evolution and the difficulty level being finding an effective solution, the value less than the preset generation cost threshold is determined as the solution generation cost. In response to the first information that the current parent solution actually satisfies the task requirements less than a preset satisfaction threshold, and the second information that the problem type is mathematical algorithm evolution and the difficulty level is breaking through the target limit, a value not less than a preset generation cost threshold is determined as the solution generation cost.

[0164] In some other alternative implementations of this example, the multiple candidate sub-solution generation module is further configured as follows: Based on the current parent solution, M candidate sub-solutions are generated in the dialogue provided by the target solution generation mode according to the improvement strategy. The method of generating M candidate sub-solutions will be retried up to N times if the actual satisfaction level of any candidate sub-solution does not exceed the actual satisfaction level of the current parent solution, and the size of M increases with the increase of the actual number of retries.

[0165] In some other alternative implementations of this example, the problem-solving apparatus 900 based on evolutionary agents may further include: The instantaneous memory storage unit is configured to store the content of each round of dialogue as instantaneous memory; The intermediate memory update unit is configured to aggregate all currently accumulated intermediate memories and historical intermediate memories in response to the cumulative storage of transient memories exceeding the preset upper limit of the amount of preceding information, and generate a semantic summary for the aggregation result as a new intermediate memory. The long-term memory transfer unit is configured to transfer intermediate memories that have been retained more than a preset number of times and / or whose importance exceeds a preset level into long-term memories; wherein, the instantaneous memory, intermediate memory and long-term memory are associated with the corresponding historical solutions.

[0166] In some other alternative implementations of this example, the evolutionary memory bank uses a tree diagram to record all historical solutions. The evolutionary memory bank is a memory storage unit in the evolutionary memory system based on a multi-population island parallel model and a multi-dimensional phenotypic elite archiving algorithm. The structure of the multi-population island parallel model is a ring topology, which is obtained by splicing ring strips corresponding to the number of islands. Each ring strip is used to store the historical solutions belonging to the corresponding population stored on the corresponding island. The elite solutions of each population are recorded by the multi-dimensional table provided by the multi-dimensional phenotypic elite archiving algorithm.

[0167] In some other alternative implementations of this example, the current parent solution selection module includes: The selection weight determination submodule is configured to determine the selection weights of each annular strip constituting the topology of the link according to the improvement strategy. The selection weight is directly proportional to the probability that the historical solution in the population is used as the historical parent solution to produce an effective solution, and the effective solution produced is directly proportional to the degree to which the corresponding historical parent solution satisfies the task requirements. The target selection strip determination submodule is configured to determine the segment strip with the highest selection weight as the target selection strip; The current parent solution selection module is configured to select the current parent solution from the historical solutions stored in the target selection strip.

[0168] In some other alternative implementations of this example, the current parent solution selects a child module as follows: The elite solution stored in the target selection strip is determined as the current parent solution.

[0169] In some other alternative implementations of this example, the selection weight is also proportional to the population entropy of the population, which is proportional to the diversity of historical solutions within the population.

[0170] In some other alternative implementations of this example, the evolutionary solving unit 901 includes an evolutionary experience generation subunit configured to generate evolutionary experience with evolutionary direction corresponding to the current evolutionary round, based on the improvement strategy and the actual degree to which the current solution meets the task requirements. The evolutionary experience generation subunit is further configured to: Determine the expected improvements based on the improvement strategy, and determine the actual improvements based on the degree to which the current solution actually meets the task requirements; Determine the degree of matching based on the difference between the actual improvements and the expected improvements; Positive and negative contributions are determined based on the degree of matching. Based on the positive and negative contributions, improvement suggestions are generated for the current solution to at least maintain the positive contribution and to minimize the negative contribution; whereby the evolutionary experience includes: matching degree, positive contribution, negative contribution and improvement suggestions.

[0171] In some other alternative implementations of this example, the evolutionary experience generation subunit may also include: The improvement suggestion adjustment module is configured to adjust improvement suggestions based on unexpected performance in the current solution.

[0172] In some other alternative implementations of this example, the problem processing apparatus 900 based on evolutionary agents may further include: an experience summarization unit configured to summarize different evolutionary experiences generated from different historical solutions at different historical evolutionary stages, the experience summarization unit being further configured to: Identify parent-child historical solutions with parent-child relationships among different historical solutions, and generate a summary of parent-child solution evolutionary experiences based on the differences between the different evolutionary experiences corresponding to the parent-child historical solutions. Different child historical solutions corresponding to the same parent historical solution are identified in different historical solutions. Based on the differences between the evolutionary experiences corresponding to each child historical solution that is in a parallel relationship, a summary of evolutionary experiences of parallel child solutions is generated. The historical evolutionary experience summary includes: the evolutionary experience summary of parent and child solutions and the evolutionary experience summary of parallel child solutions.

[0173] This embodiment exists as a device embodiment corresponding to the above method embodiment. The problem processing device based on evolutionary intelligent agents provided in this embodiment determines the improvement strategy based on task requirements and historical evolutionary experience in each round of evolution. This allows the improvement strategy to fully draw on effective historical experience, avoids blind exploration, and improves the pertinence of the improvement strategy. At the same time, when the generated current solution does not meet the task requirements, it also generates evolutionary experience containing evolutionary direction by combining the improvement strategy and the actual degree of satisfaction of the current solution, and updates the historical evolutionary experience summary, realizing the cyclical accumulation and reuse of evolutionary experience. Through this cyclical mechanism of "planning-execution-experience summary based on summarized experience", each round of evolution can adjust its direction based on the experience of the previous round, gradually approaching the task requirements, significantly improving evolutionary efficiency, reducing ineffective evolutionary rounds, and quickly converging to the target solution that meets the task requirements, while ensuring the accuracy of the target solution's performance in meeting the task requirements.

[0174] According to embodiments of this disclosure, this disclosure also provides an electronic device, the electronic device comprising: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, the instructions being executed by the at least one processor to enable the at least one processor to implement the problem-solving method based on evolutionary intelligent agents described in any of the above embodiments.

[0175] According to embodiments of this disclosure, this disclosure also provides a readable storage medium storing computer instructions that enable a computer to implement the problem-solving method based on evolutionary intelligent agents described in any of the above embodiments when executed.

[0176] According to embodiments of this disclosure, this disclosure also provides a computer program product that, when executed by a processor, can implement the problem-solving method based on evolutionary intelligent agents described in any of the above embodiments.

[0177] Figure 10 A schematic block diagram of an example electronic device 1000 that can be used to implement embodiments of the present disclosure is shown. The electronic device is intended to represent various forms of digital computers, such as laptop computers, desktop computers, workstations, personal digital assistants, servers, blade servers, mainframe computers, and other suitable computers. The electronic device may also represent various forms of mobile devices, such as personal digital processors, cellular phones, smartphones, wearable devices, and other similar computing devices. The components shown herein, their connections and relationships, and their functions are merely illustrative and are not intended to limit the implementation of the present disclosure described and / or claimed herein.

[0178] like Figure 10As shown, device 1000 includes a computing unit 1001, which can perform various appropriate actions and processes according to a computer program stored in read-only memory (ROM) 1002 or a computer program loaded into random access memory (RAM) 1003 from storage unit 1008. The RAM 1003 may also store various programs and data required for the operation of device 1000. The computing unit 1001, ROM 1002, and RAM 1003 are interconnected via bus 1004. Input / output (I / O) interface 1005 is also connected to bus 1004.

[0179] Multiple components in device 1000 are connected to I / O interface 1005, including: input unit 1006, such as keyboard, mouse, etc.; output unit 1007, such as various types of monitors, speakers, etc.; storage unit 1008, such as disk, optical disk, etc.; and communication unit 1009, such as network card, modem, wireless transceiver, etc. Communication unit 1009 allows device 1000 to exchange information / data with other devices through computer networks such as the Internet and / or various telecommunications networks.

[0180] The computing unit 1001 can be various general-purpose and / or special-purpose processing components with processing and computing capabilities. Some examples of the computing unit 1001 include, but are not limited to, a central processing unit (CPU), a graphics processing unit (GPU), various special-purpose artificial intelligence (AI) computing chips, various computing units running machine learning model algorithms, a digital signal processor (DSP), and any suitable processor, controller, microcontroller, etc. The computing unit 1001 performs the various methods and processes described above, such as problem-solving methods based on evolutionary agents. For example, in some embodiments, the problem-solving method based on evolutionary agents can be implemented as a computer software program tangibly contained in a machine-readable medium, such as storage unit 1008. In some embodiments, part or all of the computer program can be loaded and / or installed on device 1000 via ROM 1002 and / or communication unit 1009. When the computer program is loaded into RAM 1003 and executed by the computing unit 1001, one or more steps of the problem-solving method based on evolutionary agents described above can be performed. Alternatively, in other embodiments, the computing unit 1001 may be configured to perform an evolutionary agent-based problem-solving method by any other suitable means (e.g., by means of firmware).

[0181] Various embodiments of the systems and techniques described above herein can be implemented in digital electronic circuit systems, integrated circuit systems, field-programmable gate arrays (FPGAs), application-specific integrated circuits (ASICs), application-specific standard products (ASSPs), systems-on-a-chip (SoCs), payload-programmable logic devices (CPLDs), computer hardware, firmware, software, and / or combinations thereof. These various embodiments may include implementations in one or more computer programs that can be executed and / or interpreted on a programmable system including at least one programmable processor, which may be a dedicated or general-purpose programmable processor, capable of receiving data and instructions from a storage system, at least one input device, and at least one output device, and transmitting data and instructions to the storage system, the at least one input device, and the at least one output device.

[0182] The program code used to implement the methods of this disclosure may be written in any combination of one or more programming languages. This program code may be provided to a processor or controller of a general-purpose computer, special-purpose computer, or other programmable data processing apparatus, such that when executed by the processor or controller, the program code causes the functions / operations specified in the flowcharts and / or block diagrams to be implemented. The program code may be executed entirely on a machine, partially on a machine, as a standalone software package partially on a machine and partially on a remote machine, or entirely on a remote machine or server.

[0183] In the context of this disclosure, a machine-readable medium can be a tangible medium that may contain or store a program for use by or in conjunction with an instruction execution system, apparatus, or device. A machine-readable medium can be a machine-readable signal medium or a machine-readable storage medium. A machine-readable medium can be, but is not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, apparatus, or devices, or any suitable combination of the foregoing. More specific examples of machine-readable storage media include electrical connections based on one or more wires, portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination of the foregoing.

[0184] To provide interaction with a user, the systems and techniques described herein can be implemented on a computer having: a display device for displaying information to the user (e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor); and a keyboard and pointing device (e.g., a mouse or trackball) through which the user provides input to the computer. Other types of devices can also be used to provide interaction with the user; for example, feedback provided to the user can be any form of sensory feedback (e.g., visual feedback, auditory feedback, or tactile feedback); and input from the user can be received in any form (including sound input, voice input, or tactile input).

[0185] The systems and technologies described herein can be implemented in computing systems that include backend components (e.g., as a data server), or computing systems that include middleware components (e.g., an application server), or computing systems that include frontend components (e.g., a user computer with a graphical user interface or web browser through which a user can interact with implementations of the systems and technologies described herein), or any combination of such backend, middleware, or frontend components. The components of the system can be interconnected via digital data communication of any form or medium (e.g., a communication network). Examples of communication networks include local area networks (LANs), wide area networks (WANs), and the Internet.

[0186] Computer systems can include clients and servers. Clients and servers are generally located far apart and typically interact through communication networks. The client-server relationship is created by computer programs running on the respective computers and having a client-server relationship with each other. The server can be a cloud server, also known as a cloud computing server or cloud host, which is a hosting product within the cloud computing service system to address the shortcomings of traditional physical hosts and Virtual Private Server (VPS) services, such as high management difficulty and weak business scalability.

[0187] According to the technical solution of this disclosure, by determining the improvement strategy based on task requirements and historical evolutionary experience in each round of evolution, the improvement strategy can fully draw on effective historical experience, avoid blind exploration, and improve the pertinence of the improvement strategy. Simultaneously, when the generated current solution does not meet the task requirements, evolutionary experience containing evolutionary direction is generated by combining the improvement strategy and the actual degree of satisfaction of the current solution, and this experience is updated in the historical evolutionary experience summary, realizing the cyclical accumulation and reuse of evolutionary experience. Through this cyclical mechanism of "planning-execution-experience summary based on summarized experience," each round of evolution can adjust its direction based on the experience of the previous round, gradually approaching the task requirements, significantly improving evolutionary efficiency, reducing ineffective evolutionary rounds, and quickly converging to the target solution that meets the task requirements, while ensuring the accuracy of the target solution's performance in meeting the task requirements.

[0188] It should be understood that the various forms of processes shown above can be used to rearrange, add, or delete steps. For example, the steps described in this disclosure can be executed in parallel, sequentially, or in different orders, as long as the desired result of the technical solution disclosed in this disclosure can be achieved, and this is not limited herein.

[0189] The specific embodiments described above do not constitute a limitation on the scope of protection of this disclosure. Those skilled in the art should understand that various modifications, combinations, sub-combinations, and substitutions can be made according to design requirements and other factors. Any modifications, equivalent substitutions, and improvements made within the spirit and principles of this disclosure should be included within the scope of protection of this disclosure.

Claims

1. A problem-solving method based on evolutionary intelligent agents, comprising: Determine the task requirements and current evolutionary stage of the problem to be addressed, and then execute the evolutionary solution steps: Based on the task requirements and the summary of historical evolutionary experience, the improvement strategy of the current evolutionary round compared with the previous evolutionary round is determined. The summary of historical evolutionary experience is obtained by summarizing the different evolutionary experiences generated by different historical solutions in different historical evolutionary rounds. Based on the improved strategy, a current solution is generated for processing the problem to be solved; In response to the current solution not meeting the task requirements, based on the improvement strategy and the actual degree to which the current solution meets the task requirements, an evolutionary experience with evolutionary orientation is generated corresponding to the current evolutionary round. The historical evolutionary experience summary is updated using the evolutionary experience of the current evolutionary cycle; The next evolutionary round is taken as the new current evolutionary round, and the evolutionary solution steps are repeated until the target solution that meets the task requirements is obtained.

2. The method according to claim 1, wherein, The step of generating a current solution for processing the problem to be processed based on the improved strategy includes: Based on the improved strategy, the current parent solution is selected from the memory evolution library that stores all historical solutions; Based on the current parent solution and the task requirements, determine the target solution generation mode; Based on the current parent solution, multiple candidate sub-solutions are generated according to the target solution generation mode and the improvement strategy; Determine the actual degree to which each candidate sub-solution satisfies the task requirements, and determine the candidate sub-solution that has a higher degree of satisfaction with the task requirements than the current parent solution as the current solution for processing the problem to be processed in the current evolution round.

3. The method according to claim 2, wherein, The step of determining the target solution generation mode based on the current parent solution and the task requirements includes: The first piece of information is determined based on the actual degree to which the current parent solution meets the task requirements; The second information is determined based on the problem to be processed, the problem type, and the difficulty level of the task requirements; The solution generation cost is determined based on the first information and the second information; The solution generation mode corresponding to the solution generation cost is determined as the target solution generation mode.

4. The method according to claim 3, wherein, The step of determining the solution generation mode corresponding to the solution generation cost as the target solution generation mode includes: In response to the solution generation cost being less than a preset generation cost threshold, a single-turn dialogue is determined as the target solution generation mode; wherein, a single-turn dialogue refers to generating a solution through a single interaction; In response to the solution generation cost being not less than the preset generation cost threshold, multi-turn dialogue is determined as the target solution generation mode; wherein, the multi-turn dialogue refers to generating a solution through at least two interactions or at least two execution steps.

5. The method according to claim 4, wherein, The step of determining the solution generation cost based on the first information and the second information includes: In response to the first information being that the actual degree of satisfaction of the task requirement by the current parent solution is lower than a preset satisfaction threshold, and the second information containing the problem type being mathematical algorithm evolution and the difficulty level being finding an effective solution, the value less than the preset generation cost threshold is determined as the solution generation cost; In response to the first information being that the actual degree of satisfaction of the task requirement by the current parent solution is lower than the preset satisfaction threshold, and the second information containing the problem type being mathematical algorithm evolution and the difficulty level being breaking through the target limit value, a value not less than the preset generation cost threshold is determined as the solution generation cost.

6. The method according to claim 2, wherein, Based on the current parent solution, multiple candidate sub-solutions are generated according to the target solution generation mode and the improvement strategy, including: Based on the current parent solution, M candidate sub-solutions are generated in the dialogue provided by the target solution generation mode according to the improved strategy; wherein, the method of generating M candidate sub-solutions will be retried a maximum of N times if the actual satisfaction level of any candidate sub-solution does not exceed the actual satisfaction level of the current parent solution, and the size of M increases with the increase of the actual number of retries.

7. The method according to claim 6, further comprising: The content of each round of dialogue is stored as instantaneous memory; In response to the cumulative storage of the instantaneous memory exceeding the preset upper limit of the preceding information, all currently accumulated instantaneous memories and historical intermediate memories are aggregated, and a semantic summary is generated for the aggregation result as a new intermediate memory. Intermediate memories that have been retained more than a preset number of times and / or whose importance exceeds a preset level are transferred to long-term memories; wherein, the instantaneous memories, the intermediate memories, and the long-term memories are associated with the corresponding historical solutions.

8. The method according to claim 2, wherein, The evolutionary memory bank uses a tree diagram to record all historical solutions. The evolutionary memory bank is a memory storage unit in an evolutionary memory system based on a multi-population island parallel model and a multi-dimensional phenotypic elite archiving algorithm. The structure of the multi-population island parallel model is a ring topology, which is obtained by splicing ring strips corresponding to the number of islands. Each ring strip is used to store the historical solutions belonging to the corresponding population stored on the corresponding island. The elite solutions of each population are recorded by the multi-dimensional table provided by the multi-dimensional phenotypic elite archiving algorithm.

9. The method according to claim 8, wherein, The step of selecting the current parent solution from the evolutionary memory storing all historical solutions based on the improved strategy includes: The selection weights of each annular strip constituting the topology of the link are determined according to the improvement strategy; wherein, the magnitude of the selection weight is directly proportional to the probability that the historical solution in the population is used as the historical parent solution to produce an effective solution, and the effective solution produced is directly proportional to the degree to which the corresponding historical parent solution satisfies the task requirements. The segment with the highest selection weight is identified as the target selection segment; The current parent solution is selected from the historical solutions stored in the target selection strip.

10. The method according to claim 9, wherein, The step of selecting the current parent solution from the historical solutions stored in the target selection strip includes: The elite solutions stored in the target selection strip are determined as the current parent solutions.

11. The method according to claim 8, wherein, The selection weight is also proportional to the population entropy of the population to which it belongs, and the population entropy is proportional to the degree of diversity of historical solutions within the population.

12. The method according to any one of claims 1-11, wherein, The step of generating evolutionary experience with evolutionary direction corresponding to the current evolutionary round, based on the improvement strategy and the actual degree to which the current solution meets the task requirements, includes: The improvement expectation is determined based on the improvement strategy, and the actual improvement is determined based on the actual degree to which the current solution meets the task requirements; The degree of matching is determined based on the difference between the actual improvement and the expected improvement. Positive and negative contributions are determined based on the matching degree. Based on the positive and negative contributions, an improvement proposal is generated for the current solution to at least maintain the positive contribution and to mitigate the negative contribution as much as possible; wherein the evolutionary experience includes: the matching degree, the positive contribution, the negative contribution, and the improvement proposal.

13. The method according to claim 12, wherein, The step of generating evolutionary experience with evolutionary direction corresponding to the current evolutionary round, based on the improvement strategy and the actual degree to which the current solution meets the task requirements, further includes: In response to unexpected performance in the current solution that exceeds the expected improvement, the improvement recommendations are adjusted based on the unexpected performance.

14. The method of claim 12, further comprising: This summary is based on the different evolutionary experiences generated from different historical solutions at different stages of evolution, and includes: Identify parent-child historical solutions with parent-child relationships among different historical solutions, and generate a summary of parent-child solution evolutionary experiences based on the differences between the different evolutionary experiences corresponding to the parent-child historical solutions. Different child historical solutions corresponding to the same parent historical solution are identified in different historical solutions, and a summary of evolutionary experiences of parallel child solutions is generated based on the differences between the evolutionary experiences corresponding to each child historical solution that is in a parallel relationship; wherein, the historical evolutionary experience summary includes: the parent-child solution evolutionary experience summary and the parallel child solution evolutionary experience summary.

15. A problem-solving device based on an evolutionary intelligent agent, comprising: The evolutionary solving unit is configured to determine the task requirements and the current evolutionary round of the problem to be processed, and to execute the evolutionary solving steps: based on the task requirements and the summary of historical evolutionary experience, determine the improvement strategy of the current evolutionary round compared with the previous evolutionary round, wherein the summary of historical evolutionary experience is obtained by summarizing the different evolutionary experiences generated from different historical solutions of different historical evolutionary rounds; Based on the improved strategy, a current solution is generated for processing the problem to be solved; In response to the current solution not meeting the task requirements, based on the improvement strategy and the actual degree to which the current solution meets the task requirements, an evolutionary experience with evolutionary direction corresponding to the current evolutionary round is generated; the historical evolutionary experience summary is updated using the evolutionary experience of the current evolutionary round. The repeat execution unit is configured to take the next evolutionary round as the new current evolutionary round and repeat the evolutionary solution steps until the target solution that meets the task requirements is obtained.

16. An electronic device comprising: At least one processor; as well as A memory communicatively connected to the at least one processor; wherein, The memory stores instructions executable by the at least one processor, which, when executed by the at least one processor, enables the at least one processor to perform the problem-solving method based on evolutionary agents as described in any one of claims 1-14.

17. A non-transitory computer-readable storage medium storing computer instructions for causing the computer to perform the problem-solving method based on an evolutionary intelligent agent as described in any one of claims 1-14.

18. A computer program product comprising a computer program that, when executed by a processor, implements the steps of the problem-solving method based on an evolutionary agent according to any one of claims 1-14.

Images