Task processing method, task platform, computing device and computer-readable storage medium

Abstract

The embodiments of this specification provide a task processing method, a task platform, a computing device, and a computer-readable storage medium, wherein the image processing method includes: obtaining a task description text of a target task; extracting task elements of the target task from the task description text using a large language model; based on the task elements, determining multiple target agents and target skills of the multiple target agents from a set of candidate agents, and generating structured execution protocols corresponding to the target skills of the multiple target agents; performing dependency analysis on the target skills of the multiple target agents based on the structured execution protocols corresponding to the target skills of the multiple target agents to obtain a skill combination; and scheduling the skill tools corresponding to the skill combination to execute the target task and obtain a task result. The accuracy and scalability of skill and tool call processing target tasks in open scenarios are achieved.

Description

Technical Field

[0001] The embodiments of this specification relate to the technical field of artificial intelligence, and in particular to a task processing method, a task platform, a computing device, and a computer-readable storage medium. Background Art

[0002] With the development of deep learning technology, intelligent agents, as a new generation of artificial intelligence systems, are being widely used in the automated processing of complex tasks and user interaction scenarios.

[0003] Currently, intelligent agents are able to perceive the environment, understand user needs, and autonomously plan and execute tasks, thereby providing users with efficient and accurate services.

[0004] However, a single skill set often falls short of meeting the demands of complex projects, especially in multi-step, multi-task scenarios. Intelligent agents must be able to combine multiple skills. The key challenge currently in need of solutions is how to integrate the skills and tools of multiple agents to autonomously plan and execute tasks. Summary of the Invention

[0005] In view of this, embodiments of this specification provide a task processing method. One or more embodiments of this specification also relate to a task platform, a computing device, a computer-readable storage medium, and a computer program product to address technical deficiencies in the prior art.

[0006] In one embodiment of this specification, a task processing method is provided, including:

[0007] Get the task description text of the target task;

[0008] Using a large language model, we extract the task elements of the target task from the task description text. Based on the task elements, we determine multiple target agents and their target skills from a set of candidate agents, and generate structured execution protocols corresponding to the target skills of the multiple target agents.

[0009] Based on the structured execution protocols corresponding to the target skills of multiple target agents, the target skills of multiple target agents are subjected to dependency analysis to obtain skill combinations;

[0010] Schedule the skill tools corresponding to the skill combination to perform the target task and obtain the task results.

[0011] By adopting a large language model to perform semantic analysis and element extraction on the task description text, semantic alignment and dynamic adaptation of the multimodal skill interface are achieved, solving the problem of collaboration between heterogeneous skill modules; by generating a structured execution protocol and implementing dependency analysis, an extensible skill combination framework is constructed, which significantly improves the autonomous planning and execution capabilities of complex tasks. The semantically driven skill combination mechanism breaks through the limitations of a single intelligent agent. At the same time, relying on the generalized understanding ability of the large language model, the accuracy and scalability of skill and tool calls to handle target tasks in open scenarios are achieved. BRIEF DESCRIPTION OF THE DRAWINGS

[0012] Figure 1 This is a flowchart of a task processing method provided by one embodiment of this specification;

[0013] Figure 2 This is a flowchart of a task processing method provided by an embodiment of this specification;

[0014] Figure 3 This is a schematic diagram of an agent list page of a task platform applied to a large language model provided by one embodiment of this specification;

[0015] Figure 4 This is a schematic diagram of a multi-version page of an agent in a task platform applied to a large language model provided by one embodiment of this specification;

[0016] Figure 5 This is a schematic diagram of an agent orchestration canvas for a task platform applied to a large language model provided by one embodiment of this specification;

[0017] Figure 6 This is one of the schematic diagrams of adding skills to a task platform for a large language model provided by one embodiment of this specification;

[0018] Figure 7 This is the second schematic diagram of adding skills to a task platform for a large language model provided by one embodiment of this specification;

[0019] Figure 8 This is a schematic diagram of pre-processing and post-processing of a task platform applied to a large language model provided by one embodiment of this specification;

[0020] Figure 9 This is a schematic diagram of concurrent execution of combined skills on a task platform for a large language model provided by one embodiment of this specification;

[0021] Figure 10 This is a schematic diagram of the overall architecture of a task platform applied to a large language model provided by an embodiment of this specification;

[0022] Figure 11 This is a schematic diagram of a combined skill architecture for a task platform applied to a large language model provided by one embodiment of this specification;

[0023] Figure 12 This is a schematic diagram of a skill input parameter schema generated by a task platform applied to a large language model provided by an embodiment of this specification;

[0024] Figure 13 This is a schematic diagram of a task platform for a large language model, provided by one embodiment of this specification, that combines skills to perform multiple tasks in parallel;

[0025] Figure 14 This is a schematic diagram of inputting supplementary information for a task platform applied to a large language model provided by one embodiment of this specification;

[0026] Figure 15 This is a schematic diagram of the structure of a task platform provided by one embodiment of this specification;

[0027] Figure 16 This is a structural block diagram of a computing device provided by one embodiment of this specification. DETAILED DESCRIPTION

[0028] The following description sets forth many specific details to facilitate a thorough understanding of this specification. However, this specification can be implemented in many other ways than those described herein, and those skilled in the art can make similar generalizations without violating the scope of this specification. Therefore, this specification is not limited to the specific implementations disclosed below.

[0029] The terms used in one or more embodiments of this specification are for the purpose of describing specific embodiments only and are not intended to limit one or more embodiments of this specification. The singular forms "a," "the," and "the" used in one or more embodiments of this specification and the appended claims are also intended to include plural forms unless the context clearly indicates otherwise. It should also be understood that the term "and / or" used in one or more embodiments of this specification refers to and includes any or all possible combinations of one or more associated listed items.

[0030] It should be understood that although the terms first, second, etc. may be used to describe various information in one or more embodiments of this specification, such information should not be limited to these terms. These terms are only used to distinguish the same type of information from each other. For example, without departing from the scope of one or more embodiments of this specification, the first may also be referred to as the second, and similarly, the second may also be referred to as the first. Depending on the context, the word "if" as used herein may be interpreted as "at the time of" or "when" or "in response to determining".

[0031] In addition, it should be noted that the user information (including but not limited to user device information, user personal information, etc.) and data (including but not limited to data used for analysis, stored data, displayed data, etc.) involved in one or more embodiments of this specification are all information and data authorized by the user or fully authorized by all parties, and the collection, use and processing of relevant data must comply with the relevant laws, regulations and standards of relevant countries and regions, and provide corresponding operation entrances for users to choose to authorize or refuse.

[0032] In one or more embodiments of this specification, a large model refers to a deep learning model with large-scale model parameters, typically containing hundreds of millions, tens of billions, hundreds of billions, trillions, or even more than ten trillion model parameters. A large model can also be called a foundation model. It is pre-trained on a large amount of unlabeled corpus to produce a pre-trained model with more than 100 million parameters. This model can adapt to a wide range of downstream tasks and has good generalization capabilities, such as a large language model (LLM) and a multi-modal pre-training model.

[0033] When large models are used in practice, only a small number of samples are needed to fine-tune the pre-trained model and it can be applied to different tasks. Large models can be widely used in natural language processing (NLP), computer vision and other fields. Specifically, they can be applied to computer vision tasks such as visual question answering (VQA), image caption (IC), and image generation, as well as natural language processing tasks such as text-based sentiment classification, text summary generation, and machine translation. The main application scenarios of large models include digital assistants, intelligent robots, search, online education, office software, e-commerce, and intelligent design.

[0034] First, the terms involved in one or more embodiments of this specification are explained.

[0035] An intelligent agent is a software system with autonomous perception, decision-making, and execution capabilities. It can complete specific tasks based on environmental input and user needs through reasoning, planning, and tool invocation. Its core characteristics include autonomy (no human intervention required), adaptability (dynamic policy adjustments), and interactivity (continuous interaction with users or the environment). It is widely used in areas such as automated services, intelligent assistants, and complex task orchestration.

[0036] Skills: Units of capability that enable an agent to perform a specific task. These encapsulate specific functional logic (such as text generation, data query, and API calls), defining input and output specifications through a standardized interface (skill schema). Skills can be deployed independently or combined, supporting modular expansion. For example, a translation skill requires input text and returns results in the target language. Its effectiveness relies on the agent's contextual understanding and tool scheduling capabilities.

[0037] Tools: External resources or interfaces integrated by agents to expand their capabilities. These include search engines, databases, third-party application programming interfaces (APIs), or local scripts. Tools are invoked by agents through abstract encapsulation (e.g., API adapters) to address requirements beyond the capabilities of native skills (e.g., real-time data acquisition). Their collaborative efficiency depends on interface compatibility and the agent's dynamic scheduling strategy.

[0038] Memory: The core module for the agent to store and manage information. It is divided into short-term memory (maintaining the current conversation state and temporary variables) and long-term memory (persisting historical records and domain knowledge base). Memory mechanisms support continuous decision-making through contextual association and retrieval enhancement (such as vector databases). For example, they remember user preferences to optimize subsequent interactions. Their design must balance real-time performance with storage overhead.

[0039] Context: A collection of dynamic background information about the current task or conversation, including user intent, environment state, historical interactions, and intermediate results of skill execution. Context is delivered to the skill chain via structured representations (such as key-value pairs or graphs). This helps resolve reference resolution (e.g., "it" refers to the object in the previous context) and ensure task coherence during multi-turn conversations. It is crucial for intelligent agents to achieve precise responses.

