An artificial intelligence based software driven processing system

Abstract

The application relates to the field of artificial intelligence and software engineering, and particularly relates to a software driving processing system based on artificial intelligence. The system comprises an intention perception module, a capability dynamic assembly engine and an execution and feedback module. The intention perception module is used for converting original input into a structured intention description. The capability dynamic assembly engine maintains a capability library composed of standardized capability atoms, and dynamically screens and arranges the atoms based on the intention description to generate a non-preset task workflow. The execution and feedback module drives the workflow execution and collects feedback information to optimize the previous modules. The application formalizes user intention into a resolvable graph structure, and drives the dynamic discovery, evaluation and combination of standardized function units based on the graph structure, realizes on-demand and instant construction and closed-loop self-optimization of a processing flow, and effectively improves the intelligent level and adaptability of a software system in processing complex and dynamic tasks.

Description

Technical Field

[0001] This invention relates to the fields of artificial intelligence and software engineering, and more specifically, to a software-driven processing system based on artificial intelligence. Background Technology

[0002] With the deepening application of artificial intelligence technology in various fields, the tasks that software systems need to handle are becoming increasingly complex and dynamic. Traditional software architectures with pre-defined processes often exhibit rigidity and insufficient adaptability when faced with users' ambiguous, changing, or cross-domain complex needs.

[0003] Currently, most mainstream software processing systems adopt fixed-process driven or modular architectures. In fixed-process driven systems, business logic is pre-coded into a predetermined execution sequence, making its processing logic rigid and difficult to adapt to changes in requirements or unforeseen anomalies in the process. In modular systems, although some flexibility is provided by piecing together functional modules, the calling relationships and data interfaces between modules usually still need to be statically defined during development, resulting in high expansion costs and slow response speeds when facing new task types. More importantly, existing systems generally lack the ability to deeply analyze and formally model high-level user intent, and also lack mechanisms to dynamically and automatically organize underlying functional modules based on real-time intent. This results in limited system intelligence, requiring users to adapt to the system's fixed capabilities through complex configurations or multiple interactions.

[0004] Therefore, to address the above problems, an AI-based software-driven processing system is proposed. To solve these problems, a software system architecture is provided that can automatically transform unstructured user requirements into explicit and executable task blueprints, and dynamically schedule and combine internal functional units of the system to complete the blueprints. Summary of the Invention

[0005] In order to overcome the above-mentioned defects of the prior art, embodiments of the present invention provide a software-driven processing system based on artificial intelligence to solve the problems mentioned in the background art.

[0006] To achieve the above objectives, the present invention provides the following technical solution: a software-driven processing system based on artificial intelligence, characterized in that it comprises: The intent perception module is used to receive raw input and convert the raw input into a structured intent description through an artificial intelligence parsing model. The intent description includes task objectives, logical relationships between sub-objectives, and execution constraints, thereby transforming unstructured user needs into a clear task blueprint that can be parsed and processed by the machine. The capability dynamic assembly engine, connected to the intent perception module, is used to maintain a capability library consisting of multiple capability atoms with standardized description files. Based on the received structured intent description, it dynamically selects multiple target capability atoms from the capability library and arranges the multiple target capability atoms into a non-preset task workflow. This arrangement process is based on the logical structure of the intent and the interface contract between the atoms, realizing the on-demand and real-time construction of the processing flow. The system also includes an execution and feedback module, which is connected to the capability dynamic assembly engine to drive the execution of the task workflow, monitor the execution process, and collect feedback information. The feedback information is transmitted to the intent perception module and the capability dynamic assembly engine, thereby forming a closed-loop optimization system from intent parsing and capability assembly to execution verification.

[0007] Furthermore, the structured intent description is a hierarchical directed acyclic graph (DAG) data. The nodes of the DAG data represent task objectives or constraints, and the directed edges of the DAG data represent dependencies, temporal relationships, or conditional logical relationships between objectives. This graph structure can formally express the decomposition hierarchy and execution logic of complex tasks, providing a precise topological basis for subsequent process assembly.

