Task processing method and device based on model cycle cultivation, equipment and medium

Abstract

The invention relates to the technical field of intelligent decision making, can be applied to business scenes such as financial science and technology and medical health, and discloses a task processing method and device based on model circulation cultivation, equipment and a medium. Comprising the steps of generating a progressive difficulty task sequence, executing a task to obtain a decision action trajectory, identifying elite decision fragments and fusing the elite decision fragments to form a guide strategy model, updating a candidate agent model based on the guide strategy model, constructing a failure case library and generating a directional enhanced training set, and performing multi-round cycle cultivation to obtain an optimized agent model. And finally generating a target task processing result. According to the method, through a cyclic evolution mechanism of progressive task learning, elite strategy fusion and failure driven training, the information seeking efficiency and decision stability of the intelligent agent under a complex task are improved.

Description

Technical Field

[0001] This invention relates to the field of intelligent decision-making technology, and in particular to a task processing method, apparatus, device, and medium based on model cyclic breeding. Background Technology

[0002] As the internet evolves into a massive, globally distributed information repository, complex tasks often require integrating and reasoning across vast, dispersed, and heterogeneous information sources, placing higher demands on information retrieval and strategy decision-making systems. While existing technologies such as traditional search engines, conversational question-answering systems, and early agent architectures can perform retrieval tasks within specific scopes, their capabilities remain significantly limited when dealing with complex structures, highly coupled information, and varied task steps.

[0003] In the fintech business, scenarios such as risk identification, credit assessment, and intelligent investment consulting typically rely on multi-round information retrieval, cross-document logical connections, and comprehensive judgment based on fact chains. Existing data-driven retrieval or inference models often only execute single-step or shallow logic, and their strategies are limited by fixed training data, making it difficult to adapt to new business structures, the latest regulatory policies, or rapidly changing market events. When faced with tasks such as cross-source contradictory information, multi-field cross-validation, and anomaly interpretation, models often exhibit strategy rigidity due to a lack of sustainable evolutionary strategy mechanisms, failing to automatically adjust their retrieval paths or inference behaviors based on new erroneous experiences or business changes. Furthermore, single-model systems cannot leverage the differentiated capabilities of multiple models, nor can they form a more robust and generalized strategy set through the mutual complementarity of multiple agents.

[0004] In the healthcare field, scenarios such as clinical decision support, symptom information collection, and cross-document medical evidence comparison often require handling medical content with complex terminology, high information uncertainty, and diverse data formats. Existing information retrieval models typically rely on limited sample data for learning. When encountering rare cases, interdisciplinary reasoning, or unstructured medical knowledge, their retrieval strategies are prone to path deviations or information omissions. Due to a lack of ability to continuously absorb new papers, new cases, or the latest guidelines, models cannot gradually improve their reasoning chain organization capabilities over long-term operation. At the same time, uncertain symptom combinations, conflicting medical viewpoints, and high-risk decision-making needs in medical scenarios make it more difficult for single-strategy models to possess robustness and fault tolerance, and current technologies cannot automatically discover efficient task processing strategies through multi-agent collaboration. Summary of the Invention

[0005] The main objective of this invention is to provide a task processing method, apparatus, device, and storage medium based on model cyclic breeding. This invention aims to address the technical problem that existing technologies lack mechanisms to achieve continuous evolution in a multi-agent policy ecosystem, self-correct based on failure experience, and form continuously upgradeable information-seeking capabilities through group policy fusion, resulting in models being unable to cope with complex, multi-source, and changing task scenarios.

[0006] To achieve the above objectives, the present invention provides a task processing method based on model iterative breeding, comprising: Based on the preset task complexity dimension parameters, a sequence of simulated information interaction tasks with progressive difficulty gradients is generated; The simulated information interaction task sequence is input into a policy ecosystem set containing multiple candidate intelligent agent models. Each candidate intelligent agent model is controlled to execute the simulated information interaction task sequence in parallel and independently, and the decision action trajectory generated during the execution process is obtained. Each decision node in the decision action trajectory is analyzed using a multi-dimensional quality analysis model, and elite decision segments that meet preset performance standards are selected and identified from all decision nodes included in the decision action trajectory based on the analysis results. Elite decision fragments from different candidate agent models are logically spliced ​​and fused to generate a fused guidance strategy model; Using the fusion-guided strategy model as the supervision target, the parameters of all candidate agent models in the strategy ecosystem set are updated. Extract failure cases that lead to execution failure or incorrect results from the decision-making action trajectory, and construct a failure case library; Based on the failure case library, a targeted reinforcement training set is generated. The candidate agent model with updated parameters is controlled to perform repeated iterative training on the targeted reinforcement training set to obtain the evolved agent model. The evolved agent model is used again as the candidate agent model, and the step of generating a sequence of simulated information interaction tasks with progressive difficulty gradients is returned to be executed. Multiple rounds of cyclical training are carried out until the preset training termination condition is met, and an optimized agent model is obtained. The optimized agent model is used to process the target task and generate the target task processing result.

[0007] Furthermore, to achieve the above objectives, the present invention provides a task processing device based on model cyclic breeding, comprising: The task generation module is used to generate a sequence of simulated information interaction tasks with progressive difficulty gradients based on preset task complexity dimension parameters. The parallel execution module is used to input the simulated information interaction task sequence into a policy ecosystem set containing multiple candidate agent models, control each candidate agent model to execute the simulated information interaction task sequence in parallel and independently, and obtain the decision action trajectory generated during the execution process. The quality analysis module is used to analyze each decision node in the decision action trajectory through a multi-dimensional quality analysis model, and to select and identify elite decision segments that meet the preset performance standards from all decision nodes included in the decision action trajectory based on the analysis results. The strategy fusion module is used to logically splice and fuse elite decision fragments from different candidate agent models to generate a fused guided strategy model. The parameter update module is used to update the parameters of all candidate agent models in the policy ecosystem set by using the fusion guidance strategy model as the supervision target. The failure case construction module is used to extract failure cases that lead to execution failure or incorrect results from the decision action trajectory and build a failure case library. The targeted reinforcement training module is used to generate a targeted reinforcement training set based on the failure case library, and control the candidate agent model after parameter update to perform repeated iterative training on the targeted reinforcement training set to obtain the evolved agent model. The iterative nurturing module is used to re-use the evolved agent model as the candidate agent model, return to the step of generating a sequence of simulated information interaction tasks with progressive difficulty gradients, perform multiple rounds of iterative nurturing until the preset training termination condition is met, and obtain the optimized agent model. The task execution module is used to process the target task through the optimized agent model and generate the target task processing result.

[0008] Furthermore, to achieve the above objectives, the present invention also provides a computer device, the computer device including a memory, a processor, and a model-based cyclic breeding task processing program stored in the memory and executable on the processor, wherein when the model-based cyclic breeding task processing program is executed by the processor, it implements the steps of the model-based cyclic breeding task processing method as described above.

[0009] Furthermore, to achieve the above objectives, the present invention also provides a computer-readable storage medium storing a task processing program based on model cyclic breeding, wherein the task processing program based on model cyclic breeding, when executed by a processor, implements the steps of the task processing method based on model cyclic breeding as described above.

[0010] Beneficial Effects: This invention relates to the field of intelligent decision-making technology and can be applied to business scenarios such as fintech and healthcare. It discloses a task processing method, apparatus, device, and medium based on model iterative development, comprising: generating a sequence of simulated information interaction tasks with progressively increasing difficulty; executing tasks to obtain decision action trajectories; identifying elite decision segments based on quality analysis; fusing these to form a guiding strategy model and using it to update candidate agent models; extracting failure cases from the trajectories to construct a failure case library; generating a targeted reinforcement training set based on the failure case library to obtain an evolved agent model; obtaining an optimized agent model through multiple rounds of iterative development; and having the optimized agent model process the target task to generate the target task processing result. This invention, through progressive task difficulty generation, elite strategy fusion, failure experience reinforcement training, and iterative evolution mechanisms, enables the agent to develop a continuously improving information-seeking ability, significantly improving the quality of information acquisition and reasoning stability under complex tasks. Attached Figure Description

[0011] The present invention will be further described below with reference to the accompanying drawings and embodiments. In the accompanying drawings: Figure 1 This is a schematic diagram of an application environment for a task processing method based on model cyclic breeding in one embodiment of the present invention; Figure 2 This is a flowchart illustrating an embodiment of the task processing method based on model cyclic breeding according to the present invention; Figure 3 This is a schematic diagram of the functional modules of a preferred embodiment of the task processing device based on model cyclic breeding of the present invention; Figure 4 This is a schematic diagram of the structure of a computer device according to an embodiment of the present invention; Figure 5 This is another structural schematic diagram of a computer device according to one embodiment of the present invention. Detailed Implementation

[0012] It should be understood that the specific embodiments described herein are for illustrative purposes only and are not intended to limit the scope of the invention.

[0013] The task processing method based on model cyclic breeding provided in this invention can be applied to, for example... Figure 1In this application environment, the client communicates with the server via a network. The server can generate a sequence of simulated information interaction tasks with progressively increasing difficulty through the client, execute the tasks to obtain decision-making action trajectories, identify elite decision fragments based on quality analysis, fuse them to form a guiding strategy model and use it to update the candidate agent model, extract failure cases from the trajectories to build a failure case library, generate a targeted reinforcement training set based on the failure case library to obtain an evolved agent model, and obtain an optimized agent model through multiple rounds of iterative training. The optimized agent model then processes the target task to generate the target task processing result. This invention, through progressive task difficulty generation, elite strategy fusion, failure experience reinforcement training, and iterative evolution mechanism, enables the agent to form a continuously improving information-seeking ability, significantly improving the information acquisition quality and reasoning stability under complex tasks. The client can be, but is not limited to, various personal computers, laptops, smartphones, tablets, and portable wearable devices. The server can be implemented using a standalone server or a server cluster consisting of multiple servers. The invention will be described in detail below through specific embodiments.

[0014] Please see Figure 2 , Figure 2 This is a flowchart illustrating an embodiment of the task processing method based on model iterative breeding provided by the present invention. It should be noted that although the logical order is shown in the flowchart, in some cases, the steps shown or described may be performed in a different order than that shown here.