[0040] Skill schema: A standard, structured template that defines skill behavior. It specifies functional descriptions, input parameters (e.g., data types, required / optional), output formats (e.g., JavaScript Object Notation (JSON) schema), and execution constraints (e.g., permission requirements). The schema enables automatic skill registration and discovery (e.g., skill pools) through machine-readable metadata and drives agent protocol generation (e.g., Open Application Programming Interface (OPEN-API) specifications), ensuring seamless collaboration among heterogeneous skills.

[0041] In this specification, a task processing method is provided. This specification also involves a task platform, a computing device, a computer-readable storage medium, and a computer program product, which are described in detail one by one in the following embodiments.

[0042] See also Figure 1 , Figure 1 A flowchart of a task processing method provided by an embodiment of this specification is shown, including the following specific steps:

[0043] Step 102: Obtain the task description text of the target task.

[0044] The embodiments of this specification are applied to websites, applications or system platforms deployed with large language models, for example, task platforms of large language models, code development platforms of large language models, and cloud network platforms of large language models.

[0045] The target task is a natural language request to be processed. It is a complex operational task performed by coordinating the skills of multiple agents, such as cross-system data integration, multimodal information processing, or dynamic decision support. For example, the target task is: "Query the weather in a certain location." The task description is the natural language instruction entered by the user. The task description directly or implicitly includes task elements such as the task objective, execution constraints, and task context. For example, the task description of the target task is: "Query the weather in a certain location."

[0046] To obtain the task description text of the target task, one optional way is to receive the task description text of the target task sent by the front end, another optional way is to obtain the task description text of the target task from the database, and another optional way is to parse the task data of the target task to obtain the task description text of the target task. There is no limitation here.

[0047] For example, on a task platform with a large language model, a user wants to automate a target task by combining multiple agents in the agent pool of the task platform. The user enters the task description text of the target task, "Query the weather in a certain place," into the front end.

[0048] In step 102, the task description text of the target task is obtained, which provides an input data basis for the subsequent generation of a structured execution protocol.

[0049] Step 104: Utilize the large language model to extract the task elements of the target task from the task description text. Based on the task elements, determine multiple target agents and target skills of the multiple target agents from the candidate agent set, and generate a structured execution protocol corresponding to the target skills of the multiple target agents.