[0008] Furthermore, when generating the structured intent description, the intent perception module performs a logical conflict resolution process. This process identifies contradictions in resources, logic, or timing among multiple task elements extracted from the original input, and automatically adjusts these contradictions based on preset conflict resolution rules or through analogy with historical cases to ensure that the generated intent description is logically self-consistent and has an executable basis.

[0009] Furthermore, the standardized description file for each capability atom in the capability library includes a function identifier, a function semantic vector, an input data pattern, an output data pattern, an execution precondition declaration, and strategy parameters representing non-functional attributes. The strategy parameters include estimated execution time, resource consumption range, and tolerance threshold for input data defects. This standardized description method enables atomic functions to be uniformly understood, discovered, and measured by machines, which is a prerequisite for realizing dynamic combination.

[0010] Furthermore, the process by which the capability dynamic assembly engine dynamically filters and orchestrates target capability atoms based on the structured intent description includes: Calculate the similarity between the semantic vector of the task target node and the semantic vector of the capability atom function in the structured intent description, so as to screen out candidate capability atoms and achieve a preliminary match between functional requirements and functional supply. By combining the constraints in the structured intent description, the current resource status of the system, and the strategy parameters of the candidate capability atoms, the feasibility of the candidate capability atom combinations is verified and comprehensively evaluated to ensure that the final solution satisfies all constraints and is close to the optimal solution. Based on the results of the comprehensive evaluation and the logical relationships defined in the structured intent description, the task workflow is synthesized, which specifically defines the execution order of atoms and the data transfer path.

[0011] Furthermore, the comprehensive evaluation adopts a multi-objective optimization method, which simultaneously weighs the estimated total execution time of the task workflow, the overall resource consumption, the quality confidence of the output results, and the robustness of the execution path. By optimizing in a multi-dimensional objective space, the assembled workflow achieves a balance across multiple key performance indicators.

[0012] Furthermore, when the execution and feedback module drives the task workflow, it performs runtime data adaptation operations. When the output data of the upstream capability atom is inconsistent with the declared input mode of the downstream capability atom, it automatically calls the data converter to perform format conversion, field mapping, or content completion. This mechanism decouples the strict data format coupling between atoms and enhances the system's ability to handle heterogeneous data sources and improve compatibility between atoms.

[0013] Furthermore, when the execution and feedback module detects that the target capability atom fails to execute or the output deviates from the expected result during the execution process, it pauses the current task workflow and sends the error context, the generated intermediate data, and the unfinished task target subset to the capability dynamic assembly engine to trigger workflow replanning and assembly. This resilience mechanism enables the system to recover from local failures and attempt to continue to complete the core task target through alternative paths.

[0014] Furthermore, the intent perception module incrementally trains its artificial intelligence parsing model based on the assessment of the accuracy of intent understanding in the feedback information, enabling the model to continuously adapt to new expression methods and task types; the capability dynamic assembly engine dynamically updates the strategy parameters of each capability atom in the capability library and its association weight in semantic matching based on the data on the actual performance of capability atoms and workflow execution effects in the feedback information, so that the system's decision knowledge base can continuously evolve and optimize in actual operation.

[0015] Furthermore, the system provides a capability atom registration interface, which allows external functional modules to be encapsulated as capability atoms conforming to the standardized description file specification and registered to the capability library through hot deployment or cold deployment. This open extension mechanism enables the system's processing capabilities to be flexibly enhanced and customized without modifying the architecture and logic of the core engine.

[0016] The technical effects and advantages of this invention are as follows: This invention, by introducing an intent-aware module and structured intent description, first transforms user-input natural language or unstructured instructions into a machine-parseable graph structure containing the target, sub-targets, and their logical relationships. The system uses this structured task blueprint, rather than a fixed code path, to guide subsequent processing. This enables the system to formally understand complex, multi-layered user needs, providing precise input for dynamic process construction, thereby enhancing the system's semantic understanding and adaptability to diverse and dynamically changing tasks.