[0015] like Figure 2 As shown, the task processing method based on model cyclic breeding proposed in this invention includes the following steps: S10: Generate a sequence of simulated information interaction tasks with progressive difficulty gradients based on preset task complexity dimension parameters. In this embodiment, the preset task complexity dimension parameters consist of multiple dimensions used to express the differences in information interaction behavior. These dimensions can be derived from quantifiable indicators in the task structure, such as text size, information volume, inference depth, semantic jump amplitude, information dependency chain length, or environmental noise disturbance level. Each indicator can be defined with different value ranges in the numerical space, forming a computable complexity representation vector. The complexity dimension parameters can be set based on the statistical distribution of historical task samples or manually based on domain knowledge to form a complexity space covering different task difficulty levels. During the generation of simulated information interaction tasks, by reading different values ​​of the complexity dimension parameters, these values ​​are mapped to structural constraints that can be used to construct task content, such as controlling the number of structural levels of the input text, the nesting depth of the information to be extracted, the logical span between search terms, or the proportion of information noise to be processed.

[0016] The progressive difficulty gradient is determined by the numerical span of the combination of complexity dimensions. In a continuous difficulty space, the generation of each task requires a unidirectional or bidirectional numerical increase in the complexity dimension parameter, resulting in a more complex structure in terms of information density, inference depth, or interaction logic chain. The generation process of simulating information interaction tasks can adjust the task description template, information interference configuration, inference chain depth, or semantic structure according to the complexity dimension vector, so that tasks of different gradients exhibit perceptible differences in input scale, number of dependencies, noise ratio, and distribution of target information. When generating executable task content, the number of entities, number of events, nesting levels, cross-segment dependencies, or semantic jump requirements in the task can be dynamically increased based on the complexity value, and the same complexity mapping method ensures that all task gradients have an upward progressive relationship.

[0017] The simulated information interaction task sequence consists of several tasks following the aforementioned gradient system. Each task, during generation, is constrained by a complexity dimension parameter and forms the task text or input structure through mechanisms such as content splicing, information perturbation, structural transformation, or semantic rewriting. Tasks within the sequence need to maintain gradient continuity, ensuring a quantifiable increase in complexity between preceding and subsequent tasks. To avoid content duplication between tasks, content perturbation, structural replacement, or semantic fragment re-extraction can be employed during generation to maintain content diversity while ensuring an increasing difficulty level in the task sequence.

[0018] This embodiment generates a sequence of simulated information interaction tasks with progressive difficulty gradients by using complexity dimension parameters and a parameter-driven approach. It can dynamically adjust the amount of task information, inference depth, or semantic span while maintaining the consistency of task structure, so that each task forms a continuous difficulty increase relationship, realizing a smooth transition from simple cognitive ability to complex reasoning ability. This helps to form a more stable learning curve during training or evaluation and improves the model's adaptability when handling tasks of different complexities.

[0019] S20, the simulated information interaction task sequence is input into a policy ecosystem set containing multiple candidate intelligent agent models, and each candidate intelligent agent model is controlled to execute the simulated information interaction task sequence in parallel and independently, and the decision action trajectory generated during the execution process is obtained. In this embodiment, the simulated information interaction task sequence refers to a multi-level difficulty task set formed by the preceding steps, including text content, information structure, or interaction triggering conditions that can be used to trigger the model's inference behavior. The policy ecosystem set is a runtime environment capable of accommodating multiple candidate agent models, which can consist of multiple agent models with different structures or policy characteristics. Each agent model processes the input task through an independent execution unit. Parallel independent execution means running multiple agent models simultaneously in an independent manner, allowing each agent model to complete task processing based solely on its own parameter state, without sharing the internal inference process. Parallel execution is typically achieved through multi-threading, multi-processing, or distributed instance execution mechanisms, enabling the task sequence to unfold synchronously across multiple execution paths.

[0020] The task input process distributes the task sequence one by one, converting each task into an input format that can be directly processed by the agent model. This may include steps such as structured encoding, feature vector construction, or context encapsulation. When executing a task, the agent model automatically generates a series of internal operational behaviors, such as query actions, inference actions, information selection actions, or interactive response actions. These operational behaviors constitute a decision-making action trajectory in chronological order. The decision-making action trajectory consists of multiple discrete actions, each containing an action type, action triggering conditions, intermediate state identifiers during action execution, or output fragments, which are extracted by the trajectory recording module. To maintain the continuity and analyzability of the trajectory, the trajectory recording module can monitor model state updates during execution, encoding the triggering information, execution information, and intermediate states of each action in a unified format.

[0021] This embodiment distributes simulated information interaction task sequences to a policy ecosystem set and triggers the parallel and independent execution of multiple candidate agent models. In a single run, decision action trajectories from different model policies can be obtained, enabling task processing results to cover a wider policy space. This allows for more efficient identification of behavioral and policy differences under varying task difficulty, and provides continuous, structured, and comparable behavioral data for subsequent effect evaluation or policy updates.

[0022] S30, each decision node in the decision action trajectory is analyzed through a multi-dimensional quality analysis model, and elite decision segments that meet the preset efficiency standards are selected and identified from all decision nodes included in the decision action trajectory based on the analysis results. In this embodiment, the multi-dimensional quality analysis model is an analytical structure used to evaluate decision-making action trajectories from multiple perspectives. It can construct cross-dimensional quality measurement rules based on the action content, triggering conditions, information selection methods, or intermediate states contained in the trajectory, such as time consumption dimensions, information extraction dimensions, inference stability dimensions, or logical coherence dimensions. Each decision node in the decision-making action trajectory refers to a discrete action unit formed in chronological order within the trajectory. Each action unit contains action type, triggering information, and intermediate state identifiers, represented through a unified encoding structure. To ensure that the trajectory analysis covers multiple quality aspects, the multi-dimensional quality analysis model analyzes each decision node individually, mapping the corresponding state changes, input sources, and execution behaviors to a multi-dimensional scoring vector, giving each node a comparable quality label.

[0023] The preset performance criteria are a set of thresholds used to filter high-quality behavioral segments. These can include single-dimensional thresholds or multi-dimensional comprehensive thresholds, used to determine whether decision nodes meet expected performance in specific scenarios. To identify elite decision segments from decision-making action trajectories, the analysis results of each node need to be compared with the preset performance criteria, and a segment set is constructed through the matching process of consecutive nodes. Elite decision segments consist of multiple consecutive high-quality nodes that consistently meet performance requirements in the evaluation of the multi-dimensional quality analysis model. The segment construction process needs to consider the temporal coherence and semantic coherence of actions between nodes, ensuring that the selected segments reflect stable and effective decision-making methods.

[0024] This embodiment utilizes a multi-dimensional quality analysis model to analyze the decision-making action trajectory node by node and select elite decision fragments. This can quickly locate high-quality behavioral paths in complex task processing, making the behavior selection process more structured and quantifiable, thereby providing high-value data fragments for subsequent strategy improvement, behavior fusion, or capability optimization.

[0025] S40: Logically splice and fuse elite decision fragments from different candidate agent models to generate a fused guidance strategy model; In this embodiment, elite decision segments from different candidate agent models are a set of decision behavior units that have undergone quality screening and have a continuous logical structure. Each set corresponds to an efficient behavior segment exhibited by an agent model during execution. To enable these sets to generate new strategies, a logical splicing and fusion processing method is introduced. By performing structured analysis on the action sequence, action triggering conditions, and state transition methods within the elite decision segments, the logical relationships between segments are obtained, making the efficient behaviors from different sources semantically composable. Logical splicing refers to establishing continuous relationships between multiple segments by matching the state codes of the end nodes of segments with the state codes of the start nodes of other segments to generate a connectable combination structure. Fusion refers to extracting common behavior patterns and high-frequency action chains from multiple logical splicing structures to generate a set of behaviors suitable as a unified strategy reference. The fusion-guided strategy model consists of the spliced ​​and fused action sequence structure, forming a strategy structure that can be used for behavior guidance through a unified action expression form, state transition representation method, and behavior weight configuration.

[0026] This embodiment constructs a more generalizable policy structure by performing logical splicing and fusion of elite decision fragments from different candidate agent models, enabling the integration of the advantageous behaviors of multiple agents, thereby providing a guiding policy model with stability and knowledge coverage for subsequent policy generation.

[0027] S50, using the fusion guidance strategy model as the supervision target, update the parameters of all candidate agent models in the strategy ecosystem set; In this embodiment, the fusion-guided strategy model is a strategy structure generated in the previous processing stage, used to express the action sequence expression, state transition logic, and behavioral weight information after the fusion of elite decision fragments. Using the fusion-guided strategy model as the supervision target means that when updating the parameters of candidate agent models, this strategy structure is used as a benchmark to measure whether the action probability output of the candidate agent model when processing simulated information interaction task sequences is consistent with the guidance structure. In this context, the supervision target is a target behavior distribution derived from the response process of the fusion-guided strategy model to the input task sequence, used to instruct the candidate agent model how to adjust its parameters to approach a better behavioral pattern. The candidate agent models in the strategy ecosystem are a group of agent models with different structures, preferences, or behavioral patterns. Each model needs to update its internal parameters according to the supervision target, so that the multiple models within the strategy ecosystem can approach the behavioral performance of the fusion-guided strategy model. Parameter update is an internal parameter adjustment behavior based on the difference quantification results. It iterative adjustments are made by comparing the current output of the candidate agent model with the supervision target, so that the weights, biases, or control coefficients within the model gradually approach the behavioral expression of the supervision target.

[0028] This embodiment updates the parameters of candidate agent models in the policy ecosystem by using the fused guided policy model as the supervision target, so that multiple models can continuously move closer to the fused behavioral structure, thereby obtaining a more stable, consistent policy expression with more efficient behavior distribution.

[0029] S60, extract failure cases that lead to execution failure or incorrect results from the decision action trajectory, and build a failure case library; In this embodiment, the decision action trajectory is the action sequence expression formed by the candidate agent model when executing a simulated information interaction task sequence. Its content originates from the model's query behavior, browsing behavior, and reasoning behavior, and is an important basis for judging whether the execution performance is abnormal. Extracting failure cases that lead to execution failure or incorrect results requires analyzing the action sequence structure, state transition rules, and final output content within the decision action trajectory to identify abnormal patterns in the strategy pattern. Execution failure refers to abnormal patterns such as behavior loops, behavior stagnation, or processing timeouts in the action sequence. It is usually manifested as actions repeatedly accessing the same information source at different time points, continuously executing invalid reasoning instructions, or failing to produce effective state changes for a long period of time. Result errors refer to the final conclusion given by the decision action trajectory being semantically inconsistent with the verification answer preset in the task sequence, which needs to be determined through semantic comparison or structured information comparison. The failure case library is a structured collection that uniformly collects and organizes the identified abnormal decision action trajectories, used to support targeted reinforcement of abnormal behaviors in subsequent training phases.