[0050] The large language model is a pre-trained deep neural network capable of natural language understanding and generation. It acquires semantic reasoning and contextual modeling capabilities through training on massive amounts of text data. Optionally, the large language model employs a self-attention mechanism to model cross-sequence dependencies. Its core functions include intent recognition, entity extraction, logical reasoning, and structured output generation, enabling it to map unstructured task descriptions into executable instructions. The task elements of a target task are a set of structured task features parsed from the task description, including the target task's objective, entities, instructions, input and output parameters, execution constraints, and contextual information. For example, in the task description "Query the weather in a certain location," the task elements include the objective (obtaining weather data), execution constraints (a time range of the next 24 hours), input parameters (location: XX, date: XXXX-XX-XX, temperature: 35°C), and contextual information (requiring the use of a real-time data interface). An agent is an agent instance that completes a specific task through reasoning, planning, and tool invocation based on environmental input and user needs. The agent acts as a skill invocation medium, with multiple functional modules registered in its pre-set skill pool. Each agent declares its skill invocation specifications through a skill schema. For example, agent A registers the weather query and weather map rendering skills, while agent B registers the data visualization skill. The candidate agent set is the currently callable agent, consisting of multiple pre-registered agent instances with heterogeneous functionality. This set is maintained through a dynamic registration mechanism. An agent's pre-registered skills are callable functional modules pre-registered in the agent skill pool via the skill schema. Each skill corresponds to problem-solving capabilities in a specific domain. Examples include, but are not limited to, natural language processing skills (such as entity recognition), API call skills (such as map service interfaces), data processing skills (such as table merging), and decision-making and reasoning skills (such as path planning algorithms). The target agent is an agent instance from among the pre-registered skills of multiple agents that is suitable for the task elements. Selection criteria include the relevance of the skill functionality to the task objective, input parameter compatibility, and execution constraint satisfaction. For example, for a weather query task, agents with registered weather API call skills and support for a specified geocoding format are selected. The target agent's target skills are callable functional modules in the target agent's skill pool that match the task elements. For example, the target skill is the "Real-time Weather Data Acquisition" skill encapsulated in the Weather Query Agent. The corresponding structured execution protocol is a machine-readable call specification generated based on the skill schema. It defines the input parameter format, output data structure, and call constraints required for skill execution. The structured execution protocol is expressed in a standardized data description language (such as JSON schema or Protobuf) and includes parameter names, data types, validation rules, and dependencies.For example, guided by the large model prompt, a structured execution protocol for the target skill is generated. The prompt is as follows: { / / Defines the data structured execution protocol specification for skill invocation parameters, used to standardize the input format and semantic constraints when executing the XX skill. "description":"Data specification for actionParam when initiating the XX skill", / / Describes the global purpose of this schema: ensuring that skill invocation parameters conform to predefined interface standards and resolving semantic alignment issues across heterogeneous skills. "properties":{ / / Declares a set of properties for skill input parameters. Each property corresponds to a specific data field extracted from the task context. "input":{ / / Semantic parsing results of the user's original command, generated after intent recognition and entity extraction using the large language model. "description":"Question extracted from user input", / / Describes field semantics: the structured question statement after NLU processing, for example, mapping "check the weather in a certain place" to "get weather data for a certain place". "type":"string" / / Data type constraint: limited to string type, must conform to UTF-8 encoding and length restrictions (e.g., ≤1024 characters).} / / Note: Other parameter fields can be expanded, such as output format preference (output_format), quality of service requirements, etc.} / / Typical application scenario example: When the intelligent agent calls the translation skill, actionParam must contain input="HelloWorld", target_lang="zh-CN"}.

[0051] For example, after parsing the task description text "Query the weather in a certain place", the large language model extracts the task elements: the goal is to obtain location data, temperature data, air quality data, and wind speed data, the constraint is the time range of "XXXX-XX-XX", and the input parameter is city = XX. Based on the skill schema matching, the "location query", "temperature query", "air quality query", and "wind speed query" skills of the environmental monitoring agent are selected from the candidate agent set, and a structured execution protocol is generated: input {city: "XX", date: "XXXX-XX-XX"}, output {"location":{"city":"XX","coordinates":{"latitude":"XX.XXXX","longitude":"XXX.XXXX"},"timezone":"XX / XXXXX"},"weather":{"date":"XXXX-XX-XX","temperature":{"value":"XX.X","unit":"°C / °F","description":"[Natural language description]"},"air_quality":{"aqi":"XX","pm2_5":"XX","pollutants":["[Pollutant type and concentration]"]},"wind":{"speed":"XX","unit":"m / s","direction":"[Wind direction description]","level":"[Wind speed classification]"},"timestamp":"XXXX-XX-XXTXX:XX:XXZ"}}.

[0052] In step 104, by using a large language model to perform semantic analysis and element extraction on the task description text, semantic alignment and dynamic adaptation of the multimodal skill interface are achieved, solving the collaboration problem between heterogeneous skill modules; by generating a structured execution protocol and implementing dependency analysis, an extensible skill combination framework is constructed, cross-skill task context transfer and dynamic resource scheduling are achieved, providing a combination basis and combination object data for the subsequent acquisition of skill combinations.

[0053] Step 106: Based on the structured execution protocols corresponding to the target skills of the multiple target agents, dependency analysis is performed on the target skills of the multiple target agents to obtain a skill combination.

[0054] Dependency analysis is a logical reasoning process that determines the execution order and data dependencies between skills. Dependency analysis analyzes the input and output parameters and execution constraints in structured execution protocols to construct a data flow and control flow dependency graph between skills, including predecessor and successor relationships (e.g., Skill B must be initiated after Skill A completes) and data transfer paths (e.g., Skill C's input parameters are derived from the output of Skill D). Dependency analysis uses a topological sorting algorithm to identify execution sequences, avoid circular dependencies, and ensure the feasibility and efficiency of the task chain. For example, in a weather query task, dependency analysis identifies that the "Query Location Data" skill must execute before the "Call Weather API" skill because the latter's input parameters depend on the geographic coordinate data output by the former. A skill combination is a skill invocation sequence constructed based on the dependency analysis results to meet the task's requirements. By logically arranging multiple target skills according to execution priorities, data dependencies, and resource constraints, a skill combination is formed that can collaboratively complete the target task. The skill combination represents the execution process using a directed acyclic graph (DAG), where nodes represent skill instances and edges represent data transfer or execution order constraints. For example, the skill combination "location query → temperature query → air quality query → wind speed query → data visualization" constitutes a multi-level skill call chain, and the output parameters of each skill serve as the input parameters of the next skill.

[0055] Based on the structured execution protocols corresponding to the target skills of multiple target agents, dependency analysis is performed on the target skills of multiple target agents to obtain skill combinations. An optional method is: based on the structured execution protocols corresponding to the target skills of multiple target agents, dependency analysis is performed on the target skills of multiple target agents, a skill call topology is constructed, and a skill combination is constructed based on the skill call topology.

[0056] For example, for the task description "Query the weather at a certain location," four skills are required: "Location Query," "Temperature Query," "Air Quality Query," and "Wind Speed ​​Query." Dependency analysis reveals that: 1) "Temperature Query" requires the standard geographic coordinates (e.g., latitude XX.XXXX, longitude XXX.XXXX) output by "Location Query"; 2) "Air Quality Query" relies on the same geographic coordinates and date parameters; and 3) "Wind Speed ​​Query" requires synchronous timestamps to ensure data consistency. Based on this, a skill invocation topology is constructed, generating a skill combination execution sequence: Location Query → (Temperature Query, Air Quality Query, Wind Speed ​​Query) executed in parallel. The location query outputs {"coordinates": {"latitude":"XX.XXXX","longitude":"XXX.XXXX"}}, which serves as input parameters for the following three skills. The temperature query, air quality query, and wind speed query share the time constraint parameter, date:"XXXX-XX-XX." After all sub-skills have completed, data aggregation is triggered, generating a complete weather report skill combination.

[0057] In step 106, a skill combination is obtained by performing dependency analysis on the target skills of multiple target agents, thereby providing an achievable skill combination for subsequent execution of the target task.

[0058] Optionally, based on the structured execution protocols corresponding to the target skills of the multiple target agents, dependency analysis is performed on the target skills of the multiple target agents to obtain a skill combination, including the following specific steps:

[0059] Based on the structured execution protocols corresponding to the target skills of multiple target intelligent agents, dependency analysis is performed on the target skills of multiple target intelligent agents, missing skills are determined, and structured execution protocols corresponding to the missing skills are obtained. Based on the structured execution protocols corresponding to the target skills of multiple target intelligent agents and the structured execution protocols corresponding to the missing skills, a skill combination is obtained.

[0060] Missing skills are functional modules identified during dependency analysis that are not currently registered in the skill pool. Missing skills are dynamically determined based on the input-output mismatch between task elements and existing skills. These skills need to be addressed through skill expansion (such as temporarily registering new skills) or alternative solutions (such as combining existing skills to simulate functionality). This discovery mechanism relies on the logical reasoning capabilities of a large language model and skill schema completeness verification. For example, if a task requires "generating a weather report for a specific location" but the skill pool lacks the "data visualization" skill, it is considered a missing skill and requires additional registration or the use of external tools (such as Matplotlib interfaces) for implementation.

[0061] Missing skills can be manually set (for example, an administrator explicitly marks a skill as pending), or they can be potential demand skills predicted through the generalization capabilities of large language models (for example, unregistered but frequently required functional modules are inferred based on historical task patterns), or they can be interface gaps automatically discovered through input and output compatibility verification of the skill schema (for example, the output parameters of an existing skill cannot meet the input type constraints of a downstream skill). There is no limitation here.

[0062] For example, developers construct a "data visualization" of missing skills based on the skill gaps pre-identified by domain knowledge, and configure a structured execution protocol corresponding to the missing skills.

[0063] By dynamically identifying and integrating missing skills and determining a structured execution protocol for missing skills, the integrity and scalability of the intelligent agent system in complex task processing are guaranteed.

[0064] Step 108: Schedule the skill tool corresponding to the skill combination to execute the target task and obtain the task result.

[0065] The skill tool corresponding to a skill combination is the execution engine or external service interface bound to each skill instance in the skill combination. Skill tools are configured based on the tool type declared in the skill schema (such as REST API endpoints, database connection configuration, and algorithm containers). They represent a dynamically instantiated collection of physical resources used to execute the skill's functional logic. Optionally, tool scheduling adheres to quality of service policies, including response time optimization (such as selecting the nearest data center) and fault tolerance mechanisms (such as retry strategies). For example, a map service tool might simultaneously connect to a map API and a database query API for automatic scheduling. Task results are structured data or operation status output after the skill combination executes, reflecting the completion of the target task. Task results include direct output (such as API response data), indirect artifacts (such as generated files), and execution metadata (such as time consumption and error codes). The format of task results must conform to the output specifications implicitly or explicitly defined in the task description and can be used by subsequent operations through context transfer mechanisms. For example, the task result of a weather query task is a JSON structure: {"temperature":25,"unit":"°C","humidity":"60%"}, accompanied by an execution status code of 200. Scheduling the skill tools corresponding to the skill combination to execute the target task and obtain the task result. An optional method is: using a scheduling engine to schedule the skill tools corresponding to the skill combination to execute the target task and obtain the task result, which is not limited here.

[0066] For example, the scheduling engine performs the following operations: It calls the "Location Coding" skill (implemented as a geocoding API wrapper) with input {"city":"XX"} and outputs {"coordinates":[121.47,31.23]}. It then schedules three skill tools in parallel: "Temperature Forecast" (implemented as a meteorological numerical forecast model microservice) with input {"coordinates":[121.47,31.23],"hours":24}; "Precipitation Probability" (implemented as a third-party weather data aggregation interface) with the same temperature forecast input; and "Wind Speed ​​Analysis" (implemented as a local Python wind speed calculation module) with the same temperature forecast input. After aggregating these results, it calls the "Report Generation" skill (implemented as a template rendering engine) with structured weather data input. Finally, it schedules the "Data Visualization" skill (implemented as a Matplotlib + Seaborn chart generator) with dashboard data input. The task result is {"status":"success","metadata":{"duration":"2.3s"},"data":{Dashboard}}.

[0067] Optionally, scheduling the skill tools corresponding to the skill combination to perform the target task and obtain the task results includes the following specific steps: scheduling the skill tools corresponding to the skill combination to perform the target task, determining the missing skills when missing information is detected, obtaining the structured execution protocol corresponding to the missing skills, and obtaining the skill combination based on the structured execution protocols corresponding to the target skills of multiple target intelligent agents and the structured execution protocols corresponding to the missing skills.

[0068] For example, when the scheduling engine reached the data aggregation phase, it discovered that the meteorological dataset {"temperature_series": [25,26,24], "precipitation": 0.3} output by the upstream skill did not match the standardized time series format {"timestamps": ["09:00","12:00","15:00"], "metrics": {"temp": [25,26,24], "rain_prob": [0.3]}} required by the downstream report generation skill. After analyzing the context logs, the large language model identified the need for a "Time Series Alignment" skill, which dynamically binds discrete values ​​to timestamps. The large language model then generated the following structured execution protocol for the missing skill: {"description":"Data conversion module that aligns unordered numerical sequences to a standardized time axis","input_schema":{ / / Input parameter time series alignment...}"output_schema":{ / / Input parameter time series alignment...}}

[0069] In the embodiments of this specification, by using a large language model to perform semantic analysis and element extraction on the task description text, semantic alignment and dynamic adaptation of the multimodal skill interface are achieved, and the collaboration problem between heterogeneous skill modules is solved; by generating a structured execution protocol and implementing dependency analysis, an extensible skill combination framework is constructed, which significantly improves the autonomous planning and execution capabilities of complex tasks, and breaks through the limitations of a single intelligent agent through a semantically driven skill combination mechanism. At the same time, relying on the generalized understanding ability of the large language model, the accuracy and scalability of skill and tool calls to process target tasks in open scenarios are achieved.

[0070] In an optional embodiment of the present specification, in step 104, a large language model is used to extract the task elements of the target task from the task description text, including the following specific steps: using the large language model to perform semantic parsing on the task description text, and extracting the task elements of the target task from the task description text, wherein the task elements include at least one of the entity, operation instructions and related information of the target task.

[0071] The entities of the target task are the objective objects or data items mentioned in the task description, including but not limited to specific instances such as location, time, numerical indicators, and project objects. Optionally, entities are extracted from natural language using named entity recognition and mapped to standardized semantic identifiers (such as GeoNames codes and timestamps) to serve as the input parameters for skill invocation. For example, in the task description "Query the temperature at a certain location for the next 24 hours," the entities include the location entity "XX" (mapped to geoID:1816670) and the time entity "next 24 hours" (parsed into the time interval [now,now+86400s]). The action instructions of the target task are the functional action requirements implicitly or explicitly defined in the task description, representing the core operation type the user desires to perform. Action instructions are identified through an intent classification model and mapped to predefined skill invocation templates (such as Query, Calculate, and Compare), driving the agent to select the corresponding functional module. For example, in the description "Compare PM2.5 values ​​at YY," the action instruction is "Compare," triggering the combined invocation of the data comparison skill. The associated information for a target task is auxiliary constraints or task context related to the task execution context, including user preferences, quality of service requirements, data timeliness constraints, and cross-task dependencies. This associated information is parsed using a contextual reasoning model and used to optimize skill invocation strategies (e.g., prioritizing low-latency APIs) and execution parameter configuration (e.g., setting cache expiration dates). For example, in the description text "Graphically display air quality trends for the past week, including ozone indicators," the associated information includes the output format preference (chart visualization) and indicator filtering criteria (ozone concentration).

[0072] For example, a large language model is used to extract entities: {location:{city:"XX", admin_division:true}, time_range:{"XXXX-XX-XX"}, metric:"PM2.5"}, identify the operation instruction sequence: ["aggregate","compare","visualize"], parse the associated information: {output_format:"chart",granularity:"monthly"}, and obtain task elements: the goal is to obtain location data, temperature data, air quality data, and wind speed data, the constraint is the "XXXX-XX-XX" time range, and the input parameter is city=XX.

[0073] In the embodiments of this specification, by utilizing a large language model to perform semantic analysis on the task description text, the task elements of the target task are extracted from the task description text, and accurate conversion of natural language instructions to structured task parameters is achieved, providing accurate data support for the subsequent determination of the target skills of at least one target intelligent agent.

[0074] In an optional embodiment of the present specification, in step 104, based on the task elements, multiple target agents and target skills of multiple target agents are determined from the candidate agent set, including the following specific steps: based on the task elements and the matching degree between the skill descriptions of the preset skills of the agents in the candidate agent set and the structured execution protocol specifications of the preset skills, multiple target agents and target skills of multiple target agents are determined from the candidate agent set, wherein the structured execution protocol specifications include parameter rules and / or operation rules.

[0075] The skill description of a preset skill is functional data describing the skill and can be defined using natural language or structured metadata. The skill description can include the skill's purpose (e.g., "geocode conversion"), applicable domain (e.g., "meteorological data processing"), functional limitations (e.g., "supports Chinese address input only"), and performance metrics (e.g., "response time < 500ms"), which are used for skill discovery and matching decisions. For example, the description of a weather query skill might be, "Get real-time temperature, humidity, and wind speed data using latitude and longitude coordinates, supporting global queries but returning only in Celsius." The structured execution protocol specification for preset skills is a technical standard for the skill invocation interface defined in machine-readable form, constraining input and output data structures and execution environment requirements. The structured execution protocol specification uses a standardized description language (e.g., JSON schema) to declare parameter types, required fields, enumeration value ranges, and error code systems, ensuring syntactic compatibility across skill invocations. For example, the structured execution protocol specification for the Air Quality Query skill includes input parameters {"coordinates": {"type": "array", "items": {"type": "number"}, "minItems": 2}} and an output field {"aqi": {"type": "integer", "minimum": 0}}. Parameter rules are a set of technical constraints on input and output parameters in the structured execution protocol specification, ensuring semantic consistency during data exchange. Parameter rules can include data types (e.g., string / number), value ranges (e.g., 0≤pH≤14), formatting conventions (e.g., ISO 8601 timestamps), and dependencies (e.g., require_card_id=true when type="VIP"). Runtime rules are a set of non-functional constraints on skill execution, defining resource consumption, concurrency control, and quality of service requirements. Runtime rules can include timeout thresholds (e.g., max_duration=2s), permission levels (e.g., auth_level≥3), resource dependencies (e.g., GPU memory ≥4GB), and rate limits (e.g., 10 calls / minute).

[0076] For example, a task element contains the command "aggregate" and the input parameters {"city": "XX", "metrics": ["PM2.5","SO2"]}. This matches Agent A (skill score 0.87) and Agent B (skill score 0.79), both of which have the skill "Air Pollutant Aggregation." Verification revealed that Agent A's structured execution protocol specification requires "NO2" as a metric, while Agent B supports dynamic metric expansion. Consequently, Agent B's "Multi-Pollutant Analysis" skill was selected.

[0077] In the embodiments of this specification, by establishing a multi-dimensional matching mechanism between task elements, skill descriptions, and structured execution protocol specifications, the accuracy and adaptability of skill selection are achieved, and the problem of function positioning in heterogeneous skill pools is solved; by verifying parameter rules and / or operation rules, the compatibility and reliability of skill calls are ensured, laying a technical foundation for the subsequent generation of structured execution protocols.

[0078] In an optional embodiment of the present specification, generating a structured execution protocol corresponding to the target skills of multiple target agents in step 104 includes the following specific steps: generating a structured execution protocol corresponding to the target skills of multiple target agents based on the skill descriptions of the target skills of the multiple target agents and the structured execution protocol specifications, wherein the structured execution protocol specifications include parameter rules and / or operation rules.

[0079] The skill description of a target skill is functional data describing the target skill and can be defined using natural language or structured metadata. The skill description can include the skill's purpose, applicable domain, functional limitations, and performance metrics, and is used for skill discovery and matching decisions. The structured execution protocol specification for a target skill defines the skill invocation interface technical standard in a machine-readable format, constraining input and output data structures and execution environment requirements. The structured execution protocol specification uses a standardized description language (such as JSON schema) to declare parameter types, required fields, enumeration value ranges, and error code systems, ensuring syntactic compatibility across skill invocations.

[0080] For example, for the target skill "Weather Report Generation," based on its skill description "Integrate multi-source weather data to generate a comprehensive report" and the structured execution protocol specification {"input": {"required": ["temperature","humidity"], "properties": {"temperature": {"type": "number"}, "humidity": {"type": "number", "maximum": 100}}}, "output": {"type": "object", "properties": {"report": {"type": "string"}, "severity_level": {"type": "integer", "minimum": 1, "maximum": 5}}}}, the following structured execution protocol is generated: {"action":"generate_weather_report", / / Defines the action type for skill invocation and identifies the specific functional module currently being executed. "parameters": { / / Declare all parameter configurations required for skill invocation. "input": { / / A set of input parameters, corresponding to the input data structure defined in the skill schema. "temperature":"humidity":"pressure":},"constraints":{ / / Execution constraints, defining non-functional requirements. "output_format":"markdown", / / The output format must be Markdown syntax, corresponding to the format restrictions in the skill description. "timeout":3000 / / Timeout threshold (unit: milliseconds). Exceeding 3000ms will trigger the interrupt mechanism.}},"output_schema":{ / / Output data structure definition, declaring the format specification of the skill execution result...}}

[0081] In the embodiments of this specification, a machine-readable standardized interface definition is achieved by structurally converting skill descriptions into structured execution protocol specifications; parameter rules are used to ensure data consistency in input and output, and operation rules are used to guarantee service quality, forming a verifiable and executable skill call framework, providing an accurate protocol foundation for subsequent dependency analysis and skill combination.

[0082] In an optional embodiment of the present specification, structured execution protocols corresponding to the target skills of multiple target agents are generated based on the skill description of the target skills and the structured execution protocol specification, including the following specific steps: based on the skill description of the target skills and the structured execution protocol specification, context data is queried to generate structured execution protocols corresponding to the target skills of multiple target agents, wherein the context data includes at least one of historical interaction data, real-time interaction request data and external service response data.

[0083] Context data is a dynamic collection of information accessible to an agent during task execution. It includes at least one of historical interaction data, real-time interaction request data, and external service response data. Optionally, context data is maintained in a key-value store or vector database, supporting fast retrieval based on timestamps or semantic similarity. This data is used to dynamically populate skill invocation parameters and optimize execution strategies. For example, in a weather query task, context data includes the user's historical location preferences (historical interaction data), the precise time range of the current request (real-time interaction request data), and real-time weather alerts returned by third-party APIs (external service response data). Historical interaction data is a persistent record of past interactions between the agent and the user or environment, including but not limited to user preferences, frequent operation patterns, and historical task execution logs. Historical interaction data is stored in a long-term memory module. Applications include personalized parameter defaults (e.g., automatically populating a user's frequently used cities) and skill invocation priority learning (e.g., prioritizing APIs with high user ratings). For example, historical interaction data might record that "User A requested Celsius display in 8 of the past 10 queries," driving a temperature query skill to automatically set the "unit:" parameter. Real-time interaction request data represents instantaneous state information generated during the current task execution cycle, including user input (such as follow-up questions in multi-turn conversations), temporary variables (such as intermediate calculation results), and system monitoring metrics (such as CPU utilization). Optionally, real-time interaction data is maintained in a short-term memory module, using a buffer for efficient reading and writing to address immediate dependencies (such as when a downstream skill requires the real-time output of an upstream skill). For example, when a user adds a request for "add precipitation probability," the real-time interaction request data will be updated with a new field {"require_precipitation": true}, triggering the dynamic expansion of the skill set. External service response data represents the structured results returned when the agent calls a third-party service or tool. This includes API response bodies (such as JSON returned by REST (Representational State Transfer) interfaces), database query result sets, and hardware device status feedback. For example, external service response data may contain {"aqi": 45, "provider": "XWeather", "timestamp": "XXXX-03-20T14:00:00Z"}, which needs to be mapped to the internal standard format for use by downstream skills.