[0017] To address the issues of rigid composition and poor compatibility caused by tight coupling between components and strict data format requirements in existing modular systems, this invention defines capability atoms with standardized description files and a runtime data adaptation mechanism. Each capability atom is described through a declarative file containing functional semantics, input / output patterns, and non-functional strategies, enabling the system to uniformly discover and evaluate them. During execution, when data interfaces between atoms do not fully match, the system can automatically invoke a converter for adaptation. This approach reduces the coupling between components at both the interface contract and runtime levels, making the reuse and composition of functional units more flexible and automated, and effectively integrating heterogeneous functional modules to handle complex task flows.

[0018] This invention constructs a closed-loop system that includes execution monitoring and feedback, and establishes an open capability atomic registration interface. Feedback information is used to continuously optimize the accuracy of intent parsing and the strategy for capability combination, while the open interface allows new functions to be easily integrated into the system. This enables the system to not only continuously adjust and improve its decision-making quality based on actual results during operation, achieving incremental optimization, but also to rapidly expand its capability boundaries in a non-intrusive manner. Attached Figure Description

[0019] Figure 1 This is a flowchart illustrating the overall system workflow of the present invention.

[0020] Figure 2 This is a flowchart illustrating the implementation of the capability dynamic assembly engine of the present invention. Detailed Implementation

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

[0022] As attached Figures 1 to 2The system described is a software-driven processing system based on artificial intelligence. This system constructs a three-layer cascaded intelligent software architecture to realize a closed loop of the entire process from understanding user intent to automatic task execution.

[0023] The first layer is the intent-aware module, which transforms unstructured raw requests (such as natural language commands) input by users or external systems into a precise and machine-processable structured task representation. The second layer is the capability dynamic assembly engine, which maintains a resource library of standardized, encapsulated functional units (called capability atoms) and dynamically constructs an executable task workflow based on the task representation output from the first layer through a series of optimization decisions. The third layer is the execution and feedback module, responsible for reliably running the workflow, monitoring the entire execution process, collecting performance and result data, generating feedback information, and sending it back to the first two layers to achieve continuous self-optimization of the system. The collaborative work of these three modules enables the system to handle complex, dynamic task requirements that are not pre-programmed.

[0024] Furthermore, this structured task representation is specifically implemented as a directed acyclic graph with hierarchical relationships. Each node in the graph is a data structure that contains a unique node identifier, node type (distinguishing between "target" and "constraint"), semantic content description (text and corresponding semantic vector), and attributes such as confidence level.

[0025] Directed edges between nodes explicitly record the type of relationship between the two nodes, such as "dependency", "sequential predecessor", "conditional triggering" or "data flow direction".

[0026] For example, for a request to "generate a quarterly financial report", the graph may contain a root node "generate report", which is decomposed into sub-nodes such as "get raw data", "perform financial analysis", "create visualization charts" and "arrange documents", and a "dependency" relationship edge is established between the "perform financial analysis" and "get raw data" nodes.

[0027] This graph structure depicts the inherent decomposition logic and execution topology of the task, providing unambiguous input for subsequent automated planning.

[0028] Furthermore, the intent-aware module integrates an automated logical conflict detection and resolution mechanism during the construction of the aforementioned intent map. This mechanism ensures that the generated task blueprint is semantically consistent with user input and logically self-consistent and actionable. The system has a built-in configurable conflict rule base, with rules defined in a "condition-action" format. For example, a rule might be defined as: if two task nodes are detected to both declare that they need to exclusively occupy the same resource and there is no explicit execution order, then they are marked as "resource conflict".