[0030] This embodiment extracts failure cases from decision-making action trajectories and constructs a failure case library, thereby structurally accumulating abnormal behavior patterns and error outputs. This provides a basis for continuous improvement of error patterns in subsequent training processes, thereby enhancing the model's ability to identify abnormal situations and the stability of the strategy.

[0031] S70, Based on the failure case library, a targeted reinforcement training set is generated, and the candidate agent model after parameter update is controlled to perform repeated iterative training on the targeted reinforcement training set to obtain the evolved agent model; In this embodiment, the failure case library stores decision trajectories and related information that result in execution failures or incorrect outcomes during information seeking tasks. Each record includes at least the task input, environment state sequence, action sequence, failure location marker, error type label, and expected output expression. When generating a targeted reinforcement training set based on the failure case library, the error type labels can be statistically analyzed to obtain the frequency distribution of different error categories such as timeout, interruption, loop, conclusion bias, and missing evidence in the overall dataset, thereby determining which error categories constitute performance bottlenecks. For error categories with high frequency or significant impact, training sample entries are constructed for each failure record. Each sample entry retains the original state sequence and action sequence, while introducing a reference action or target state representing the target behavior to compare the difference between the current behavior and the target behavior during training.

[0032] The construction of the targeted reinforcement training set can be completed in three stages: error segmentation, context completion, and reward signal design. In the error segmentation stage, the failure trajectory is broken down into several state transition segments in chronological order, and the key transition points leading to failure are located. These key transition points and the steps before and after them are combined into local training segments. In the context completion stage, to prevent the model from learning only local patterns and ignoring long-term dependencies, contextual information such as task instructions, historical retrieval summaries, and a list of selected evidence is added to each local training segment, ensuring that the training input truly reflects the information conditions the model faces at that time. In the reward signal design stage, reward and penalty values ​​are selected and configured for actions based on different error categories. For example, repetitive errors are strongly penalized for repeated actions, and conclusion bias errors are strongly penalized for missing key evidence. Furthermore, better action sequences, generated manually or through rules, are inserted into the local trajectories and assigned higher positive rewards. In this way, the correct behavioral paths are clearly reinforced in the targeted reinforcement training set.

[0033] After the targeted reinforcement training set is generated, the candidate agent model, with updated parameters, undergoes iterative training on this set. During training, the state sequences from failed cases serve as environmental input, the policy output of the candidate agent model is used as action selection, and an immediate reward is generated at each step using the aforementioned reward design. This reward is then combined with a discount factor to obtain a reward estimate. Parameter updates can employ policy gradient, temporal differencing, or value function-based updates, transforming the gradient relationship between reward and action probability into adjustments to the model's internal weights. In each iteration, statistical metrics such as average reward, failure rate, and trajectory length for each error category are recorded to observe the model's convergence trend on the targeted training set.

[0034] To avoid overfitting in the targeted reinforcement training set, difficulty scheduling and sampling control mechanisms can be introduced. The difficulty scheduling mechanism dynamically adjusts the proportion of samples from each category in the training batch by tracking the failure rate of different error categories. When the failure rate of a certain category decreases significantly, the weight of samples from that category is reduced, shifting training resources to categories that remain high-risk. The sampling control mechanism controls the repetition frequency of the same task instance by setting a soft threshold and merges or compresses highly similar segments in the trajectory to reduce the interference of redundant data on the update direction. After multiple rounds of iterative training, a comprehensive judgment is made based on the stable reward level on the targeted reinforcement training set, the error category coverage, and the performance on the external validation set to determine whether a new model version should be formed. The version that meets the requirements is marked as the evolved agent model and used as the starting point for subsequent iterations or for handling real tasks.

[0035] This embodiment constructs a targeted reinforcement training set based on a failure case library, and performs iterative training on the updated candidate agent model on this training set. This focuses the training process on high-risk error patterns and weak behavioral links. Through targeted reward design and multiple rounds of parameter updates, negative experiences in the failure trajectory are transformed into policy adjustment signals, thereby obtaining an evolved agent model. When faced with similar complex tasks, this model can significantly reduce the probability of repeating errors and improve decision stability and error correction capabilities.

[0036] S80, the evolved agent model is used again as the candidate agent model, and the step of generating a sequence of simulated information interaction tasks with progressive difficulty gradients is returned to be executed. Multiple rounds of training are carried out until the preset training termination condition is met, and the optimized agent model is obtained. In this embodiment, after completing a targeted training and parameter update, the evolved agent model is re-registered as a new candidate agent model for the next training cycle. In system implementation, a model version index can be maintained in the training control unit. The model weights and structural information obtained from the latest training round are marked as the current active version, and this version is added to the candidate model list within the policy ecosystem set to replace the candidate agent model used in the previous round. Through this model role switching, the same entity assumes the dual identity of both the evolutionary result and the starting model for the new round at different training stages, forming a continuous evolutionary chain.

[0037] To return to the processing stage of generating simulated information interaction task sequences with progressively increasing difficulty, the training control unit can maintain a loop control flow, organizing multiple processing stages such as task generation, model execution, quality evaluation, parameter updates, failure case discovery, and targeted training into a complete closed loop. Each time the evolved agent model completes targeted reinforcement training, the loop control flow, based on the current model version index and external configuration, redirects the control flow back to the task sequence generation logic. The updated model, combined with the new task complexity configuration, is used to generate simulated information interaction task sequences again, triggering parallel execution and subsequent analysis processes within the policy ecosystem. In this way, multi-round cyclical nurturing is not limited to local parameter fine-tuning but allows the model to continuously undergo full-process training and evaluation in different rounds.

[0038] The execution of multi-round training iterations needs to be controlled in conjunction with training termination conditions. Training termination conditions can include multiple dimensions, such as convergence judgment based on performance metrics, upper limits based on the number of iterations, and safety boundaries based on resource consumption. Regarding performance metrics, at the end of each iteration, quantitative indicators such as the model's success rate, average retrieval steps, and error type distribution on simulated information interaction task sequences can be statistically analyzed. The improvement between adjacent iterations can be calculated, and when the improvement is below a preset threshold for several consecutive iterations, performance is considered to have stabilized. Regarding the number of iterations, a maximum number of iterations can be set, and subsequent training can be forcibly terminated when the upper limit is reached. Regarding resource consumption, runtime and computing power consumption can be monitored, and a stop signal can be triggered when the target is approaching the preset budget. These three conditions can take effect individually or be combined logically to determine whether to continue to the next round of training.

[0039] When the training termination condition is met, the loop control process no longer re-enters the evolved agent model into the processing stage for generating simulated information interaction task sequences. Instead, it registers the current model version as the optimized agent model. The metadata of the optimized agent model can include the final weight parameters, performance profiles on various tasks, and capability tags formed during training, which are used for subsequent loading and invocation in real-world business scenarios. By combining the multi-round cyclic nurturing process with model version management, performance monitoring, and termination condition judgment, a stable and reliable final model version can be obtained while ensuring resource control.

[0040] This embodiment guides the evolved agent model back as a candidate agent model, and then trains it through multiple rounds of cyclical development in a complete training loop that generates a sequence of simulated information interaction tasks with progressively increasing difficulty. By combining preset training termination conditions with dynamic constraints on the cyclical process, it can avoid ineffective iterations or waste of resources while continuously accumulating training experience. This allows the model's capabilities to gradually converge to a more robust policy configuration in multiple rounds of course-based training, ultimately resulting in an optimized agent model that performs stably and has stronger generalization ability on complex information seeking tasks.

[0041] S90, the target task is processed through the optimized agent model to generate the target task processing result.

[0042] In this embodiment, after completing multiple rounds of training and capability calibration, the optimized agent model is loaded into the task processing environment to process the input target task. The target task can consist of text, structured data, or multimodal data. Before entering the processing flow, content parsing needs to be performed to transform the task type field, constraint field, retrieval content field, or inference requirement field in the input content into an internal representation that the model can understand. This internal representation can be constructed through vectorized encoding, symbolic structure mapping, semantic fragment extraction, etc., so that complex tasks can be transformed into a unified input format that adapts to the model's inference mechanism.

[0043] After content parsing is complete, a task execution environment needs to be constructed to bind task inputs, execution strategies, and runtime parameters. This environment can be implemented by dynamically loading model inference components, context management components, and a retrieval router, enabling the optimized agent model to invoke retrieval capabilities, inference capabilities, or a combination of both according to the task's processing requirements. The task execution environment can also fine-tune execution parameters based on input size, inference depth requirements, or external resource constraints. For example, it can adjust the maximum inference depth, limit the retrieval expansion width, or set thought chain length constraints to ensure the controllability and stability of the processing.

[0044] During the task execution phase, the optimized agent model initiates a series of action generation processes based on the semantic structure of the task input. These actions can include retrieving and calling up literature information, verifying data facts, constructing relationship chains, and searching for causal inference paths. Internally, the model can select the next action to execute by calculating the action probability distribution and generate continuous operation trajectories through recursive reasoning. During inference, the model can adjust subsequent action generation strategies based on accumulated intermediate conclusions, making the entire processing path exhibit dynamic programming characteristics.

[0045] The action sequences, retrieved content, inference chains, and intermediate conclusions generated during task execution can be encapsulated as execution records to construct preliminary output results. The construction of preliminary results can be accomplished by extracting final conclusion nodes, supporting evidence nodes, and key reasoning fragments from the execution records, ensuring that the target task's output includes the model's final judgment and supporting information. To generate a standard structure usable by external systems, the preliminary results need to undergo a normalization transformation, mapping the internal expression format to structured results with clearly defined field boundaries. For example, the inference chain can be transformed into a more readable sequence of sentence segments, the retrieval hit results can be integrated into factual statement fields, and the final conclusion can be reconstructed into a set of output fields.

[0046] Before outputting the final target task processing result, consistency checks and content filtering can be performed to remove redundant intermediate nodes, merge duplicate conclusions, format field order, or detect potential conflicts, ensuring that the final target task processing result has structural integrity, semantic coherence, and content accuracy. After verification, the target task processing result is exported as standardized output for loading and use by external task scheduling systems or business applications.