[0084] For example, when processing the task description "Query the weather in a certain location," historical interaction data is queried to obtain the user's default city parameter: {"preferred_city": "XX"}. Real-time interaction request data is parsed to extract the time range: {"time_range": ["XXXX-XX-XX"]}. The air quality API is called to obtain external service response data: {"historical_data": [{"month": "XXXX-XX-XX", "avg_pm25":}, {"month": "XXXX-XX-XX", "avg_pm25":}]}. This contextual data is combined to generate a structured execution protocol.

[0085] In the examples of this specification, a multi-dimensional contextual data fusion mechanism is established to achieve dynamic and accurate skill parameter generation. This system optimizes default parameter settings through persistent learning of historical interaction data, stream processing of real-time interaction data ensures task consistency, and standardized conversion of external service response data ensures system compatibility. This creates a closed-loop parameter generation system, significantly improving skill invocation accuracy and system robustness in complex task scenarios.

[0086] In an optional embodiment of the present specification, step 106 includes the following specific steps: parsing the structured execution protocols corresponding to the target skills of multiple target agents to obtain the execution dependencies corresponding to the target skills of multiple target agents; constructing a skill call topology based on the execution dependencies corresponding to the target skills of multiple target agents; and arranging the target skills of multiple target agents based on the skill call topology to obtain a skill combination.