[0029] Upon detecting a conflict, the conflict resolution engine first attempts to apply preset strategies for automatic adjustment, such as automatically inserting sequence constraints based on task priority. If the automatic strategy fails to resolve the conflict or if the conflict involves multiple feasible paths, the system constructs a structured interactive clarification request, submitting feasible resolution options (such as "execute A then B sequentially" or "allocate alternative resource C to task B") to the user or a higher-level decision-making system for adjudication, and solidifying the adjudication result into the intent graph. This process explicitly incorporates implicit domain knowledge and constraints into the task definition phase.

[0030] Furthermore, all schedulable basic functions in the system are abstracted and encapsulated into capability atoms, adhering to a unified description specification. Each capability atom's description file is a machine-readable declarative document containing the following key sections: A functional semantic vector that maps atomic functional text descriptions to a pre-trained semantic model (such as a Transformer-based encoder). ; employing precisely defined input and output data schemas using a schema language (such as JSONSchema); and a series of non-functional strategy parameters, such as (Estimated time, unit: ms) (Maximum memory consumption, in MB) and (A tolerance threshold for missing values ​​in input data, such as 0.1 indicating that 10% missing values ​​are acceptable). This standardized description enables the system to discover, understand, and measure heterogeneous functional modules from different sources in a unified manner. In particular, functional semantic vectors allow the system to calculate the cosine similarity between vectors. This allows for the quantification of functional relevance, thereby enabling precise semantic-based matching.

[0031] Furthermore, the capability dynamic assembly engine maps a structured intent map into an executable workflow composed of concrete capability atomic instances. This process is a multi-stage constraint satisfaction and optimization search problem.

[0032] The first stage is semantic retrieval and candidate set generation: for each task node in the intent graph... The engine calculates its semantic vector. With all capability atomic function vectors Based on similarity, filter out those with similarity higher than a threshold. The atoms are selected as candidates, forming a candidate atom set for each node. .

[0033] The second stage is multi-constraint optimization: the engine formalizes the problem into a solution that addresses each constraint. Select one atom And determine the data connections between them to form a complete workflow. This workflow All logical dependency constraints in the intent diagram must be satisfied, while optimizing a function consisting of multiple objectives.

[0034] The objective function typically considers the estimated total execution time of the workflow. Total resource cost and the expected result quality score This can be expressed as solving ,in It is the set of all workflows that satisfy the hard constraints. The engine uses methods such as constraint programming combined with heuristic search or evolutionary algorithms to solve this multi-objective optimization problem.

[0035] The third stage is workflow instantiation: based on the optimal or near-optimal atom selection and connection scheme obtained from the solution, the engine generates an executable workflow description file containing complete control flow and data flow definitions.

[0036] Furthermore, the aforementioned multi-objective optimization process is not static, but can be dynamically adjusted based on the runtime context. The system maintains a set of dynamically loadable optimization strategy configuration files, each strategy defining a weight combination of different optimization objectives (such as time, cost, and quality). .

[0037] Different strategies can be applied depending on the business scenario or system state. For example, a cost-first strategy can be adopted during peak business periods. However, when handling time-sensitive tasks, it switches to a time-optimal strategy. This makes the optimization objective function behave as a weighted scalar function in actual execution: This context-aware optimization mechanism enables the system to flexibly make intelligent trade-offs across different dimensions to adapt to diverse service quality requirements.

[0038] Furthermore, to ensure reliable workflow operation in an environment composed of heterogeneous atoms, the execution and feedback module designs a transparent runtime data adaptation layer. This layer is responsible for resolving inconsistencies in data format, structure, or units between capability atoms. Internally, it maintains a lightweight, pluggable data converter registry, which registers micro-conversion functions such as field renaming mappers, date format normalizers, and numerical unit converters.

[0039] When the workflow engine needs to convert atoms The output data is passed to the atom At that time, the adapter layer will automatically compare atoms. The input mode of the declaration and the atom The actual output mode. If incompatibility is found, the adaptation layer will dynamically retrieve and combine the shortest and most efficient converter chain from the registry center based on type compatibility and semantic similarity, and automatically perform the conversion during data transfer. This mechanism decouples atomic implementation from integration logic. Atomic developers only need to ensure that their functions conform to their own interface contracts, enhancing the system's integration flexibility and atomic reusability.