[0047] This embodiment utilizes an optimized agent model to process the target task, and completes the generation of the target task processing results through a processing chain of parsing input, constructing the execution environment, generating action sequences, extracting conclusions, and standardizing outputs. This enables the model to perform complex reasoning and information integration work in a stable and systematic manner. This processing establishes a tight correlation between structured parsing, action generation, and result construction, allowing the optimized agent model to maintain a clear reasoning path, effective information use, and consistent output format when facing highly complex target tasks, thereby improving the quality and usability of task processing.

[0048] In one embodiment, step S10 above includes: S101, initialize the preset task complexity dimension parameters as a multi-dimensional vector containing the logical reasoning chain length value, the information source ambiguity index, the required number of reasoning steps value, and the interference information density value. S102, using the task complexity dimension parameter set to the minimum complexity, construct a single-step fact query task instance that can obtain a definite answer with only a single retrieval; S103, the length of the logical reasoning chain, the ambiguity index of the information source, the number of required reasoning steps and the density of interference information are incrementally adjusted according to the preset gradient growth step size to generate a set of advanced complexity parameters at multiple levels. S104. Based on the advanced complexity parameter set, synthesize a multi-source contradiction verification task instance that requires comparing contradictory content from at least two heterogeneous information sources to draw a conclusion. S105, following the order of the progressive difficulty gradient, the single-step fact query task instance is used as the starting node, and the multi-source contradiction verification task instance is used as the subsequent node, and the simulated information interaction task sequence is generated by arranging and combining them in sequence.

[0049] In this embodiment, the preset task complexity dimension parameter is used to form an adjustable control space when generating tasks, continuously expanding the task difficulty from low to high. In implementation, a multi-dimensional vector is first defined in the configuration layer, with each dimension corresponding to a quantifiable complexity factor. For example, the logical reasoning chain length value limits the number of reasoning steps allowed between input and conclusion; the information source ambiguity index characterizes whether the information source is clear and whether the statement is vague; the required reasoning steps value constrains the number of reasoning jumps the model needs to complete; and the interference information density value controls the proportion of information not directly related to the target problem. This multi-dimensional vector can be initially valued through configuration files, parameter panels, or program initialization code, with upper and lower bounds and discrete intervals reserved for subsequent gradient-based adjustments.

[0050] When selecting the lowest complexity setting in the multidimensional parameter space, the length of the logical reasoning chain and the number of required reasoning steps can be minimized. For example, a one- or two-level reasoning chain can bring the ambiguity index of the information source close to zero, indicating that the information is clearly and uniquely presented, and the density of interference information close to zero, indicating that the input material contains almost no irrelevant content. Under this parameter combination, single-step fact query task instances can be constructed, constraining the task to obtain a single definite answer through a single retrieval or query operation. For example, given a specific fact item, the agent can locate the corresponding entry in an information database. These task instances do not require complex comparisons or contain contradictory information; they only verify basic retrieval and direct matching capabilities.

[0051] Building upon this, a gradient growth step size is introduced to uniformly control the adjustment range of each dimension from low to high complexity. In implementation, an incremental value can be set for each dimension. For example, the logical reasoning chain length increases by one reasoning step per level, the information source ambiguity index increases by a certain percentage per level, the required number of reasoning steps increases synchronously with the chain length, and the interference information density increases the noise proportion proportionally. By iteratively summing the parameters in the multi-dimensional parameter space with a fixed increment, several levels of advanced complexity parameter sets can be generated, forming several parameter vectors arranged from low to high, each vector corresponding to a task difficulty level.

[0052] Based on an advanced complexity parameter set, multi-source contradiction verification task instances can be generated at high complexity levels. At these levels, the length of the logical reasoning chain and the required number of reasoning steps are set to larger values, the ambiguity index of the information source is increased to a medium-to-high range, and the density of interfering information is also increased. This makes the task no longer a single fact query, but requires comparison of at least two heterogeneous information sources. Heterogeneous information sources can refer to data carriers with different structures, sources, or language styles, such as an industry report text and a set of structured indicator data, or two explanatory materials with contradictory conclusions. When generating task instances, a problem scenario needs to be constructed, allowing different information sources to have differences or implicit conflicts in key conclusions. The agent is required to identify contradictions through retrieval, comparison, and reasoning, and provide a unified conclusion after analysis. When constructing the task, the resource identifiers to be compared can be explicitly specified, or candidate resources can be automatically recalled through a set of search keywords, and then conflicting statement fragments can be injected during the generation stage.

[0053] After generating single-step fact-finding task instances and multi-source conflict verification task instances, they need to be arranged and combined according to a progressive difficulty gradient. In implementation, a difficulty level label can be assigned to each set of task parameters. The lowest complexity single-step fact-finding task instances are marked as beginner level, intermediate complexity tasks as intermediate level, and multi-source conflict verification task instances constructed using high-complexity parameter sets as advanced level. When constructing the simulated information interaction task sequence, beginner-level tasks are used as the starting node, and these tasks are arranged according to a certain number or coverage. Then, intermediate and advanced level tasks are added to the end of the sequence in ascending order of level. This arrangement and combination ensures that tasks within the same level maintain diversity in theme, data type, and scenario background, avoiding variations only in parameter values ​​without considering actual contextual differences. This forms a task sequence that gradually transitions from simple fact-finding to complex multi-source conflict analysis, for use in subsequent training or evaluation phases.

[0054] This embodiment constructs the task complexity dimension parameters into a multi-dimensional vector, and generates single-step fact query task instances and multi-source contradiction verification task instances in this vector space from the lowest complexity to the highest complexity. Then, these instances are arranged into a simulated information interaction task sequence according to a progressive difficulty gradient. This presents a task structure from shallow to deep during training or evaluation, which can solidify basic retrieval and simple reasoning capabilities in the initial stage, and can specifically stimulate cross-source comparison and contradiction resolution capabilities in the advanced stage. Thus, it achieves a unity of difficulty control, scenario richness, and quantifiable analysis in the same sequence, and improves the adaptability and plasticity of the agent in complex information environments.

[0055] In one embodiment, step S20 above includes: S201, perform heterogeneous initialization of the strategy ecosystem set, and configure the candidate intelligent agent model to include strategy models with multiple functional specializations. The strategy models include, but are not limited to, a first type of search strategy model that focuses on the breadth of information retrieval and a second type of analysis strategy model that focuses on the depth of logical reasoning. S202, assign each candidate agent model in the policy ecosystem set to an isolated independent running container, and broadcast the simulated information interaction task sequence to all the independent running containers; S203, trigger all candidate agent models in the independently running containers to start parallel processing processes, and execute the simulated information interaction task sequence in parallel and independently in a non-interfering processing environment; S204, intercept and record in real time the search query statements, web page browsing sequences, intermediate reasoning thought chains and final output conclusions of each candidate intelligent agent model during the execution process, and encapsulate them in the order of timestamps to form a decision action trajectory.

[0056] In this embodiment, when a simulated information interaction task sequence is input into the policy ecosystem set, a uniformly accessible task queue needs to be maintained in the system first. This task queue contains a structured description of each task in the simulated information interaction task sequence generated in the previous stage, such as task identifier, task text, associated background information identifier, and target response format. The policy ecosystem set, as a collective runtime environment hosting multiple candidate agent models, is typically managed through a unified scheduling module in the system architecture. The scheduling module is responsible for reading task descriptions from the task queue, packaging the tasks into standardized input objects, and passing them to the lower-level candidate agent model execution interfaces according to a unified protocol, ensuring that different models use consistent data formats and calling methods when receiving tasks.

[0057] When performing heterogeneous initialization on the strategy ecosystem, it is necessary to specify differentiated configurations for each candidate agent model in the set, so that different models complement each other in terms of capability structure and behavioral tendencies. Specifically, some models can be connected to toolchains with stronger retrieval capabilities, such as configuring richer search engine interfaces, more lenient request quotas, and broader domain knowledge indexes. These models are defined as the first type of search strategy model, emphasizing the breadth of information retrieval. Other models are strengthened in their internal reasoning structure, such as adding reasoning chain verification modules, link reconstruction modules, and intermediate conclusion verification modules, giving them a higher weight in handling multi-hop reasoning and evidence integration. These models are defined as the second type of analysis strategy model, emphasizing the depth of logical reasoning. The heterogeneous initialization process can be completed through configuration files, model registries, or service orchestration languages, registering information such as model type, tool access configuration, and resource quota limits in the metadata management unit of the strategy ecosystem.

[0058] To ensure that multiple candidate agent models do not interfere with each other during execution, each model needs to be allocated an isolated running container. The running container can be a lightweight virtualization unit, such as an instance created based on a container orchestration platform, or a process-level isolated environment. When a container is created, it needs to be bound to independent process spaces, cache spaces, and log spaces, and access to external resources should be uniformly controlled through an access gateway to avoid sharing intermediate variables or execution states between different containers. The broadcast distribution of simulated information interaction task sequences can be implemented through message queues or publish-subscribe mechanisms. The task sequence is encoded as a message stream at the sending end and pushed to the subscribers bound to all containers through a unified channel. Each container, upon receiving the task sequence, establishes a task queue locally, thus enabling each candidate agent model to fully traverse the task sequence within its own environment.

[0059] Parallel processing is triggered by the execution scheduling unit within each container. Upon receiving the start command, the execution scheduling unit creates several execution threads or coroutines for the candidate agent models bound to the current container, executing the tasks in the simulated information interaction task sequence in parallel and independently. Each execution thread, when processing a single task, strictly limits its access to the context and cache space maintained within its own container, and does not share the intermediate states of other models, thus forming a non-interfering processing environment. During execution, the candidate agent models initiate a series of operations around the task content, including constructing search queries to access external retrieval services, triggering a webpage browsing sequence based on search results to retrieve page content, generating intermediate reasoning chains internally to record the reasoning path, and providing the final output conclusion after completing all necessary operations.

[0060] To facilitate quality analysis and elite behavior screening in subsequent stages, the aforementioned information generated during execution needs to be intercepted and recorded in a structured manner in real time. The system can wrap a proxy recording module around the candidate agent model to intercept the query string, search engine identifier, and summary of returned results for each search query call, recording them as search query entries. At the webpage content retrieval interface, the system records the accessed page links, access order, and dwell time, assembling them into a webpage browsing sequence. During inference, whenever the model outputs an intermediate thought text, link structure representation, or intermediate conclusion, the proxy recording module captures and marks it as a node in the intermediate inference thought chain. When the model generates the final output conclusion, the conclusion text, confidence level, and associated task identifier are recorded as the termination node.