[0087] The execution dependencies corresponding to a target skill are a set of inter-skill data flow and control flow constraints parsed from the structured execution protocol. These include input parameter sources (e.g., skill A's output field X serves as skill B's input parameter Y), execution order requirements (e.g., skill C must be started after skill D completes), and resource competition rules (e.g., skills E and F cannot share a GPU instance). Execution dependencies can be represented by directed edges, forming a graph of skill invocation preconditions. For example, in a weather query task, the execution dependency for the "Temperature Forecast" skill is {"required_inputs": ["coordinates"], "provider_skill": "Location Code"}, indicating that it requires the geographic coordinate parameters provided by the Location Code skill. The skill invocation topology is a graph structure constructed based on execution dependencies. It can be a directed acyclic graph, with nodes representing skill instances and edges representing data transfer or execution order constraints between skills. This topology uses a topological sorting algorithm to eliminate circular dependencies and optimize parallel execution paths. For example, the skill call topology may contain parallel branches: location encoding → (temperature prediction, precipitation analysis, wind speed calculation) → data aggregation → visualization, where the three skills in the brackets can be executed in parallel.

[0088] Parse the structured execution protocols corresponding to the target skills of multiple target agents to obtain the execution dependency relationships corresponding to the target skills of multiple target agents. One optional method is: through a graph traversal algorithm, parse the mapping relationship between the input and output parameters of the structured execution protocols corresponding to the target skills of multiple target agents, and generate the execution dependency relationships corresponding to the target skills of multiple target agents. Another optional method is: using a constraint satisfaction solver, calculate the parameter compatibility constraints of the structured execution protocols corresponding to the target skills of multiple target agents, and derive the execution dependency relationships corresponding to the target skills of multiple target agents. There is no limitation here.

[0089] Based on the execution dependencies corresponding to the target skills of multiple target agents, a skill call topology is constructed. One optional method is to use a critical path analysis algorithm to identify the longest execution path based on the execution dependencies corresponding to the target skills of multiple target agents, and construct a skill call topology. Another optional method is to use a constraint satisfaction solver to calculate the execution dependencies corresponding to the target skills of multiple target agents, and construct a skill call topology. Another optional method is to use a reinforcement learning algorithm with execution time as the target, and generate a skill call topology based on the execution dependencies corresponding to the target skills of multiple target agents. There is no limitation here.

[0090] For example, for a weather query task consisting of four skills, the structured execution protocol is parsed to obtain the following dependencies: Temperature prediction: {"depends_on": ["location code"], "inputs": ["coordinates"]}; Precipitation analysis: {"depends_on": ["location code"], "inputs": ["coordinates"]}; Wind speed calculation: {"depends_on": ["location code"], "inputs": ["coordinates"]}; Data aggregation: {"depends_on": ["temperature prediction","precipitation analysis","wind speed calculation"], "inputs": ["temp_data","precip_data","wind_data"]}. The skill call topology is constructed: A[location code] --> B[temperature prediction]; A --> C[precipitation analysis]; A --> D[wind speed calculation]; B --> E[data aggregation]; C --> E; D --> E. This is then orchestrated to generate a skill combination.

[0091] In the examples presented in this specification, we accurately extract dependencies through structured protocol parsing, employ graph theory algorithms to construct conflict-free call topologies, and generate skill combinations that balance efficiency and correctness. This solves the challenge of optimizing execution order when collaborating with multiple skills, improving both feasibility and efficiency.

[0092] In an optional embodiment of the present specification, step 108 includes the following specific steps: loading the skill combination into the asynchronous scheduling engine; running the asynchronous scheduling engine, scheduling the skill tool corresponding to the skill combination to perform the target task, and obtaining the task result.

[0093] The asynchronous scheduling engine is a distributed scheduling system that supports concurrent task execution. It utilizes task queues, resource pools, and fault-tolerance mechanisms to enable the parallel invocation and collaborative management of multiple skill tools. This engine can include non-blocking task dispatching (e.g., based on an event loop), dynamic load balancing (e.g., localized scheduling), and fault isolation (e.g., preventing a single skill failure from impacting the overall workflow), making it suitable for the efficient execution of heterogeneous skill combinations. For example, an asynchronous scheduling engine might include a RabbitMQ task queue, a Kubernetes resource scheduler, and a Prometheus monitoring module to enable the parallel execution of the "temperature forecast," "precipitation analysis," and "wind speed calculation" skills in a weather query task.

[0094] Run the asynchronous scheduling engine to schedule the skill tools corresponding to the skill combination to execute the target task and obtain the task results. An optional method is to use message middleware to run the asynchronous scheduling engine, schedule the skill tools corresponding to the skill combination to execute the target task and obtain the task results. Implement asynchronous dispatch of skill call requests and result callbacks.

[0095] For example, load the skill combination into the task queue of the asynchronous scheduling engine, publish the stage 1 task to the geocoding service cluster through Kafka, and after receiving the completion event, initiate stage 2 calls to the weather model service and third-party APIs. Listen to the response events of all skill tools, trigger the retry / supplement mechanism in case of timeout or failure, and generate the task result:

[0096] In the embodiments of this specification, an asynchronous scheduling engine is used to achieve parallel execution and efficient resource utilization of multi-skill tools, solving the response delay problem caused by serial scheduling and significantly improving the processing throughput and reliability of complex tasks.

[0097] In an optional embodiment of the present specification, the task description text is a plurality of task description texts.

[0098] During a single interaction, a user may enter multiple task descriptions, potentially covering different but related objectives. Multiple task descriptions can be identified and separated using delimiters (such as line breaks or semicolons) or semantic segmentation algorithms, supporting parallel processing of multiple tasks. For example, a user inputting "Query the weather in a certain location; then query tomorrow's air quality in another location" contains two task descriptions, corresponding to two independent but parallelizable tasks: a weather query and an air quality query.

[0099] For example, consider a user input containing two task descriptions: "Get temperature data for the next three days at a certain location and compare it with the same period at another location." After semantic parsing, two subtasks are identified: Task 1: {"task": "Temperature query", "location": "a certain location", "duration": "3 days"}; Task 2: {"task": "Data comparison", "locations": ["a certain location", "another location"], "metric": "temperature"}. Reference content for a skill set is generated for parallel execution. Geocoding and temperature prediction for tasks t1 and t2 are executed in parallel.

[0100] In the examples of this specification, the efficient execution of complex instructions is achieved through intelligent parsing and parallel processing of multi-task description text. This solution breaks through the limitations of traditional single-task processing and significantly improves system response efficiency in complex interactive scenarios by dynamically building parallel skill combinations.

[0101] In an optional embodiment of the present specification, step 108 includes the following specific steps: when a missing skill with missing parameters is detected in the structured execution protocol, using a large language model, based on the structured execution protocol specification corresponding to the missing skill, generating parameter completion guidance information; feeding back the parameter completion guidance information to the front end; receiving the supplementary parameters sent by the front end; based on the supplementary parameters, updating the structured execution protocol corresponding to the missing skill to obtain an updated skill combination; scheduling the skill tool corresponding to the updated skill combination to execute the target task and obtain the task result.

[0102] Missing parameters are skill instances where required input parameters are not met during skill execution. This determination is based on the following criteria: 1) the value of a field marked "required" in the structured execution protocol is empty; 2) parameter type validation fails (e.g., a string is received for a numeric parameter); and 3) context-passed parameters do not match the skill schema definition (e.g., missing latitude and longitude coordinates, but a weather query skill requires geocoded input). For example, if the "Time Range" parameter is missing during the execution of the "Air Quality Forecast" skill, the skill is marked as missing. Parameter completion guidance is structured information generated by a large language model to guide users in providing missing parameters. It includes the parameter name, data type, example values, and constraint descriptions. The generation process integrates the skill schema's protocol specifications and contextual reasoning, using a hybrid of natural language and structured templates. For example, the generated guidance message might read: "Please specify the query time range (format: YYYY-MM-DD to YYYY-MM-DD)." The supplementary parameters are the legal parameter data provided by the user in response to the guidance message and must pass protocol validation before being integrated into the execution context. Supplementary parameters must meet the following requirements: data type matching (e.g., date strings must conform to ISO 8601); value range validity (e.g., temperature values ​​must be between -50°C and 60°C); and no conflicts with existing parameters (e.g., the time range must not exceed the API service period). For example, a user enters "YYYY-YY-YY" as a supplementary time range parameter. The updated skill combination is a reconstructed skill call sequence after integrating the supplementary parameters. The update mechanism uses topological sorting to ensure dependency relationships are maintained, for example, expanding a single API call in the original skill combination into a batch query by time period.

[0103] Based on the supplementary parameters, the structured execution protocol corresponding to the missing skills is updated to obtain the updated skill combination. An optional method is to use a graph reconstruction algorithm to adjust the node parameter configuration and edge dependency of the skill call topology based on the supplementary parameters to obtain the updated skill combination.

[0104] Scheduling the skill tools corresponding to the updated skill combination to execute the target task and obtain the task result. An optional method is to use a scheduling engine to schedule the skill tools corresponding to the updated skill combination to execute the target task and obtain the task result.

[0105] For example, a missing skill was detected when executing the "Weather Report Generation" skill combination. Missing skill identification: The "Data Visualization" skill was found to be missing the "chart_type" parameter (the protocol requires the mandatory enumeration value ["line", "bar", "pie"]). A guidance message was generated: "Please select the chart type: line chart / bar chart / pie chart." The user supplemented the parameter: "line." "parameters": {"visualization": {"chart_type": "line"}} was added to the structured execution protocol. A "Data Conversion" node was inserted into the skill call topology to map the temperature data array to a time series format. An interactive report containing a line chart of 24-hour temperature changes was generated.

[0106] In the embodiments of this specification, a closed-loop parameter completion mechanism is implemented by detecting missing parameters in real time and generating precise guidance information; by dynamically updating protocols and reconstructing skill combinations, the continuous execution capability of the task chain is guaranteed, effectively solving the problem of incomplete parameters in open scenarios, significantly reducing the task interruption rate, and optimizing the input efficiency of complex parameters through human-computer collaboration.