[0040] Furthermore, this module implements a state-intact, resilient execution and recovery mechanism. During workflow execution, a specific capability atomic instance... The system will not fail completely if execution fails, times out, or produces invalid output. The execution controller immediately captures a snapshot of the system's consistent state, including verified output data for all successfully completed atoms and error information for the currently failing atom.

[0041] Subsequently, the controller identifies the faulty atom, the available intermediate data, and the incomplete subgraph derived from the original intent graph. This is encapsulated as a "replanning request" and sent back to the capability dynamic assembly engine. Based on this request, the engine reuses verified data and completes... To achieve this, initiate a local replanning process to quickly generate an alternative subworkflow that bypasses the failure point. The execution controller then recovers from the previous consistent snapshot, injects and executes the new alternative. This mechanism enables the system to automatically recover from partial failures, improving the end-to-end robustness of long-cycle, multi-step tasks.

[0042] Furthermore, the system achieves incremental improvements in performance and intelligence by constructing a continuous learning loop from execution feedback to model parameters. Fine-grained data generated during execution is systematically collected to form a feedback stream. For the intent-aware module, its underlying semantic parsing model periodically uses the "raw input-intent map" pairing data corresponding to successful tasks for incremental fine-tuning to continuously improve its understanding of new expressions and domain terminology.

[0043] For the capability dynamic assembly engine, feedback is mainly used for two purposes: first, to dynamically calibrate the non-functional policy parameters of capability atoms, for example, to update atoms using an exponential smoothing algorithm. Estimated time: ,in A smoothing factor (e.g., 0.1). The first factor is the actual execution time of the most recent execution of the atom, which makes the descriptive parameters increasingly closer to reality. The second is optimizing the decision-making model; for example, strengthening the association between atoms that repeatedly succeed in a specific task context and their corresponding intent nodes, thereby increasing their selection priority in similar future scenarios. This allows the system to accumulate experience, and the quality of decisions continuously evolves over time.

[0044] Furthermore, to support the open evolution of the system, a standardized interface for hot registration and discovery of capability atoms is provided. Any newly developed functional module only needs to encapsulate its implementation according to the aforementioned description specification (such as providing a Docker image or API endpoint information) and generate a corresponding description file to register with the system through this interface. The registration process is real-time and non-intrusive, and the metadata of the new atom, especially its functional semantic vector, is stored within it. These features will be instantly indexed into the semantic search space of the assembly engine. This means that new features can be immediately discovered, evaluated, and used to assemble new task workflows after successful registration, without interrupting existing services or modifying core system code.

[0045] Example 1 The following case study systematically illustrates the entire process of this system, from receiving user requests to delivering the final result. This process strictly adheres to the aforementioned modular design and demonstrates the data flow and decision-making logic at each stage.

[0046] Step S100: Raw input reception and preprocessing The system receives processing requests from external sources through a pre-defined general input interface. The request payload contains at least one unstructured target description field (such as a piece of text) and may optionally include contextual metadata. The input adapter of the intent-aware module first performs standardization validation on the payload to ensure data format compliance. Subsequently, basic preprocessing operations are performed on the target description field, including but not limited to: encoding normalization, irrelevant character filtering, and word segmentation based on a basic word segmentation tool. The output of this step is an internally unified request object that encapsulates the original description, context, and preprocessing results.

[0047] Step S101: Structured Intent Graph Construction and Logical Verification The core parsing model of the intent-aware module loads the request object output in step S100. This model is a trained artificial intelligence model capable of understanding the semantics of domain tasks (such as a sequence-to-graph model based on Transformer). The model takes the unstructured description of the request as input and, through its internal multi-layer attention mechanism, decodes and generates an initial graph-structured data with nodes and edges—that is, a structured intent graph. .