[0061] Through the above steps, this embodiment achieves two objectives. First, the heterogeneous initialization results in differences between the retrieval breadth model and the inference depth model, ensuring sufficient diversity of decision-making action trajectories in the policy space. This facilitates the subsequent selection of elite behaviors that combine efficiency and accuracy. Second, the independent running container and unified log encapsulation mechanism ensure clear trajectory record structure and controllable source, which helps to accurately align the operation links of different models under the same task conditions in subsequent analysis stages. This provides a high-resolution data foundation for quality assessment, policy fusion, and failure mode mining.

[0062] In one embodiment, step S30 above includes: S301, parse the decision action trajectory in chronological order, and decompose the decision action trajectory into multiple independent single-step decision nodes, each single-step decision node corresponding to a query input operation, information browsing operation, or logical reasoning operation; S302, invoke the multi-dimensional quality analysis model to quantify the answer accuracy score, step efficiency score, and behavior rationality score for each single-step decision node; S303, based on preset dimension weight coefficients, the answer accuracy score, the step efficiency score, and the behavior rationality score of each single-step decision node are weighted and summed to generate a comprehensive performance score for each single-step decision node; S304, Traverse all single-step decision nodes and compare the comprehensive performance score of each single-step decision node with the performance threshold in the preset performance standard; S305, mark the single-step decision node whose comprehensive performance score reaches or exceeds the performance threshold as an elite decision, and define the sequence of elite decision nodes in chronological order as an elite decision segment.

[0063] In this embodiment, after the execution record of the previous stage, the decision-making action trajectory first needs to be structured and parsed in chronological order, breaking down the entire trajectory into multiple independent single-step decision nodes. During the parsing process, the system uses timestamps as the primary key to sort events recorded in the log, such as query calls, page visits, inference outputs, and final conclusions, and then classifies them into three categories based on event type: query input operations, information browsing operations, and logical reasoning operations. For example, the query string and its parameters sent to the retrieval service are mapped to query input operations, the act of accessing hyperlinks and fetching page content is mapped to information browsing operations, and the thought chain text, sub-conclusions, or intermediate judgments generated internally by the model are mapped to logical reasoning operations. Each single-step decision node, in its data structure, at least includes node type, associated task identifier, relationship between preceding and following nodes, trigger time, and input / output content to support subsequent quality analysis.

[0064] The multi-dimensional quality analysis model uses single-step decision nodes as the basic unit of analysis, calculating answer accuracy score, step efficiency score, and behavior rationality score for each node. Answer accuracy score primarily targets nodes that generate intermediate or final answers, such as a logical reasoning node or a query node containing direct answer content. The analysis module can call pre-stored fact verification interfaces, knowledge alignment interfaces, or predefined rules in the task environment to compare the node output with the target fact set or standard answer set. A numerical score is calculated based on the degree of matching, fact coverage, and completeness of key elements. Step efficiency score focuses more on resource consumption and link redundancy when completing the same task objective. For example, for query input operations, it can count the number of subsequent nodes required from the current node to obtaining valid information, the cumulative request time, or the amount of resources accessed, evaluating nodes with lower resource consumption and shorter information acquisition paths as higher scores. For information browsing operations, it can assess whether the access constitutes efficient behavior by combining the effective information density of the page content and the number of jumps. The behavior rationality score is used to measure the logical rationality of the current node in the overall task context. For example, whether the logical reasoning operation is based on prior evidence, whether it introduces concepts that are irrelevant to the current problem, and whether there are obviously self-contradictory reasoning segments. The analysis module can assign lower scores to nodes that deviate from the task goal or logical link through semantic consistency detection, causal relationship template matching, and task intent alignment detection.

[0065] To aggregate evaluation results from multiple dimensions into a ranking-based comprehensive performance score, the system pre-configures a set of dimensional weight coefficients. Each component in the weight vector corresponds to the answer accuracy score, step efficiency score, and behavior rationality score. The weight settings can be adjusted according to business needs; for example, increasing the weight of the answer accuracy score in scenarios emphasizing accuracy, and appropriately increasing the weight of the step efficiency score in resource-constrained environments. After calculating the three types of scores for each single-step decision node, the multi-dimensional quality analysis model performs a weighted sum according to the weight vector to generate a comprehensive performance score at the numerical level. When comparing the comprehensive performance score with preset performance standards, these standards can be represented as one or more performance thresholds. A single threshold can be used in a single-task scenario, while different threshold tables can be maintained according to task type in multiple scenarios. The system traverses all single-step decision nodes in the decision action trajectory, compares the comprehensive performance score of each node with the corresponding performance threshold, and marks nodes that reach or exceed the threshold as elite decisions. The distribution of these elite decision-making nodes along the time axis in the trajectory typically presents several continuous segments. During traversal, the system maintains the start and end positions of the current continuous elite nodes. Once a node that does not meet a threshold is encountered, the current segment ends, and the newly accumulated sequence of continuous elite nodes is defined as an elite decision-making segment and written into the result set. In this way, high-quality information from individual actions is preserved while capturing decision sub-chains that consistently perform well over time, providing structured input for subsequent strategy combination or model guidance using these segments.

[0066] Through the above steps, this embodiment can accurately locate the local behavioral chains that truly contribute value, avoiding the overall consideration of long trajectories containing inefficient queries, redundant browsing, or unreasonable reasoning as positive examples. This provides higher-quality and more clearly structured behavioral samples for subsequent strategy fusion, knowledge transfer, and reinforcement training, thereby improving the convergence efficiency and policy ceiling of subsequent optimization stages.

[0067] In one embodiment, step S40 above includes: S401, analyze the decision logic and applicable conditions of each elite decision segment from different candidate agent models, and obtain the set of logical features of each elite decision segment; S402, Based on the set of logical features, identify the logical conflict points and complementary points between different elite decision-making segments, and generate a conflict-complement relationship diagram; S403, according to the preset conflict resolution strategy, coordinate the logical conflict points existing in the conflict complementarity relationship diagram to obtain a coordinated set of elite decision fragments. S404, The coordinated set of elite decision fragments is spliced ​​and integrated according to the task execution logic to form a spliced ​​and integrated decision logic flowchart; S405, the spliced ​​and integrated decision logic flowchart is encoded into an executable strategy model to generate a fusion guidance strategy model.

[0068] In this embodiment, elite decision segments from different candidate agent models first need to be represented in a unified format for further logical analysis and combination. Each elite decision segment can be viewed as a high-quality sequence of decision nodes arranged chronologically within a single task context. This sequence includes various operation types such as query input, information collection, evidence screening, reasoning transition, and conclusion generation. When constructing elite decision segments, the system adds metadata such as source model identifier, start and end timestamps, task identifier, and summaries of preceding and following contexts to each segment, enabling subsequent processing to both preserve the segment's position in the original trajectory and perform unified comparisons across models.

[0069] When analyzing the decision-making logic and applicable conditions of each elite decision-making segment, the system performs structured extraction of the node sequence within the segment, transforming the time series into a logical unit chain consisting of three parts: premise, action, and result. Premise can be summarized into a set of contextual constraints by extracting the task description, collected evidence, and current retrieval status at the segment's starting point, such as a set of key entities, question type labels, and a list of known evidence. Actions are represented by node types and node content, such as "initiating a webpage search," "filtering irrelevant results," and "performing comparative reasoning on two candidate answers." Results are expressed through variables such as intermediate conclusions, confidence scores, and task progress status at the segment's end. Applicable conditions are derived from the segment's actual performance on different tasks and can be generated by statistically analyzing the trigger frequency and success rate of the segment across various task labels, difficulty levels, and information source types. The system combines premise vectors, action sequence encodings, result summaries, and condition vectors to form a set of logical features for the elite decision segment. The set of logical features includes both symbolic representations (such as predicate structures and conditional constraint expressions) and continuous numerical representations (such as embedding vectors and confidence distributions), providing input for subsequent graph construction and model encoding.

[0070] After obtaining the logical feature set of all elite decision-making segments, the system compares the relationships between different segments to identify potential logical conflicts and complementarities. Logical conflicts can be determined by various conditions: for example, two segments, under similar contextual premises (same task type, similar entity set, similar difficulty level), point to different or even opposite action sequences, or they give mutually exclusive conclusions about the same information source in the same task stage; they can also manifest as making drastically different inference directions regarding the same intermediate evidence. Complementarities are reflected in highly related premises covering different sub-tasks, or the result of one segment providing missing evidence for the premise of another segment, thus forming a connectable relationship in the logical chain. The system constructs pairwise relationship matrices in the segment set by calculating context similarity, action pattern similarity, and result consistency indicators, marking segments that meet conflict conditions as conflicting relationships and segments that meet complementarity conditions as complementary relationships.

[0071] Based on the above analysis, the system constructs a conflict-complement relationship graph, treating each elite decision segment as a node in the graph and the conflict or complementarity relationships between segments as labeled edges. The edge labels distinguish between different types of conflict (e.g., different conclusions within the same context, path redundancy) and different types of complementarity (e.g., evidence completion, stage connection). Additional attributes such as similarity values ​​and historical success rate differences are also recorded on the edges. The conflict-complement relationship graph is typically stored in the form of an adjacency list or a sparse matrix, supporting subsequent operations such as traversal, connected component analysis, and maximum compatibility subgraph solving.

[0072] In the conflict resolution phase, the system coordinates the pairs of segments marked as conflicting in the relationship graph according to a pre-configured conflict resolution strategy. The conflict resolution strategy can employ a priority-based selection strategy, such as selecting the optimal segment in the conflict context based on the overall performance score of the elite decision segment in the original trajectory, cross-task statistical success rate, or the performance of the source model in the overall ecosystem, discarding the others; it can also employ a probabilistic fusion strategy, analyzing the decision probability distribution of key actions in two segments, weighting and synthesizing the action distribution at the conflict node to form a new fused action node; or it can employ a conditional splitting strategy, further subdividing the context conditions in the logical feature set, splitting the pair of segments originally marked as conflicting into their respective applicable sub-condition regions, and retaining the corresponding segments in different regions. When traversing conflict edges, the system adds the selected or fused segments to the coordinated elite decision segment set and updates the applicable conditions for each segment, ensuring that there are no unprocessed logical conflicts in the same context during subsequent splicing.