[0107] In the application scenarios of intelligent agents, skills are the core execution units of intelligent agents, and tools are the specific means of implementing skills. In order to cope with increasingly complex project requirements, intelligent agents need to have the following capabilities: 1. Flexible expansion of combined skills: By linking multiple skills, more powerful composite capabilities are formed to adapt to diverse task requirements. 2. Context awareness and dynamic parameter generation: During task execution, the parameters required for skill execution are dynamically generated based on contextual data (such as user input, memory, external service return results, etc.) to ensure accurate skill invocation. 3. User interaction optimization: When the parameters required for skill execution are incomplete, the intelligent agent can actively interact with the user to clarify and complete the missing information, thereby improving the task completion rate. 4. Multi-task parallel processing: When the user raises multiple questions or tasks, the intelligent agent can call multiple skills simultaneously to improve response efficiency and service quality.

[0108] Figure 2 FIG. 1 shows a flow chart of a task processing method provided by an embodiment of the present specification, such as Figure 2 As shown:

[0109] Front-end user questions: Users enter task requests (e.g., "Query the weather in a certain location") via natural language, triggering the task processing process. Large language model planning: Semantic parsing: Extracting task elements (goals, entities, constraints, etc.); Skill matching: Selecting target agents and skills based on the skill schema; Protocol generation: Outputting a structured execution protocol (including input and output specifications). Dependency analysis and skill combination: Topology construction: Resolving data flow and control flow dependencies between protocols; Parallel orchestration: Generating a DAG-structured skill invocation sequence. Asynchronous scheduling engine: Task distribution: Loading skill combinations into message queues; Dynamic execution: Scheduling skill tools for parallel execution; Fault tolerance: Monitoring timeouts and failures and triggering retries. Large language model observation: Execution monitoring: Real-time tracking of skill tool execution status (e.g., progress, duration, and error codes), analyzing the data quality of intermediate results (e.g., field completeness and value validity). Dynamic adjustment: Protocol optimization: Modifying the structured execution protocol based on runtime feedback; Combination reconstruction: Updating skill combinations in real time.

[0110] Optionally, the parameter completion mechanism includes the following: missing detection: identifying required but unprovided parameters; guided generation: prompting users for clarification via natural language; and protocol update: reconstructing the skill combination after integrating supplementary parameters.

[0111] Final answer feedback: Data aggregation: Merge multi-skill outputs; Format conversion: Generate a final answer that meets user expectations; Front-end response: Return the structured final answer to the front-end user.

[0112] On the task platform of large language model, a set of intelligent agent execution framework based on combined skills is designed.

[0113] The following combined Figures 3 to 14 , taking the application of the task processing method provided in this specification in the task platform of a large language model as an example, the task processing method is further explained.

[0114] in, Figure 3 A schematic diagram of an agent list page of a task platform applied to a large language model provided by an embodiment of this specification is shown. Figure 3As shown: On the agent list page of the Large Language Model Task Platform, the left navigation area includes: Home button; Practice Example button: View preset task templates (such as the weather query combination skill); Agent Center button (highlighted): Enter the agent management module; Toolbox area: Displays registered skill tools by category. The right agent management area includes: Agent Name: Input box "Please enter content", Query button, Reset button, and Get Import Key Credentials control. Creation portal: + New Agent: Starts the custom agent configuration process (corresponding to the target agent determination in step 104); Import Agent: Supports importing third-party agents using password credentials ("Get Import Password Credentials"). Agent List: Displays deployed Agents 1 and 2 (expandable). Each agent provides a complete operation chain: configuration: setting the skill schema and structured execution protocol specifications (corresponding to the structured execution protocol generation in step 104); editing: modifying the skill description and parameter rules; API debugging: verifying the skill tool interface (corresponding to the scheduling execution in step 108); evaluation results: viewing historical task execution indicators (such as the dependency analysis effect in step 106); exporting: generating a shareable agent package.

[0115] in, Figure 4 A schematic diagram of a multi-version page of an agent for a task platform applied to a large language model provided by an embodiment of this specification is shown. Figure 4 As shown: the input box for the version name "Please enter content", the selection control for the version status "Please select", the query button, the reset button and the effect tracking button. The top includes version query: version name, version status; creation entry: + New agent version: start the custom agent version configuration process (corresponding to the target agent determination in step 104); output version configuration; import agent version: supports importing third-party agent versions through password credentials. The version list records the version name, version code, version status, version creator, version creation time, creation method and operation of each version. Manage the skill schema of the agent through versioning to ensure that protocol updates do not affect online tasks; track the version iteration of skills by building paths; and use network protection mechanisms to resolve resource conflicts during parallel scheduling of multiple versions.

[0116] in, Figure 5 A schematic diagram of an agent arrangement canvas for a task platform applied to a large language model provided by one embodiment of this specification is shown. Figure 5 As shown: The agent orchestration canvas shows the orchestration process in detail: start → script task → combination task → result rendering task.

[0117] in, Figure 6FIG1 shows one of the schematic diagrams of adding skills to a task platform for a large language model provided by an embodiment of the present specification, such as Figure 6 As shown: the input parameters of the combined task include name, source, type, required and description; the execution of the task includes: selecting tools or agents, skill name and description and operation; skills can be added and users can add skills for clarification; the output parameters of the combined task include name, type and description: test - object - test; Success - Boolean value - whether it is successful; errorCode - string text - error code; errorMessage - string text - error message; Content - string text - content; taskId - string text - task code.

[0118] in, Figure 7 The second schematic diagram of adding skills to a task platform for a large language model provided by an embodiment of this specification is shown, as shown in FIG. Figure 7 As shown, script task input parameters include name, source, type, required fields, and description. Editing tool execution tasks includes selecting a tool or agent (for self-testing APIs), skill name (for testing), applicable scenarios (such as querying weather forecasts), capabilities, restrictions (not applicable to scenarios other than querying weather forecasts), task execution continuation upon exception, input parameter preprocessing (no processing, script processing, and planned processing), and a script. The script is: defpreprocesssTooParam(tool_param)...@param: tool_param, tool input string @return: processed tool input string. Note: Input and output parameters are all JSON strings. The original input parameter {"userId":"111"} is changed to {"userId":"222"}...return {"userId":"222"}.

[0119] in, Figure 8 FIG. 1 shows a schematic diagram of pre-processing and post-processing of a task platform applied to a large language model according to an embodiment of the present specification. Figure 8 As shown, the input parameters for a script task include name, source, type, required fields, and description; the editing tool execution task includes selecting a tool or agent (for self-testing APIs), skill name (for testing), applicable scenarios (such as querying weather forecasts), capabilities, restrictions (not applicable to scenarios other than querying weather forecasts), task exception continuation, input parameter pre-processing (no processing, script processing, or planned processing), input parameters (parameter name, field source, type, required fields, and description), result post-processing (direct result return, script conversion, and simulation result output), and script. The input parameters (parameter name, field source, type, required fields, and description) and result post-processing (direct result return, script conversion, and simulation result output) are configurable.

[0120] Among them, Figure 9 shows a schematic diagram of the concurrent execution of combined skills of a task platform applied to a large language model provided by an embodiment of this specification, as Figure 9 shown: On the left side is the dialogue debugging area. Through multi-round dialogues, the user generates multiple batches of test responses for skill combinations: - [{"content": "["errorMessages":], "success": true, "data": "result": "The result information of the user's query is as follows: User name: AAA, User phone: XXXXXXXX, User address: XXXXXXXXXX", "errorCode": null, "errorMsg": null, "extraData": null, "originld": null, "env": null, "other": null, "firstErrorMessage": null, "failure": false)", "isStream": false, "listlndex": 1, "success": true, "taskld": "6c111077-9d66-4800-aa3f-331364303eb8", "taskName": "Test"}, {"content": ""errorMessages": [], "success": true, "data": "result": "The result information of the user's query is as follows: User name: AAA, User phone: XXXXXXXX, User address: XXXXXXX"},"errorCode": null, "erorMsg": null, "extraData": null, "originld": null, "env": nulL, "firstErrorMessage": null, "failure": false}", "isStream": "false", "listindex": 0, "success": true, "taskld": "cd38c945-9544-46d4-b347-2bb3a0b9f04d", "taskName": "Test"}]. In the middle is the intelligent agent task rule area, which shows a flow chart; on the right side are the log and model inference process areas, which show the execution status of each skill during the task execution.

[0121] Among them, Figure 10 shows a schematic diagram of the overall architecture of a task platform applied to a large language model provided by an embodiment of this specification, as Figure 10As shown: The scenario layer includes scenarios 1-n, a designer debugging module, and an OPEN-API interface. The orchestration component includes skill orchestration components, skill combinations, tools, agents, document retrieval, data table retrieval, image and text retrieval, multi-tenant infrastructure, system observability, the OneRAG suite, and a SQL executor. The skill capability layer includes an asynchronous scheduling engine, header encryption, header function value retrieval, input parameter / header default values, asynchronous tools, asynchronous callback expiration policies, skill simulation, the ability to continue executing despite skill exceptions, debugging / breakpoint capabilities, input parameter pre-processing, skill invocation, result post-processing, skill combination parallelism, and streaming tools. The skill execution layer includes an API executor, knowledge base retrieval, the OneRAG suite executor, a large language model voice prompt executor, and a SQL executor. Tool registration includes: custom API registration: Curl parsing registration, tool debugging, request method, header definition, input and output parameter definition, whether it is asynchronous, whether it is streaming, tenant & space isolation...; platform tools: Prompt large language model tool, calculator, asr, tts, SQL executor, OneRAG suite, knowledge base and tenant.