[0048] Node generation: The model identifies and creates nodes in the graph. Each node... Assigned a type property A semantic content extracted or inferred from the original description. and a numerical value representing the confidence level of that node. .

[0049] Edge generation: The model simultaneously infers the logical relationships between nodes and creates directed edges. Each edge is assigned a relation type attribute. It clearly defines the dependencies, timing, or conditional logic between nodes.

[0050] Next, the logical consistency checker within the module is activated. It iterates through... The system scans against a pre-loaded set of conflict rules. If a conflict is detected (e.g., circular dependencies or resource constraint contradictions), the validator triggers a resolution decision-maker. The resolution decision-maker attempts to generate a corrective solution based on a built-in policy library, potentially directly addressing... Automated corrections (such as adjusting edge relationships or inserting virtual coordinating nodes) may also generate a set of decision options requiring external intervention. Ultimately, the output is a logically consistent, final version of a structured intent map that can serve as a planning blueprint. .

[0051] Step S102: Capability Atom Matching Based on Semantic Vectors Capability dynamic assembly engine receives Its internal semantic matching service begins operation. This service maintains functional semantic vector indices for all registered capability atoms. For Each target type node in Perform the following operations: 1. Vectorization: Transforming the semantic content of nodes Transformed into query vectors using the same embedding model. .

[0052] 2. Similarity retrieval: In the vector index, for each capability atom Calculate its function vector With query vector cosine similarity .

[0053] 3. Candidate set generation: Based on a preset similarity threshold... Filter out all The capability atoms constitute the candidate atom set corresponding to the target node. .

[0054] The output of this step is a mapping relationship: This means that each target task node in the graph is associated with a set of potential execution units with matching functions.

[0055] Step S103: Solving multi-objective optimization under constraints The engine's constraint optimization solver receives mapping relationships. and containing constraint nodes The solver formalizes the problem as a combinatorial optimization problem: Decision variables: for each target node From its candidate set Select a specific capability atom .

[0056] Hard constraints: 1. Regarding any edge in (express Depends on ), its corresponding atoms Must You can only begin after that is completed.

[0057] 2. All selected atoms The total real-time resource demand must not exceed the current available resource limit of the system. .

[0058] 3. All constraint nodes Boundary conditions defined in the code (such as latest completion time) ( ) must be satisfied.

[0059] Optimization objective: Minimize a multi-objective weighted function The function consists of the following components: Total estimated time ,in Estimate the time required for atomic calculations. Estimate the time required for data transfer between atoms.

[0060] Total resource cost .

[0061] Negative overall quality score ,in It is an atom Historical success rate weighting.

[0062] final, Weight Defined by the currently active policy configuration file.

[0063] The solver employs heuristic search algorithms (such as variants of A* search) to explore the solution space, searching for solutions that satisfy all hard constraints and make... The minimum solution. The solution result is an atom allocation scheme. And the inferred execution sequence.

[0064] Step S104: Instantiate the executable workflow The engine's workflow synthesizer is based on Plan and The topology in the code generates an executable workflow definition. . It is a directed acyclic graph (DAG), where: A node is a specific atomic instance of a capability, and each instance carries an atomic implementation identifier obtained from the Plan and an atomic implementation identifier obtained from the Plan. The input parameters inherited from the middle.

[0065] Edges represent data and control dependencies between instances, and their direction is from... The edge in The decision is made, along with the expected data pattern mapping from the source instance output to the target instance input. It is serialized into a standard workflow description language (such as a custom DSL in JSON format) and passed to the execution and feedback module.

[0066] Step S105: Workflow Execution and Dynamic Data Adaptation Workflow interpreter loading for the execution and feedback module And begin scheduling and executing atomic instances in topological order. Within the atomic instance... After execution, output data is generated. The data adaptation layer will... Passed to downstream atomic instances Previously, perform the following operations: 1. Pattern comparison: Obtain Actual output data mode (Available via runtime reflection or convention) and Declared input data pattern .