[0073] After obtaining the coordinated set of elite decision fragments, the system integrates and assembles them according to the task execution logic to construct a decision logic flowchart covering the entire task process. The task execution logic can be divided based on the task's phased structure, such as the information clarification phase, retrieval planning phase, evidence aggregation phase, and reasoning decision-making phase. The system first determines which phase a fragment is more suitable for, based on the premise and result information in the logical feature set of each fragment, and then sorts the fragments within each phase according to time sequence, dependency, and complementarity. Subsequently, the system establishes connections between phases, mapping the result variable of one fragment to the premise variable of subsequent fragments, generating directed edges in the graph to form a set of paths from the task's starting point to its completion. For scenarios with branching or backtracking behavior, the system adds condition judgment nodes to the flowchart, guiding the execution flow to select different elite decision fragment chains at runtime through conditions such as state variables, confidence thresholds, and error type markers in the premises. The final decision logic flowchart consists of three parts: a set of nodes, a set of edges, and a set of conditional expressions, capable of describing which elite decision fragment chain should be selected for execution in different contexts.

[0074] During the encoding process into an executable policy model, the system transforms the decision logic flowchart into parameter and structural configurations that can run in an inference engine or neural network architecture. For the rule-based implementation, state detection rules and action triggering rules are generated for each flowchart node, and jump condition rules are generated for each edge. These rules are loaded into the policy execution engine, which selects the next elite decision segment by matching the current task context state. In the neural network-based implementation, the logical feature set can be used as training samples, and the "state-action-next state" structure in the flowchart can be mapped as a supervision signal for the policy network. Supervised training of the policy network ensures that the network outputs a result consistent with the flowchart after receiving the current task state encoding as input. Figure 1 The algorithm calculates the probability distribution of actions and implicitly represents the branching and sequential relationships in the flowchart as parameters within the network. Regardless of the encoding method used, the generated fusion guidance strategy model accepts task context descriptions and historical trajectory summaries through a unified interface and outputs recommended actions or action probability distributions to guide the subsequent learning process.

[0075] Through the above steps, this embodiment can eliminate contradictory decision-making patterns while retaining the advantageous behavioral patterns of each model. By sequentially linking elite segments through task execution logic, the fusion-guided strategy model can not only possess the strategy diversity brought by multi-source experience when facing new tasks, but also avoid decision oscillations caused by conflicts between models. This provides a more stable, interpretable, and executable supervision target for subsequent knowledge transfer and parameter updates.

[0076] In one embodiment, step S50 above includes: S501, the simulated information interaction task sequence is loaded as input data into the fusion guidance strategy model to obtain the target action probability distribution vector output by the fusion guidance strategy model for the simulated information interaction task sequence; S502, input the simulated information interaction task sequence into the candidate agent model in the policy ecosystem set, and obtain the current predicted action probability distribution vector output by the candidate agent model; S503, determine the relative entropy divergence value between the target action probability distribution vector and the current predicted action probability distribution vector, so as to quantify the difference in decision logic between the candidate agent model and the fusion guidance strategy model; S504, construct a loss function with the objective of minimizing the relative entropy divergence value, determine the gradient using the backpropagation algorithm based on the loss function, and update the parameters of the candidate agent model based on the gradient until the relative entropy divergence value meets the preset convergence condition, thereby obtaining the candidate agent model with updated parameters.

[0077] In this embodiment, the previously constructed simulated information interaction task sequence is first used as a unified training input. The system expands the simulated information interaction task sequence by time step. Each task sample includes fields such as task description, current context state, and historical interaction fragments. These are converted into vector representations by the encoding module and used to form batch inputs. These batch inputs are then fed into the fusion guidance strategy model for forward computation. At each decision moment, the fusion guidance strategy model outputs a target action probability distribution vector. This vector spatially covers the set of currently executable actions, such as continuing retrieval, switching information sources, merging evidence, and executing intermediate summaries. Each dimension corresponds to the probability value of an optional action, and all dimensions are summed to one. By performing forward inference on the entire simulated information interaction task sequence time step by time, a set of target action probability distribution vector sequences arranged by time index can be obtained, which is used as a supervision signal.

[0078] After obtaining the output of the fusion-guided policy model, the system repeats the same input process for each candidate agent model in the policy ecosystem set, inputting the same batch of simulated information interaction task sequences into the candidate agent model for forward inference. At each decision point, the candidate agent model also outputs a current predicted action probability distribution vector, covering the same action space as the fusion-guided policy model. By aligning the two probability distribution vectors at the same time step and for the same task sample, it ensures that subsequent calculations target the same task state and action set, thus making the difference quantification comparable.

[0079] When quantifying the difference in decision logic between two models, the system calculates the relative entropy divergence value between the target action probability distribution vector and the current predicted action probability distribution vector for each time step and each task sample. The relative entropy divergence value can be obtained by summing the probability values ​​of all action dimensions. For example, using the target action probability as the weight, the system takes the logarithm of the ratio of the target probability to the predicted probability and calculates a weighted sum, resulting in a non-negative real number used to measure the deviation of the candidate agent model from the fused guidance policy model. For a batch of samples, the relative entropy divergence values ​​of all time steps and all task samples can be averaged or weighted to form an overall difference index for training.

[0080] After obtaining the relative entropy divergence value, the system constructs a loss function aimed at minimizing this difference index. The loss function can directly use the average of the relative entropy divergence values ​​within a batch, or it can add a regularization term to the relative entropy to constrain the norm of the candidate agent model parameters or encourage the output distribution entropy to remain within a reasonable range. The dependence of the loss function on the model parameters is implicitly reflected through the network structure of the candidate agent model; therefore, it is necessary to differentiate the parameters of each layer in the network. By enabling an automatic differentiation mechanism in the candidate agent model, the gradient can be calculated layer by layer along the network computation graph, starting from the loss function, to obtain the gradient value of each parameter tensor in the current batch.

[0081] After obtaining the gradient, the system updates the parameters of the candidate agent model according to a preset optimization strategy. An independent optimizer instance can be configured for each model. In each training round, the learning rate is used as a scaling factor, the gradient is multiplied by the negative learning rate and accumulated into the current parameters, achieving adjustment in the gradient descent direction. To improve training stability, mechanisms such as momentum terms, adaptive learning rate adjustment, and gradient pruning can be introduced to smooth or truncate the gradient, preventing parameter oscillations or divergence during updates. After each batch training round, the system recalculates the new relative entropy divergence value and compares it with the preset convergence criteria.

[0082] Convergence criteria can be set in various ways. For example, they can require the relative entropy divergence value of the most recent training epochs to be lower than a predetermined threshold, or the relative entropy change between two adjacent epochs to be lower than a certain proportion. The maximum number of training epochs can also be set as an upper bound. When the convergence criteria are met, the current candidate agent model is marked as the candidate agent model with updated parameters, and knowledge distillation training is no longer performed at this stage. Other candidate agent models in the policy ecosystem can be aligned with the fusion-guided policy model in the same way. For different types of candidate agent models, parameter updates can be completed in parallel within the same training framework, thereby achieving an overall improvement in policy behavior within the entire set and convergence towards a unified supervision goal.

[0083] This embodiment preserves fine-grained information about the relative preferences of the fusion-guided policy model for each action through a training process with soft distribution as the supervision target. It also controls the timing of training termination by using convergence conditions. This reduces training instability while improving the overall consistency and decision quality of the models within the policy ecosystem, providing a higher starting point for subsequent collaborative evolution on more difficult tasks.

[0084] In one embodiment, step S60 above includes: S601, parse the action sequence structure of the decision action trajectory, and detect whether there is a dead loop mode in the action sequence structure where the action state repeats or a timeout mode where the number of operation steps exceeds a preset threshold. S602, the decision action trajectory containing the infinite loop mode or the timeout mode is determined as the trajectory that leads to execution failure; S603, extract the final task conclusion output by the decision action trajectory, compare the semantic consistency of the final task conclusion with the preset standard verification answer in the simulated information interaction task sequence, and determine the decision action trajectory that fails the comparison as the trajectory that leads to the error in the result; S604, the trajectories that are determined to cause execution failure and the trajectories that are determined to cause result errors are regarded as failure cases, and the failure cases are associated with the corresponding error type tags and stored in the database to build a failure case library.

[0085] In this embodiment, the decision action trajectory can be understood as a complete record of the agent's behavior during a simulated information interaction task, from receiving the task to giving the final task conclusion. It is typically stored as a chronological sequence of events. The action sequence structure can be implemented using an array or a linked list, with each element bound to an action state, including fields such as action type flag, action input content, action trigger timestamp, and environmental feedback flag. By performing structured parsing of the decision action trajectory, an action sequence structure that facilitates traversal and pattern detection can be obtained, providing a foundation for subsequent error pattern recognition.

[0086] In the action sequence structure, it is necessary to identify infinite loop patterns where action states repeat repeatedly. In implementation, a sub-sequence signature can be constructed for each time window. For example, the action type and key parameters of several consecutive steps can be encoded into hash values, and the recurrence of the same signature can be checked throughout the entire action sequence structure. When the same action sub-sequence is detected to appear multiple times in the trajectory in the same order, and the corresponding environmental feedback does not indicate task completion or state progression, an infinite loop pattern of repeated action states can be determined. Alternatively, a finite state automaton can be used to detect cyclical paths in the state transition graph that return to earlier states but lack effective progress, thereby capturing repetitive patterns with longer spans.

[0087] In addition to infinite loops, the system also needs to detect timeout patterns where the number of operation steps exceeds a preset threshold. During the configuration phase, the system sets operation step thresholds for different task categories. These thresholds can be determined based on historical execution statistics or business requirements; for example, a lower upper limit can be set for simple fact queries, while a higher upper limit can be set for multi-round inference tasks. When traversing the action sequence structure, the system counts the actions from the start of the task to the current state in a single decision action trajectory. When the count exceeds the preset threshold for the corresponding task type and no task end marker or valid intermediate conclusion is generated, the trajectory is determined to have entered a timeout mode. Infinite loop and timeout modes can be recorded separately for their hit locations and the involved action intervals, which can be used later to locate problematic segments.

[0088] After the above detection is completed, decision-making action trajectories exhibiting infinite loop or timeout patterns are uniformly marked as trajectories that led to execution failure. Execution failure here refers to the agent's inability to effectively advance the task during operation, such as repeatedly accessing the same information source, repeatedly issuing approximate queries, or continuously executing invalid operations, resulting in excessive resource consumption without generating valuable output. When recording, the system creates a failure record entry for each failed trajectory, with fields including trajectory identifier, failure category, the action index range at the time of failure, and the associated task identifier, facilitating correlation analysis with other information.