[0122] Figure 11 A schematic diagram of a combined skill architecture of a task platform applied to a large language model provided by an embodiment of this specification is shown. Figure 11 As shown: From the preceding node, multiple API tools are called through the skill combination to implement the skill combination streaming variable update and sequentially execute the subsequent nodes.

[0123] Figure 12 FIG. 1 shows a schematic diagram of a skill input parameter schema generated by a task platform applied to a large language model according to an embodiment of the present specification. Figure 12 As shown: You can choose whether to continue executing the task if an exception occurs. Script task input parameters include name, source, type, required fields, and description. Task execution in the editing tool involves input parameter preprocessing (no processing, script processing, and planned processing), input processing, and post-processing (direct result return, script conversion, and simulation result output). When generating skill input parameter schemas, input parameters include parameter name, field source, type, required fields, and description settings: Input-Prompt: User input extraction question - string - No - Open to modification; User-Constant: {"userId":"243243"} - No - ...; Username-Constant: XXXX - string - No - Not open to modification.

[0124] Figure 13 FIG. 1 shows a schematic diagram of a task platform for a large language model provided by an embodiment of the present specification for performing multiple tasks in parallel using combined skills, such as Figure 13As shown: Multiple skills and their parameters are generated during planning. Multiple skills are generated simultaneously in combined skills. The asynchronous scheduling engine loads multiple skills and initiates calls to the skill service at the same time. In the left dialogue debugging area, the user generates multi-batch test responses for skill combinations through multi-round dialogues: - [{"content": "["errorMessages":], "success": true, "data": "result": "The result information queried by the user is as follows: User name: AAA, User phone: XXXXXXXX, User address: XXXXXXXXXX", "errorCode": null, "errorMsg": null, "extraData": null, "originld": null, "env": null, "other": null, "firstErrorMessage": null, "failure": false), "isStream": false, "listlndex": 1, "success": true, "taskld": "6c111077-9d66-4800-aa3f-331364303eb8", "taskName": "Test"}, {"content": ""errorMessages": [], "success": true, "data": "result": "The result information queried by the user is as follows: User name: AAA, User phone: XXXXXXXX, User address: XXXXXXX"},"errorCode": null, "erorMsg": null, "extraData": null, "originld": null, "env": nulL, "firstErrorMessage": null, "failure": false}", "isStream": "false", "listindex": 0, "success": true, "taskld": "cd38c945-9544-46d4-b347-2bb3a0b9f04d", "taskName": "Test"}]. The flow chart is displayed in the middle intelligent agent task rule area; in the right log and model inference process area, the execution status of each skill during task execution is displayed.

[0125] Figure 14 The figure shows a schematic diagram of supplementary input information of a task platform applied to a large language model provided by an embodiment of this specification, as Figure 14As shown: When the necessary parameters for executing a skill are not met, the user enters additional information a second time. According to the skill schema description, the large model can perceive whether the necessary parameters for the execution tool are missing based on the context information during planning, and provide the user with clarification questions and answers if they are missing. In the dialogue debugging area on the left, the user goes through multiple rounds of dialogue: - What information do you need to know? I will do my best to help you. - Query the weather in a certain place. - In order to query the weather in a certain place, I need to know which day's weather conditions you want to obtain, and whether you need detailed weather information, such as temperature, humidity, wind speed, etc. The agent task rule area on the right displays a flowchart; Start → Task Planning (Prompt full text, reasoning results) → User Intention Clarification Task (output results).

[0126] above Figures 3 to 14 The agent execution framework on the task platform of the large language model includes the following key features:

[0127] 1. In combined skills, by associating multiple skills and combining skills in the intelligent agent to add skills, the skill capability description and input parameter schema protocol are described, and in react, the large model planning and thinking ability is combined to accurately activate the skills; 2. When the intelligent agent plans to execute skills, the skill schema defined by the combined skills can be used to extract and generate skills based on context data during planning to dynamically input parameters to activate the skills; 3. When the user's question matches the required execution skill, but the execution skill input parameters are incomplete, the user is provided with the ability to clarify and the user is asked again to complete the execution skill parameters; 4. When the user asks multiple questions and hits multiple skills in the combined skills, the combined skills support the parallel execution of multiple skills at one time.

[0128] Corresponding to the above method embodiment, this specification also provides a task platform embodiment, Figure 15 FIG1 shows a schematic diagram of a task platform provided by an embodiment of the present specification. The task platform 1500 includes a front-end task interface 1510 and a response unit 1520;

[0129] The front-end task interface 1510 is used to receive the task description text of the target task sent by the front-end; the response unit 1520 is used to use the large language model to extract the task elements of the target task from the task description text, and based on the task elements, determine the target skills of at least one target intelligent agent from the preset skills of multiple intelligent agents, and generate structured execution protocols corresponding to the target skills of multiple target intelligent agents; based on the structured execution protocols corresponding to the target skills of multiple target intelligent agents, perform dependency analysis on the target skills of multiple target intelligent agents to obtain skill combinations; schedule the skill tools corresponding to the skill combinations to execute the target tasks, obtain task results, and send the task results to the front-end.

[0130] Optionally, the response unit 1520 is specifically used to: use a large language model to perform semantic analysis on the task description text, and extract task elements of the target task from the task description text, wherein the task elements include at least one of the entity, operation instructions and related information of the target task.

[0131] Optionally, the response unit 1520 is specifically used to: determine multiple target agents and target skills of multiple target agents from the candidate agent set based on task elements and the degree of match between the skill descriptions of the preset skills of the agents in the candidate agent set and the structured execution protocol specifications of the preset skills, wherein the structured execution protocol specifications include parameter rules and / or operation rules.

[0132] Optionally, the response unit 1520 is specifically used to generate structured execution protocols corresponding to the target skills of multiple target agents based on the skill descriptions of the target skills of multiple target agents and the structured execution protocol specifications, wherein the structured execution protocol specifications include parameter rules and / or operation rules.

[0133] Optionally, the response unit 1520 is specifically used to: query context data based on the skill descriptions and structured execution protocol specifications of the target skills of multiple target agents, and generate structured execution protocols corresponding to the target skills of multiple target agents, wherein the context data includes at least one of historical interaction data, real-time interaction request data, and external service response data.

[0134] Optionally, the response unit 1520 is specifically used to: parse the structured execution protocols corresponding to the target skills of multiple target agents, and obtain the execution dependencies corresponding to the target skills of multiple target agents; construct a skill call topology based on the execution dependencies corresponding to the target skills of multiple target agents; and arrange the target skills of multiple target agents based on the skill call topology to obtain a skill combination.

[0135] Optionally, the response unit 1520 is specifically used to: load the skill combination into the asynchronous scheduling engine; run the asynchronous scheduling engine, schedule the skill tool corresponding to the skill combination to perform the target task, and obtain the task result.

[0136] Optionally, the task description text is multiple task description texts.

[0137] Optionally, the response unit 1520 is specifically used to: when a missing skill with missing parameters is detected in the structured execution protocol, generate parameter completion guidance information based on the structured execution protocol specification corresponding to the missing skill using a large language model; feed back the parameter completion guidance information to the front end; receive the supplementary parameters sent by the front end; based on the supplementary parameters, update the structured execution protocol corresponding to the missing skill to obtain an updated skill combination; schedule the skill tool corresponding to the updated skill combination to execute the target task and obtain the task result.

[0138] In the embodiments of this specification, the task platform uses a large language model to perform semantic analysis and element extraction on the task description text, thereby achieving semantic alignment and dynamic adaptation of the multimodal skill interface and solving the collaboration problem between heterogeneous skill modules; by generating a structured execution protocol and implementing dependency analysis, an extensible skill combination framework is constructed, which significantly improves the autonomous planning and execution capabilities of complex tasks, and breaks through the limitations of a single intelligent agent through a semantically driven skill combination mechanism. At the same time, relying on the generalized understanding ability of the large language model, the accuracy and scalability of skill and tool calls to process target tasks in open scenarios are achieved.

[0139] The above is a schematic scheme of a task platform of this embodiment. It should be noted that the technical solution of the task platform and the technical solution of the task processing method described above are of the same concept. For details not described in detail in the technical solution of the task platform, please refer to the description of the technical solution of the task processing method described above.

[0140] Figure 16 FIG1 shows a block diagram of a computing device according to an embodiment of the present disclosure. Components of the computing device 1600 include, but are not limited to, a memory 1610 and a processor 1620. The processor 1620 is connected to the memory 1610 via a bus 1630, and a database 1650 is used to store data.

[0141] Computing device 1600 also includes an access device 1640 that enables computing device 1600 to communicate via one or more networks 1660. Examples of such networks include a Public Switched Telephone Network (PSTN), a Local Area Network (LAN), a Wide Area Network (WAN), a Personal Area Network (PAN), or a combination of communication networks such as the Internet. Access device 1640 may include one or more of any type of wired or wireless network interface (e.g., a Network Interface Controller (NIC)), such as an IEEE 802.11 Wireless Local Area Network (WLAN) wireless interface, a Worldwide Interoperability for Microwave Access (Wi-MAX) interface, an Ethernet interface, a Universal Serial Bus (USB) interface, a cellular network interface, a Bluetooth interface, or a Near Field Communication (NFC) interface.