[0067] 2. Difference Analysis: Calculates the differences between two schemas, identifying mismatches in field names, types, structures, or units.

[0068] 3. Conversion Chain Generation: Query the internal converter registry to find one or more converters that can bridge the identified differences. .

[0069] 4. Perform the conversion: sequentially... Application transformation chain: .

[0070] 5. Data Submission: Submit the adapted data Passed to As input. This process is transparent to atomic instances, ensuring that instances with inconsistent interface declarations can still collaborate correctly.

[0071] Step S106: Anomaly Monitoring and Resilient Recovery Execution exist During execution, the status monitor continuously tracks the execution status of each atomic instance. When an instance is detected... Execution failed (returning an error code, timeout, or output that violates its declaration). When this occurs, the following resilience recovery process is triggered: 1. State Snapshot: Immediately saves the collection of all currently successfully completed atomic instances. and its verified output data Record fault instance identifiers. and error messages .

[0072] 2. Residual map extraction: From In the middle, "prune" the parts corresponding to all completed nodes to generate a remaining intention sub-graph. .

[0073] 3. Replanning Request: Construct a plan containing , , and Replanning request package And send it back to the capability dynamic assembly engine.

[0074] 4. Local replanning: The engine uses... As input, re-execute steps S102 to S104. However, the optimization problem is now limited to... Within the range, and As a new input constraint Excluded from the candidate set. Generate an alternative sub-workflow. .

[0075] 5. State Recovery and Continuation: The workflow interpreter of the execution module receives... Then, roll back the execution environment to the state it was in before. and Consistent state points, then load and execute. This allows them to bypass the point of failure and continue the mission.

[0076] Step S107: Perform feedback data collection regardless Regardless of whether the process ultimately succeeds or fails, the feedback collector will systematically collect the following data after the process is completed: Atomic metrics: for each atomic instance that is invoked. Record its actual execution time Actual resource consumption Execution status .

[0077] Workflow-level metrics: Record the overall completion status and total time of the workflow.

[0078] Data adaptation log: Records each converter call and its effect.

[0079] External feedback signals: If present, collect quality scores or subsequent behavioral signals related to the results of this task. .

[0080] Step S108: Feedback-driven continuous optimization of the model and parameters The collected feedback data is asynchronously fed into the optimization processor, driving updates in two directions: 1. Ability Atom Parameter Update: For each atom The policy parameters in its description file are dynamically calibrated. For example, the estimated time is updated using exponential smoothing: ,in This is the average of the actual time spent recently. Learning rate. Historical success rate weight. It is also fine-tuned based on the current execution status.

[0081] 2. Incremental learning of the intent parsing model: This will enable successfully completed... The original request descriptions and their corresponding pairs form training sample pairs, which are added to the training dataset of the intent-aware module parsing the model. The system periodically (or after accumulating a certain amount) initiates the incremental training process of the model, using new samples to fine-tune the model parameters to improve the accuracy of understanding similar intents in the future.

[0082] This complete process demonstrates how the system transforms ambiguous inputs into reliable outputs and achieves self-evolution through "intent graphing," "atomic matching and optimization," "dynamic adaptation and resilient execution," and "feedback learning."

[0083] Finally, the following points should be noted: First, in the description of this application, it should be noted that, unless otherwise specified and limited, the terms "installation", "connection", and "linkage" should be interpreted broadly, and can be mechanical or electrical connections, or internal connections between two components, or direct connections. "Up", "down", "left", "right", etc. are only used to indicate relative positional relationships. When the absolute position of the described object changes, the relative positional relationship may change. Secondly: The accompanying drawings of the embodiments disclosed in this invention only involve the structures involved in the embodiments disclosed in this invention. Other structures can refer to the general design. In the absence of conflict, the same embodiment and different embodiments of this invention can be combined with each other. In conclusion, the above description is only a preferred embodiment of the present invention and is not intended to limit the present invention. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.

Claims