[0089] For decision action trajectories that did not trigger the execution failure flag, it is also necessary to check whether there are any errors in the output content. To this end, the process extracts the final task conclusion from the end of each decision action trajectory. This conclusion can be natural language response text or structured decision data, such as multi-field judgments, label sets, or numerical ranges. During the simulated information interaction task sequence generation phase, a standard verification answer can be configured for each task. This standard verification answer is obtained from authoritative data sources or manually annotated data that has been reviewed, covering the factual conclusions, key rationale points, or acceptable numerical ranges corresponding to the task.

[0090] To compare the consistency between the final task conclusion and the standard verification answer, a semantic consistency comparison mechanism is introduced. In practice, the text at both ends is semantically encoded, and vector representations are obtained using a pre-trained language model. The similarity between the vectors is then calculated, and a comprehensive judgment is made based on rules such as keyword matching, numerical comparison, and entity verification. If the similarity is below a threshold, or if conflicts occur in fields such as key entity names, time ranges, or monetary ranges, the final task conclusion of the current decision-making trajectory is determined to be inconsistent with the standard verification answer, and from a result perspective, it belongs to a trajectory that leads to an incorrect result. For structured output, each field can be checked to see if it falls into a predefined legal set or allowed range; if any discrepancies exist, it is also considered an incorrect result.

[0091] After identifying two types of trajectories—execution failure and result error—a set of failure cases needs to be constructed. For each trajectory determined to have caused execution failure, the system packages the original action sequence structure, the location of the failure, task context information, and failure-related statistical data into a single failure case, based on the decision action trajectory itself. For each trajectory determined to have caused a result error, the system similarly uses the complete decision action trajectory as the main body, along with the final task conclusion, standard verification answer fragment, semantic consistency comparison score, and conflict field information, forming another type of failure case.

[0092] To facilitate subsequent retrieval and differentiation of differences, each failed case needs to be labeled with an error type tag. Error type tags can use a hierarchical coding method; for example, an infinite loop pattern can be labeled "Execution Failure - Infinite Loop," a timeout pattern can be labeled "Execution Failure - Timeout," an answer conflicting with facts can be labeled "Result Error - Fact Deviation," and a missing key reason can be labeled "Result Error - Missing Reason," etc. Each failed case should be associated with at least one error type tag, and multiple error tags can also be recorded for the same case to reflect situations where both process anomalies and result deviations exist simultaneously during execution.

[0093] All failure cases are written to the database through a unified data access interface. The storage structure can employ a document-oriented database to store trajectory content, supplemented by relational or vector indexes for rapid querying based on error type, task topic, and semantic content. The database is indexed by error type labels, task categories, time windows, and other dimensions, enabling subsequent components to extract failure case sets with specific patterns as needed. By continuously accumulating failure case data from different periods and candidate agent models, the failure cases in the database gradually form a stable failure case library, becoming a centralized resource directly usable in subsequent training and evaluation phases.

[0094] Through the above steps, this embodiment not only characterizes the specific location and form of failure at the behavioral sequence granularity, but also provides a searchable error pattern perspective at the result output level, providing a reliable data foundation and operable entry point for subsequent training set construction, performance diagnosis and strategy improvement based on failure samples.

[0095] In one embodiment, a task processing apparatus based on model iterative breeding is provided, which corresponds one-to-one with the task processing method based on model iterative breeding described in the above embodiments. (Refer to...) Figure 3 , Figure 3This is a schematic diagram of the functional modules of a preferred embodiment of the task processing device based on model iterative training according to the present invention. The modules include a task generation module 10, a parallel execution module 20, a quality analysis module 30, a strategy fusion module 40, a parameter update module 50, a failure case construction module 60, a targeted reinforcement training module 70, an iterative training module 80, and a task execution module 90. Detailed descriptions of each functional module are as follows: The task generation module 10 is used to generate a sequence of simulated information interaction tasks with progressive difficulty gradients based on preset task complexity dimension parameters. The parallel execution module 20 is used to input the simulated information interaction task sequence into a policy ecosystem set containing multiple candidate intelligent agent models, control each candidate intelligent agent model to execute the simulated information interaction task sequence in parallel and independently, and obtain the decision action trajectory generated during the execution process. The quality analysis module 30 is used to analyze each decision node in the decision action trajectory through a multi-dimensional quality analysis model, and to select and identify elite decision segments that meet the preset performance standards from all decision nodes included in the decision action trajectory based on the analysis results. The strategy fusion module 40 is used to logically splice and fuse elite decision fragments from different candidate agent models to generate a fused guided strategy model. The parameter update module 50 is used to update the parameters of all candidate agent models in the policy ecosystem set by using the fusion guidance strategy model as the supervision target. The failure case construction module 60 is used to extract failure cases that lead to execution failure or incorrect results from the decision action trajectory and construct a failure case library. The targeted reinforcement training module 70 is used to generate a targeted reinforcement training set based on the failure case library, and control the candidate agent model after parameter update to perform repeated iterative training on the targeted reinforcement training set to obtain the evolved agent model. The cyclic breeding module 80 is used to re-use the evolved agent model as the candidate agent model, return to execute the step of generating a sequence of simulated information interaction tasks with progressive difficulty gradients, perform multiple rounds of cyclic breeding until the preset training termination condition is met, and obtain the optimized agent model. The task execution module 90 is used to process the target task through the optimized agent model and generate the target task processing result.

[0096] For preferred embodiments of the task processing device based on model cyclic breeding, please refer to the foregoing limitations of the task processing method based on model cyclic breeding, which will not be repeated here. Each module in the aforementioned task processing device based on model cyclic breeding can be implemented entirely or partially through software, hardware, or a combination thereof. These modules can be embedded in or independent of the processor in a computer device in hardware form, or stored in the memory of a computer device in software form, so that the processor can call and execute the operations corresponding to each module.

[0097] In one embodiment, a computer device is provided, which may be a server, and its internal structure diagram may be as follows: Figure 4 As shown, the computer device includes a processor, memory, network interface, and database connected via a system bus. The processor provides determination and control capabilities. The memory includes non-volatile and / or volatile storage media and internal memory. The non-volatile storage media stores the operating system, computer programs, and database. The internal memory provides an environment for the operation of the operating system and computer programs in the non-volatile storage media. The network interface is used to communicate with external clients via a network connection. When the computer program is executed by the processor, it implements the functions or steps of a model-based iterative task processing method on the server side.

[0098] In one embodiment, a computer device is provided, which may be a client, and its internal structure diagram may be as follows: Figure 5 As shown, the computer device includes a processor, memory, network interface, display screen, and input devices connected via a system bus. The processor provides determination and control capabilities. The memory includes non-volatile storage media and internal memory. The non-volatile storage media stores the operating system and computer programs. The internal memory provides an environment for the operation of the operating system and computer programs in the non-volatile storage media. The network interface is used to communicate with an external server via a network connection. When the computer program is executed by the processor, it implements client-side functions or steps of a model-based iterative task processing method.

[0099] In one embodiment, a computer device is provided, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to perform the following steps: Based on the preset task complexity dimension parameters, a sequence of simulated information interaction tasks with progressive difficulty gradients is generated; The simulated information interaction task sequence is input into a policy ecosystem set containing multiple candidate intelligent agent models. Each candidate intelligent agent model is controlled to execute the simulated information interaction task sequence in parallel and independently, and the decision action trajectory generated during the execution process is obtained. Each decision node in the decision action trajectory is analyzed using a multi-dimensional quality analysis model, and elite decision segments that meet preset performance standards are selected and identified from all decision nodes included in the decision action trajectory based on the analysis results. Elite decision fragments from different candidate agent models are logically spliced ​​and fused to generate a fused guidance strategy model; Using the fusion-guided strategy model as the supervision target, the parameters of all candidate agent models in the strategy ecosystem set are updated. Extract failure cases that lead to execution failure or incorrect results from the decision-making action trajectory, and construct a failure case library; Based on the failure case library, a targeted reinforcement training set is generated. The candidate agent model with updated parameters is controlled to perform repeated iterative training on the targeted reinforcement training set to obtain the evolved agent model. The evolved agent model is used again as the candidate agent model, and the step of generating a sequence of simulated information interaction tasks with progressive difficulty gradients is returned to be executed. Multiple rounds of cyclical training are carried out until the preset training termination condition is met, and an optimized agent model is obtained. The optimized agent model is used to process the target task and generate the target task processing result.

[0100] In one embodiment, a computer-readable storage medium is provided, which may be non-volatile or volatile, and a computer program is stored thereon, which, when executed by a processor, performs the following steps: Based on the preset task complexity dimension parameters, a sequence of simulated information interaction tasks with progressive difficulty gradients is generated; The simulated information interaction task sequence is input into a policy ecosystem set containing multiple candidate intelligent agent models. Each candidate intelligent agent model is controlled to execute the simulated information interaction task sequence in parallel and independently, and the decision action trajectory generated during the execution process is obtained. Each decision node in the decision action trajectory is analyzed using a multi-dimensional quality analysis model, and elite decision segments that meet preset performance standards are selected and identified from all decision nodes included in the decision action trajectory based on the analysis results. Elite decision fragments from different candidate agent models are logically spliced ​​and fused to generate a fused guidance strategy model; Using the fusion-guided strategy model as the supervision target, the parameters of all candidate agent models in the strategy ecosystem set are updated. Extract failure cases that lead to execution failure or incorrect results from the decision-making action trajectory, and construct a failure case library; Based on the failure case library, a targeted reinforcement training set is generated. The candidate agent model with updated parameters is controlled to perform repeated iterative training on the targeted reinforcement training set to obtain the evolved agent model. The evolved agent model is used again as the candidate agent model, and the step of generating a sequence of simulated information interaction tasks with progressive difficulty gradients is returned to be executed. Multiple rounds of cyclical training are carried out until the preset training termination condition is met, and an optimized agent model is obtained. The optimized agent model is used to process the target task and generate the target task processing result.

[0101] It should be noted that the functions or steps that can be implemented by the computer-readable storage medium or computer device described above can be referred to the relevant descriptions on the server side and client side in the foregoing method embodiments. To avoid repetition, they will not be described one by one here.

[0102] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a non-volatile computer-readable storage medium. When executed, the computer program can include the processes of the embodiments of the above methods. Any references to memory, storage, databases, or other media used in the embodiments provided in this application can include non-volatile and / or volatile memory. Non-volatile memory can include read-only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM), or flash memory. Volatile memory can include random access memory (RAM) or external cache memory. By way of illustration and not limitation, RAM is available in various forms, such as static RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), dual data rate SDRAM (DDRSDRAM), enhanced SDRAM (ESDRAM), synchronous link DRAM (SLDRAM), Rambus direct RAM (RDRAM), direct memory bus dynamic RAM (DRDRAM), and memory bus dynamic RAM (RDRAM), etc.