[0142] In one embodiment of the present specification, the above components of the computing device 1600 and Figure 16 Other components not shown in the figure may also be connected to each other, for example, via a bus. Figure 16 The computing device structure block diagram shown is for illustrative purposes only and is not intended to limit the scope of this specification. Those skilled in the art may add or replace other components as needed.

[0143] Computing device 1600 can be any type of stationary or mobile computing device, including a mobile computer or mobile computing device (e.g., a tablet computer, personal digital assistant, laptop computer, notebook computer, netbook computer, etc.), a mobile phone (e.g., a smartphone), a wearable computing device (e.g., a smartwatch, smart glasses, etc.), or other types of mobile devices, or a stationary computing device such as a desktop computer or personal computer (PC). Computing device 1600 can also be a mobile or stationary server.

[0144] The processor 1620 is configured to execute the following computer program / instruction, which implements the steps of the above-mentioned task processing method when executed by the processor.

[0145] The above is a schematic solution of a computing device of this embodiment. It should be noted that the technical solution of the computing device and the technical solution of the above-mentioned task processing method are of the same concept. For details not described in detail in the technical solution of the computing device, please refer to the description of the technical solution of the above-mentioned task processing method.

[0146] An embodiment of the present specification further provides a computer-readable storage medium storing a computer program / instruction. When the computer program / instruction is executed by a processor, the steps of the above-mentioned task processing method are implemented.

[0147] The above is a schematic scheme of a computer-readable storage medium of this embodiment. It should be noted that the technical scheme of the storage medium and the technical scheme of the task processing method described above are of the same concept. For details not described in detail in the technical scheme of the storage medium, please refer to the description of the technical scheme of the task processing method described above.

[0148] An embodiment of the present specification further provides a computer program product, including a computer program / instruction, which implements the steps of the above-mentioned task processing method when executed by a processor.

[0149] The above is a schematic solution of a computer program product of this embodiment. It should be noted that the technical solution of this computer program product and the technical solution of the task processing method described above are based on the same concept. For details not described in detail in the technical solution of the computer program product, please refer to the description of the technical solution of the task processing method described above.

[0150] The foregoing description of this specification describes specific embodiments. Other embodiments are within the scope of the appended claims. In some cases, the actions or steps recited in the claims can be performed in an order different from that described in the embodiments and still achieve the desired results. Furthermore, the processes depicted in the accompanying drawings do not necessarily require the specific order shown or the sequential order to achieve the desired results. In certain embodiments, multitasking and parallel processing are also possible or may be advantageous.

[0151] The computer instructions include computer program code, which may be in source code form, object code form, executable file, or some intermediate form. The computer-readable medium may include any entity or device capable of carrying the computer program code, recording medium, USB flash drive, mobile hard drive, magnetic disk, optical disk, computer memory, read-only memory (ROM), random access memory (RAM), electric carrier signals, telecommunication signals, and software distribution media. It should be noted that the content of the computer-readable medium may be appropriately increased or decreased based on the requirements of patent practice. For example, in some regions, according to patent practice, computer-readable media does not include electric carrier signals and telecommunication signals.

[0152] It should be noted that for the aforementioned method embodiments, for the sake of simplicity of description, they are all expressed as a series of action combinations, but those skilled in the art should be aware that the embodiments of this specification are not limited by the order of the actions described, because according to the embodiments of this specification, certain steps can be performed in other orders or simultaneously. Secondly, those skilled in the art should also be aware that the embodiments described in this specification are all preferred embodiments, and the actions and modules involved are not necessarily required by the embodiments of this specification.

[0153] In the above embodiments, the description of each embodiment has its own focus. For parts that are not described in detail in a certain embodiment, reference can be made to the relevant descriptions of other embodiments.

[0154] The preferred embodiments disclosed above are intended only to help illustrate this specification. The optional embodiments do not exhaustively describe all details, nor do they limit the invention to the specific embodiments described. Obviously, many modifications and variations can be made based on the content of the embodiments of this specification. This specification selects and specifically describes these embodiments in order to better explain the principles and practical applications of the embodiments of this specification, so that those skilled in the art can better understand and utilize this specification. This specification is limited only by the claims and their full scope and equivalents.

Claims

1. A task processing method, comprising: Get the task description text of the target task; Utilizing a large language model, extracting the task elements of the target task from the task description text, determining multiple target agents and target skills of the multiple target agents from a set of candidate agents based on the task elements, and generating a structured execution protocol corresponding to the target skills of the multiple target agents, wherein the agent is a skill call carrier, a preset skill pool of the agent has multiple functional modules registered therein, and the target skills of the target agent are callable functional modules in the skill pool of the target agent that match the task elements; Based on the structured execution protocols corresponding to the target skills of the multiple target agents, dependency analysis is performed on the target skills of the multiple target agents to obtain a skill combination, wherein the dependency analysis is a logical reasoning process for determining the execution order and data dependency relationship between skills, and the skill combination is a skill call sequence constructed based on the dependency analysis results and meeting the task elements; Schedule the skill tools corresponding to the skill combination to perform the target task and obtain the task results.

2. The method according to claim 1, wherein extracting the task elements of the target task from the task description text using a large language model comprises: The large language model is used to perform semantic parsing on the task description text, and task elements of the target task are extracted from the task description text, wherein the task elements include at least one of the entity, operation instructions and associated information of the target task.

3. The method according to claim 1, wherein determining a plurality of target agents and target skills of the plurality of target agents from a set of candidate agents based on the task elements comprises: Based on the task elements and the degree of match between the skill descriptions of the preset skills of the agents in the candidate agent set and the structured execution protocol specifications of the preset skills, multiple target agents and target skills of multiple target agents are determined from the candidate agent set, wherein the structured execution protocol specifications include parameter rules and / or operation rules.

4. The method according to claim 1, wherein generating a structured execution protocol corresponding to the target skills of the plurality of target agents comprises: Based on the skill descriptions of the target skills of the multiple target agents and the structured execution protocol specifications, a structured execution protocol corresponding to the target skills of the multiple target agents is generated, wherein the structured execution protocol specifications include parameter rules and / or operation rules.

5. The method according to claim 4, wherein generating structured execution protocols corresponding to the target skills of the multiple target agents based on the skill descriptions of the target skills of the multiple target agents and the structured execution protocol specifications comprises: Based on the skill descriptions and structured execution protocol specifications of the target skills of the multiple target agents, context data is queried to generate structured execution protocols corresponding to the target skills of the multiple target agents, wherein the context data includes at least one of historical interaction data, real-time interaction request data and external service response data.

6. The method according to claim 1, wherein the step of performing dependency analysis on the target skills of the multiple target agents based on the structured execution protocols corresponding to the target skills of the multiple target agents to obtain a skill combination comprises: Parsing the structured execution protocols corresponding to the target skills of the multiple target agents to obtain the execution dependency relationships corresponding to the target skills of the multiple target agents; Building a skill call topology based on the execution dependencies corresponding to the target skills of the multiple target agents; Based on the skill call topology, the target skills of the multiple target agents are arranged to obtain a skill combination.

7. The method according to claim 1, wherein the scheduling of the skill tool corresponding to the skill combination to execute the target task and obtain the task result comprises: Loading skill combinations into the asynchronous scheduling engine; Run the asynchronous scheduling engine to schedule the skill tools corresponding to the skill combination to execute the target task and obtain the task result.

8. The method according to claim 1, wherein the task description text is a plurality of task description texts.

9. The method according to any one of claims 1 to 8, further comprising: When a missing skill with missing parameters is detected in the structured execution protocol, generating parameter completion guidance information based on the structured execution protocol specification corresponding to the missing skill using the large language model; Feedback the parameter completion guidance information to the front end; Receiving supplementary parameters sent by the front end; Based on the supplementary parameters, updating the structured execution protocol corresponding to the missing skills to obtain an updated skill combination; The skill tools corresponding to the updated skill combination are scheduled to execute the target tasks and obtain the task results.

10. A task platform, comprising a front-end task interface and a response unit; The front-end task interface is used to receive the task description text of the target task sent by the front-end; The response unit is used to use a large language model to extract the task elements of the target task from the task description text, determine multiple target agents and target skills of the multiple target agents from the candidate agent set based on the task elements, and generate structured execution protocols corresponding to the target skills of the multiple target agents, perform dependency analysis on the target skills of the multiple target agents based on the structured execution protocols corresponding to the target skills of the multiple target agents, obtain skill combinations, schedule skill tools corresponding to the skill combinations to perform the target task, and obtain task results, wherein, The agent is a skill call carrier, and a plurality of functional modules are registered in the preset skill pool of the agent. The target skill of the target agent is a callable functional module in the skill pool of the target agent that matches the task elements. The dependency analysis is a logical reasoning process for determining the execution order and data dependency relationship between skills. The skill combination is a skill call sequence that satisfies the task elements and is constructed based on the dependency analysis results. The front-end task interface is also used to send the task result to the front-end.

11. A computing device comprising: memory and processor; The memory is used to store computer programs / instructions, and the processor is used to execute the computer programs / instructions. When the computer program / instructions are executed by the processor, the steps of the method according to any one of claims 1 to 9 are implemented.

12. A computer-readable storage medium storing a computer program / instruction, wherein the computer program / instruction, when executed by a processor, implements the steps of the method according to any one of claims 1 to 9.

13. A computer program product comprising a computer program / instruction, which implements the steps of the method according to any one of claims 1 to 9 when executed by a processor.

Images