1. A software-driven processing system based on artificial intelligence, characterized in that, include: The intent perception module is used to receive raw input and convert the raw input into a structured intent description through an artificial intelligence parsing model. The intent description includes the task objective, the logical relationship between sub-objectives, and execution constraints. A capability dynamic assembly engine, connected to the intent perception module, is used to maintain a capability library consisting of multiple capability atoms with standardized description files, and dynamically selects multiple target capability atoms from the capability library based on the received structured intent description, and arranges the multiple target capability atoms into a non-preset task workflow. The system also includes an execution and feedback module, which is connected to the capability dynamic assembly engine to drive the execution of the task workflow, monitor the execution process, and collect feedback information. The feedback information is transmitted to the intent perception module and the capability dynamic assembly engine.

2. The software-driven processing system based on artificial intelligence according to claim 1, characterized in that, The structured intent description is a hierarchical directed acyclic graph (DAG) data. The nodes of the DAG data represent task objectives or constraints, and the directed edges of the DAG data represent dependencies, temporal relationships, or conditional logical relationships between objectives.

3. The software-driven processing system based on artificial intelligence according to claim 2, characterized in that, When generating the structured intent description, the intent perception module performs a logical conflict resolution process. This process identifies contradictions in resources, logic, or timing among multiple task elements extracted from the original input and automatically adjusts these contradictions based on preset conflict resolution rules or through analogy with historical cases.

4. The software-driven processing system based on artificial intelligence according to claim 1, characterized in that, The standardized description file for each capability atom in the capability library includes a function identifier, a function semantic vector, an input data pattern, an output data pattern, an execution precondition declaration, and policy parameters characterizing non-functional attributes. The policy parameters include estimated execution time, resource consumption range, and tolerance threshold for input data defects.

5. The software-driven processing system based on artificial intelligence according to claim 4, characterized in that, The capability dynamic assembly engine, based on the structured intent description, dynamically filters and orchestrates target capability atoms, including the following process: Calculate the similarity between the semantic vector of the task target node and the semantic vector of the capability atom function in the structured intent description, in order to filter out candidate capability atoms; Based on the constraints in the structured intent description, the current resource status of the system, and the strategy parameters of the candidate capability atoms, the feasibility of the candidate capability atom combinations is verified and comprehensively evaluated. Based on the results of the comprehensive evaluation and the logical relationships defined in the structured intent description, the task workflow is synthesized.

6. The software-driven processing system based on artificial intelligence according to claim 5, characterized in that, The comprehensive evaluation adopts a multi-objective optimization method, which simultaneously weighs the estimated total execution time of the task workflow, the overall resource consumption, the confidence level of the output results, and the robustness of the execution path.

7. The software-driven processing system based on artificial intelligence according to claim 1, characterized in that, When the execution and feedback module drives the task workflow, it performs runtime data adaptation operations. When the output data of the upstream capability atom is inconsistent with the declared input mode of the downstream capability atom, it automatically calls the data converter to perform format conversion, field mapping, or content completion.

8. The software-driven processing system based on artificial intelligence according to claim 1, characterized in that, When the execution and feedback module detects that the target capability atom fails to execute or the output deviates from the expected result during the execution process, it pauses the current task workflow and sends the error context, the generated intermediate data, and the unfinished task target subset to the capability dynamic assembly engine to trigger workflow replanning and assembly.

9. The software-driven processing system based on artificial intelligence according to claim 1 or 5, characterized in that, The intent perception module incrementally trains its artificial intelligence parsing model based on the assessment of the accuracy of intent understanding in the feedback information; the capability dynamic assembly engine dynamically updates the strategy parameters of each capability atom in the capability library and its association weight in semantic matching based on the data on the actual performance of capability atoms and workflow execution effects in the feedback information.

10. The software-driven processing system based on artificial intelligence according to claim 1, characterized in that, The system provides a capability atom registration interface, which allows external functional modules to be encapsulated as capability atoms conforming to the standardized description file specification and registered to the capability library through hot deployment or cold deployment.

Images