[0103] It should be noted that if any software tools or components not belonging to this company appear in the embodiments of this application, they are merely illustrative examples and do not represent actual use. The embodiments described above are only used to illustrate the technical solutions of the present invention, and not to limit them; although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features; and these modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of the present invention, and should all be included within the protection scope of the present invention.

[0104] The user personal information involved in this application embodiment is all authorized (knowing and consenting) by the relevant parties or fully authorized by all parties, and the executing entity can obtain it through various open, legal and compliant means. The collection, storage, use, processing, transmission, provision and disclosure of the information, data and signals involved all comply with the relevant laws and regulations of the relevant countries and regions, and do not violate public order and good morals.

Claims

1. A task processing method based on model cyclic breeding, characterized in that, Includes the following steps: Based on the preset task complexity dimension parameters, a sequence of simulated information interaction tasks with progressive difficulty gradients is generated; The simulated information interaction task sequence is input into a policy ecosystem set containing multiple candidate intelligent agent models. Each candidate intelligent agent model is controlled to execute the simulated information interaction task sequence in parallel and independently, and the decision action trajectory generated during the execution process is obtained. Each decision node in the decision action trajectory is analyzed using a multi-dimensional quality analysis model, and elite decision segments that meet preset performance standards are selected and identified from all decision nodes included in the decision action trajectory based on the analysis results. Elite decision fragments from different candidate agent models are logically spliced ​​and fused to generate a fused guidance strategy model; Using the fusion-guided strategy model as the supervision target, the parameters of all candidate agent models in the strategy ecosystem set are updated. Extract failure cases that lead to execution failure or incorrect results from the decision-making action trajectory, and construct a failure case library; Based on the failure case library, a targeted reinforcement training set is generated. The candidate agent model with updated parameters is controlled to perform repeated iterative training on the targeted reinforcement training set to obtain the evolved agent model. The evolved agent model is used again as the candidate agent model, and the step of generating a sequence of simulated information interaction tasks with progressive difficulty gradients is returned to be executed. Multiple rounds of cyclical training are carried out until the preset training termination condition is met, and an optimized agent model is obtained. The optimized agent model is used to process the target task and generate the target task processing result.

2. The task processing method based on model iterative cultivation as described in claim 1, characterized in that, Based on preset task complexity dimension parameters, a sequence of simulated information interaction tasks with progressive difficulty gradients is generated, including: The preset task complexity dimension parameters are initialized as a multi-dimensional vector containing the logical reasoning chain length, the information source ambiguity index, the required number of reasoning steps, and the interference information density. Using the task complexity dimension parameter set to the minimum complexity, a single-step fact query task instance is constructed that can obtain a deterministic answer in just one retrieval. The logical reasoning chain length, information source ambiguity index, required reasoning steps, and interference information density are incrementally adjusted according to a preset gradient growth step size to generate a set of advanced complexity parameters at multiple levels. Based on the aforementioned advanced complexity parameter set, a multi-source contradiction verification task instance is synthesized that requires comparing contradictory content from at least two heterogeneous information sources to reach a conclusion. Following the progressive difficulty gradient, the single-step fact query task instance is used as the starting node, and the multi-source contradiction verification task instance is used as the subsequent node, and the simulated information interaction task sequence is generated by arranging and combining them in sequence.

3. The task processing method based on model iterative cultivation as described in claim 1, characterized in that, The simulated information interaction task sequence is input into a policy ecosystem set containing multiple candidate agent models. Each candidate agent model is controlled to execute the simulated information interaction task sequence in parallel and independently, and the decision action trajectory generated during the execution process is obtained, including: Heterogeneous initialization of the strategy ecosystem set is performed, and the candidate intelligent agent model is configured to include strategy models with multiple functional specializations. The strategy models include, but are not limited to, a first type of search strategy model that focuses on the breadth of information retrieval and a second type of analysis strategy model that focuses on the depth of logical reasoning. Each candidate agent model in the policy ecosystem is assigned a mutually isolated independent running container, and the simulated information interaction task sequence is broadcast and distributed to all the independent running containers; Trigger all candidate agent models in the independently running containers to start parallel processing processes, and execute the simulated information interaction task sequence in parallel and independently in a processing environment where they do not interfere with each other; The system intercepts and records the search query statements, web page browsing sequences, intermediate reasoning thought chains, and final output conclusions of each candidate intelligent agent model during execution in real time, and encapsulates them in timestamp order to form a decision action trajectory.

4. The task processing method based on model iterative cultivation as described in claim 1, characterized in that, Each decision node in the decision-making action trajectory is analyzed using a multi-dimensional quality analysis model. Based on the analysis results, elite decision segments that meet preset performance standards are selected and identified from all decision nodes included in the decision-making action trajectory, including: The decision action trajectory is analyzed in chronological order and decomposed into multiple independent single-step decision nodes. Each single-step decision node corresponds to a query input operation, an information browsing operation, or a logical reasoning operation. A multi-dimensional quality analysis model is invoked to quantify the answer accuracy score, step efficiency score, and behavior rationality score for each of the single-step decision nodes. Based on preset dimension weight coefficients, the answer accuracy score, the step efficiency score, and the behavior rationality score of each single-step decision node are weighted and summed to generate a comprehensive performance score for each single-step decision node. Iterate through all single-step decision nodes and compare the overall performance score of each single-step decision node with the performance threshold in the preset performance standard; Single-step decision nodes whose overall performance score reaches or exceeds the performance threshold are marked as elite decisions, and a sequence of elite decision nodes in chronological order is defined as an elite decision segment.

5. The task processing method based on model iterative cultivation as described in claim 1, characterized in that, Elite decision fragments from different candidate agent models are logically concatenated and fused to generate a fused guidance strategy model, including: The decision logic and applicable conditions of each elite decision segment from different candidate agent models are analyzed to obtain the set of logical features of each elite decision segment; Based on the set of logical features, identify the logical conflict points and complementary points between different elite decision-making segments, and generate a conflict-complement relationship diagram. According to the preset conflict resolution strategy, the logical conflict points existing in the conflict complementarity relationship diagram are coordinated and processed to obtain a coordinated set of elite decision fragments. The coordinated set of elite decision fragments is spliced ​​and integrated according to the task execution logic to form a spliced ​​and integrated decision logic flowchart; The assembled decision logic flowchart is encoded into an executable strategy model to generate a fusion guidance strategy model.

6. The task processing method based on model iterative cultivation as described in claim 1, characterized in that, Using the fusion-guided strategy model as the supervision target, the parameters of all candidate agent models in the strategy ecosystem set are updated, including: The simulated information interaction task sequence is loaded as input data into the fusion guidance strategy model to obtain the target action probability distribution vector output by the fusion guidance strategy model for the simulated information interaction task sequence. The simulated information interaction task sequence is input into the candidate agent model in the policy ecosystem set to obtain the current predicted action probability distribution vector output by the candidate agent model; Determine the relative entropy divergence value between the target action probability distribution vector and the current predicted action probability distribution vector to quantify the difference in decision logic between the candidate agent model and the fusion guidance strategy model; A loss function is constructed with the objective of minimizing the relative entropy divergence value. The gradient is determined using the backpropagation algorithm based on the loss function, and the parameters of the candidate agent model are updated based on the gradient until the relative entropy divergence value meets the preset convergence condition, thus obtaining the candidate agent model with updated parameters.

7. The task processing method based on model cyclic breeding as described in claim 1, characterized in that, From the decision-making action trajectory, extract failure cases that led to execution failure or incorrect results, and construct a failure case library, including: The action sequence structure of the decision action trajectory is analyzed, and the action sequence structure is checked to see if there is a dead loop pattern of repeated action state or a timeout pattern of operation steps exceeding a preset threshold. The decision action trajectory containing the aforementioned infinite loop pattern or timeout pattern is identified as the trajectory that leads to execution failure; Extract the final task conclusion output by the decision action trajectory, compare the semantic consistency of the final task conclusion with the preset standard verification answer in the simulated information interaction task sequence, and determine the decision action trajectory that fails the comparison as the trajectory that leads to the error. Trajectories deemed to cause execution failure and those deemed to cause incorrect results are identified as failure cases. These failure cases are then associated with corresponding error type tags and stored in the database to construct a failure case library.

8. A task processing device based on model cyclic breeding, characterized in that, The task processing device based on model-based cyclic breeding includes: The task generation module is used to generate a sequence of simulated information interaction tasks with progressive difficulty gradients based on preset task complexity dimension parameters. The parallel execution module is used to input the simulated information interaction task sequence into a policy ecosystem set containing multiple candidate agent models, control each candidate agent model to execute the simulated information interaction task sequence in parallel and independently, and obtain the decision action trajectory generated during the execution process. The quality analysis module is used to analyze each decision node in the decision action trajectory through a multi-dimensional quality analysis model, and to select and identify elite decision segments that meet the preset performance standards from all decision nodes included in the decision action trajectory based on the analysis results. The strategy fusion module is used to logically splice and fuse elite decision fragments from different candidate agent models to generate a fused guided strategy model. The parameter update module is used to update the parameters of all candidate agent models in the policy ecosystem set by using the fusion guidance strategy model as the supervision target. The failure case construction module is used to extract failure cases that lead to execution failure or incorrect results from the decision action trajectory and build a failure case library. The targeted reinforcement training module is used to generate a targeted reinforcement training set based on the failure case library, and control the candidate agent model after parameter update to perform repeated iterative training on the targeted reinforcement training set to obtain the evolved agent model. The iterative nurturing module is used to re-use the evolved agent model as the candidate agent model, return to the step of generating a sequence of simulated information interaction tasks with progressive difficulty gradients, perform multiple rounds of iterative nurturing until the preset training termination condition is met, and obtain the optimized agent model. The task execution module is used to process the target task through the optimized agent model and generate the target task processing result.

9. A computer device, characterized in that, The computer device includes a memory, a processor, and a model-based cyclic breeding task processing program stored in the memory and executable on the processor, wherein the model-based cyclic breeding task processing program, when executed by the processor, implements the steps of the model-based cyclic breeding task processing method as described in any one of claims 1-7.

10. A computer-readable storage medium, characterized in that, The storage medium stores a task processing program based on model cyclic breeding, which, when executed by a processor, implements the steps of the task processing method based on model cyclic breeding as described in any one of claims 1-7.

Images