A multi-agent-based task processing method and device, and a related medium

Abstract

The application discloses a kind of based on multi-agent task processing method, device and related medium, the method includes receiving user service request and parsing, obtains task request object;Intention recognition is carried out to task request object, and target decomposition is carried out according to identification result, to construct task context diagram;Based on the preset multi-agent scheduling, resource arrangement is carried out to task context diagram, and context data set is obtained;Cooperative reasoning is carried out to context data set, to generate candidate result set;Candidate result set is evaluated, and update to obtain evaluation signal, based on evaluation signal adjustment at least one agent parameter, integrated to obtain intermediate result set;Format uniform processing is carried out to intermediate result set, and generates task processing object.The application is parsed by multi-agent, intention decomposition and resource arrangement, cooperative reasoning and evaluation adaptive optimization, finally generate task processing object, in this way, improve the processing accuracy of intelligent customer service system.

Description

Technical Field

[0001] This invention relates to the field of data processing, and in particular to a multi-agent-based task processing method, apparatus, and related media. Background Technology

[0002] In the current field of intelligent customer service, the application of AI technology has evolved from simple "question-answering robots" to "digital employees" capable of handling complex business processes. Traditional intelligent customer service systems typically use a single, massive AI model to handle all user requests, or employ a workflow engine based on preset rules to connect different functional points. This lack of cross-module collaborative orchestration and adaptive closed-loop mechanisms for complex, multi-step service requests leads to the isolation of various functional modules (such as intent recognition, information retrieval, and work order processing), making it difficult to perform directed topology organization and dynamic scheduling based on sub-task dependencies. Consequently, the processing accuracy of the intelligent customer service system drops significantly. Summary of the Invention

[0003] This invention provides a multi-agent-based task processing method, apparatus, and related medium, aiming to solve the technical problem of a significant decrease in the processing accuracy of existing intelligent customer service systems.

[0004] In a first aspect, embodiments of the present invention provide a multi-agent-based task processing method, including:

[0005] Receive user service requests and parse the user service requests to obtain task request objects;

[0006] The task request object is subjected to intent recognition, and the target is decomposed based on the recognition results to construct a task context map;

[0007] Based on a preset multi-agent scheduling, the task context diagram is orchestrated to obtain a context data set.

[0008] Collaborative reasoning is performed on the context data set to generate a candidate result set;

[0009] The candidate result set is evaluated and the evaluation signal is updated. Based on the evaluation signal, the parameters of at least one agent are adjusted, and the intermediate result set is obtained by integration.

[0010] The intermediate result set is formatted uniformly to generate a task processing object corresponding to the task request object.

[0011] Secondly, embodiments of the present invention provide a multi-agent-based task processing device, comprising:

[0012] The data receiving unit is used to receive user service requests and parse the user service requests to obtain task request objects.

[0013] An intent recognition unit is used to recognize the intent of the task request object and decompose the target based on the recognition result to construct a task context map.

[0014] The resource orchestration unit is used to orchestrate the task context diagram based on a preset multi-agent scheduling to obtain a context data set.

[0015] A collaborative reasoning unit is used to perform collaborative reasoning on the context data set to generate a candidate result set;

[0016] A data scheduling unit is used to evaluate the candidate result set, update the evaluation signal, adjust the parameters of at least one agent based on the evaluation signal, and integrate to obtain an intermediate result set.

[0017] The object output unit is used to perform format unification processing on the intermediate result set and generate a task processing object corresponding to the task request object.

[0018] Thirdly, embodiments of the present invention provide a computer device, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to implement the multi-agent-based task processing method of the first aspect.

[0019] Fourthly, embodiments of the present invention provide a computer-readable storage medium, wherein a computer program is stored on the computer-readable storage medium, and when the computer program is executed by a processor, it implements the multi-agent-based task processing method of the first aspect.

[0020] This invention provides a multi-agent-based task processing method, including receiving a user service request and parsing the request to obtain a task request object; performing intent recognition on the task request object and decomposing the target based on the recognition results to construct a task context graph; orchestrating resources on the task context graph based on a preset multi-agent scheduling to obtain a context data set; performing collaborative reasoning on the context data set to generate a candidate result set; evaluating the candidate result set and updating the evaluation signal; adjusting the parameters of at least one agent based on the evaluation signal to integrate and obtain an intermediate result set; and performing format unification processing on the intermediate result set to generate a task processing object corresponding to the task request object. This invention improves the processing accuracy of intelligent customer service systems by using multiple agents to parse requests, decompose intents, and orchestrate resources, followed by collaborative reasoning and adaptive optimization through evaluation.

[0021] This invention also provides a multi-agent-based task processing device, computer equipment, and storage medium, which have the same beneficial effects as described above. Attached Figure Description

[0022] To more clearly illustrate the technical solutions of the embodiments of the present invention, the drawings used in the following description of the embodiments will be briefly introduced. Obviously, the drawings described below are some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0023] Figure 1 This is a flowchart illustrating a multi-agent-based task processing method provided in an embodiment of the present invention.

[0024] Figure 2 This is a schematic block diagram of a multi-agent-based task processing device provided in an embodiment of the present invention. Detailed Implementation

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

[0026] It should be understood that, when used in this specification and the appended claims, the terms "comprising" and "including" indicate the presence of the described features, integrals, steps, operations, elements and / or components, but do not exclude the presence or addition of one or more other features, integrals, steps, operations, elements, components and / or collections thereof.

[0027] It should also be understood that the terminology used in this specification is for the purpose of describing particular embodiments only and is not intended to limit the invention. As used in this specification and the appended claims, the singular forms “a,” “an,” and “the” are intended to include the plural forms unless the context clearly indicates otherwise.

[0028] It should also be further understood that the term "and / or" as used in this specification and the appended claims refers to any combination of one or more of the associated listed items and all possible combinations, and includes such combinations.

[0029] Please see below. Figure 1 , Figure 1The flowchart of a multi-agent-based task processing method provided in this embodiment of the invention specifically includes steps S101 to S106.

[0030] S101. Receive a user service request and parse the user service request to obtain a task request object;

[0031] S102. Perform intent recognition on the task request object and decompose the target based on the recognition result to construct a task context map;

[0032] S103. Based on the preset multi-agent scheduling, the task context diagram is resource-arranged to obtain a context data set;

[0033] S104. Perform collaborative reasoning on the context data set to generate a candidate result set;

[0034] S105. Evaluate the candidate result set and update the evaluation signal. Adjust the parameters of at least one agent based on the evaluation signal and integrate them to obtain an intermediate result set.

[0035] S106. Perform format unification processing on the intermediate result set to generate a task processing object corresponding to the task request object.

[0036] In step S101, user service requests from software mini-programs, APPs, or web pages are obtained through the multi-channel access component. The heterogeneous payloads (text, voice, images) are parsed and their fields are standardized to obtain a task request object including the channel source, user identifier, message content, and modal tag. This object is then written into the pending queue to trigger subsequent processes.

[0037] In one embodiment, step S101 includes:

[0038] Input streams from multiple channels are processed to obtain the original request packets;

[0039] The message payload is obtained by parsing the header and payload structure of the original request packet respectively.

[0040] Based on the message payload, determine the modal tags of text, voice, and image, and extract the corresponding content units to obtain structured units;

[0041] The structured units are standardized and transformed to obtain standardized task data;

[0042] The standardized task data is instantiated and constructed to generate a task request object.

[0043] In this embodiment, a secure connection is first established with clients such as software mini-programs, apps, and web pages through a multi-channel unified access system. Input streams from different channels are processed to obtain the original request packet. The original request packet includes at least the following fields: channel identifier, user identifier, timestamp, signature token, and payload pointer. Deduplication and basic authentication are performed on the access side to ensure the idempotency and security of subsequent processing. Then, the header and payload structures of the original request packet are parsed: encoding verification and time normalization are performed on the header fields to extract the channel source and session context; the payload is decapsulated and decoded according to the message type to obtain the message payload corresponding to the request. The payload can be heterogeneous content such as text fragments, audio streams, or images, and metadata related to the payload (such as sampling rate, resolution, file hash, and resource locator) is retained for traceability.

[0044] After acquiring the message payload, modal tags are determined based on the payload type, and corresponding content units are extracted to obtain structured units. When the payload is text, the main text and parsable fields are directly extracted; when the payload is speech, automatic speech recognition is performed to obtain standard text transcription and record the confidence level; when the payload is an image, image preprocessing and necessary OCR feature extraction are performed to generate descriptive text and feature vectors that can be used for semantic understanding. Each of these content units is associated with its modal tag, resulting in a unified set of structured units for consumption. The structured units are then standardized: the character set and field value formats such as time and currency are unified, field names and levels are mapped according to the preset task data specifications, required fields are filled in, and default values ​​are given for optional fields, generating standardized task data that is independent of the channel. This data includes at least user identity, channel source, modal tag set, content unit details, session context identifier, and idempotent key information, which is used to provide a consistent data view for subsequent intelligent orchestration.

[0045] Finally, the standardized task data is instantiated to generate a task request object, which is assigned a globally unique request_id and transaction identifier, and its priority and timeout policies are set. A mapping relationship is also established with the original channel receipt channel. The task request object is written into the task initialization queue and submitted to the multi-Agent collaborative orchestration system to start the subsequent intent recognition, target decomposition and resource orchestration process, realizing a closed-loop connection from access to initialization.

[0046] In step S102, the master agent performs semantic modeling of the task request object based on natural language understanding, and completes intent recognition and slot extraction; then, the target is decomposed according to the preset task template library, the request is broken down into several sub-tasks, and a directed topology is constructed according to the input and output dependencies, which is instantiated into a task context diagram to express the sequence and data transmission relationship between the sub-tasks.

[0047] In one embodiment, step S102 includes:

[0048] The task request objects are segmented, part-of-speech tagging is performed, and slot extraction is performed to obtain semantic representations;

[0049] The semantic representation is subjected to intent classification and inference processing, and core intent tags are determined based on a preset intent set;

[0050] Locate the target decomposition template corresponding to the core intent tag from the preset task template library;

[0051] The target decomposition template is used to generate a corresponding set of subtasks;

[0052] The set of subtasks is subjected to dependency construction processing to determine directed dependency pairs based on the input and output constraints of each subtask, thereby obtaining a topological sequence;

[0053] The topological sequence is instantiated into a graph structure to construct the corresponding task context graph.

[0054] In this embodiment, a standardized task request object is used as input. First, its message payload undergoes textual preprocessing, followed by word segmentation, part-of-speech tagging, and slot extraction to obtain a semantic representation including "entity-attribute-constraint." Slots include, but are not limited to, fields such as time, location, object category, quantity range, and operation instructions, providing computable elements for subsequent template variable binding. Then, the master agent performs intent classification inference on the semantic representation based on a preset intent set, calculates the confidence distribution of each candidate intent, and selects tags that meet threshold conditions as core intent tags. The intent set covers high-frequency business types for property services such as repair requests, complaints, inquiries, and expedited processing, ensuring the directionality and consistency of subsequent decomposition. The aforementioned intent recognition is performed by the master agent (Manager AI) in the orchestration system to accurately identify the user's core intent.

[0055] After the core intent label is determined, the system locates the target decomposition template corresponding to that label in the task template library and provides the expected output mode and required context for each subtask. Once the template is located, the system binds placeholder variables according to the slot fields and completes the default parameters, generating a set of subtasks matching the intent. For complex requests such as "leakage repair," instances of the subtask set can include: image content analysis, semantic location confirmation, historical work order query, and maintenance work order creation, breaking down complex requests into clear and executable multi-step tasks.

[0056] Furthermore, the system constructs dependencies for the set of subtasks. Based on the input and output constraints of each subtask, it determines the mapping from upstream output fields to downstream input fields, obtaining directed dependency pairs. Topological sorting is then performed on the set of directed dependency pairs to obtain a topological sequence that satisfies causal and data flow constraints, and the boundaries between parallel and sequential execution are identified accordingly. To facilitate subsequent scheduling and monitoring, the system instantiates the topological sequence into a graph structure, constructing a task context graph: subtasks are used as nodes to record task types, required skills, and input / output patterns; edges record field mappings and consistency verification rules. This creates a complete directed graph representation of the processing flow after "intent recognition - task decomposition," providing a structured basis for subsequent agent scheduling and collaborative reasoning.

[0057] In step S103, the scheduler reads the task context diagram, extracts the type, urgency and required skills of the subtasks, matches available professional agents from the scenario agent pool, generates assignment mapping and initializes the session context and communication route; based on this, the system aggregates the data sources accessible to the assigned agent (historical work orders, knowledge base, business system interfaces and cached sessions, etc.) to obtain a context data set, providing a consistent data view for collaborative processing.

[0058] In one embodiment, step S103 includes:

[0059] The task context diagram is processed by a preset Agent scheduler to extract subtasks, resulting in a subtask list.

[0060] Extract the task type, urgency level, and required skills of each subtask in the subtask list to obtain an attribute table;

[0061] Based on the attribute table, at least one candidate scenario agent is selected from the preset scenario agent pool to obtain a candidate set;

[0062] The candidate set is subjected to matching and scoring calculation to generate corresponding assignment mapping parameters;

[0063] The assignment mapping parameters are initialized to establish a call route and session context, thereby obtaining an interaction channel.

[0064] The data sources associated with the assigned scenario Agent in the interaction channel are aggregated to obtain a context data set.

[0065] In this embodiment, the scheduler first reads the task context graph, extracts subtasks from each node, and generates a list of subtasks arranged in topological order. Each subtask retains its identifier, input and output placeholders, and upstream dependency information to ensure consistency in subsequent orchestration and routing. Subsequently, the scheduler parses the metadata of each subtask, extracts attributes such as task type, urgency, and required skills, and summarizes them into an attribute table to drive the matching and scoring process.

[0066] After obtaining the attribute table, the scheduler accesses the scenario agent pool and filters one or more candidate scenario agents for each subtask according to the attribute table, forming a candidate set. Candidate filtering simultaneously considers agent availability (online status, load, window rate limiting) and capability tags (domain knowledge / tool ​​access / external system permissions) to ensure that the selected agents possess the professional capabilities to meet the subtask constraints. Next, the scheduler performs a matching score calculation on the candidate set: combining static adaptation score (similarity between task type and skill tags), dynamic runtime score (current load, response latency), and historical performance score (success rate, return integrity), outputting a normalized score and selecting the set of agents above a certain threshold to generate assignment mapping parameters. The assignment mapping parameters include at least the agent identifier, call route, return channel, timeout and retry strategy, and concurrency / serialization boundary, for direct invocation in subsequent execution phases. To support the execution pattern of the next stage, the scheduler simultaneously provides collaborative mode suggestion tags (routing / collaboration / coordination) during the scoring phase, which are retained as metadata of the session context to quickly determine the organization method for parallel or sequential execution during the collaborative inference phase.

[0067] After assignment is determined, the scheduler initializes the assignment mapping parameters, which involves establishing a call route and session context for each assigned scenario agent, assigning globally unique session identifiers, transaction identifiers, and idempotent keys, initializing message encoding / decoding protocols and security credentials, and configuring external system connection descriptions (such as work order systems, CRM, knowledge bases, and object storage) for subtasks requiring cross-system access. Once the channel is successfully established, the system uses the session context as an anchor point to aggregate data sources and cached resources accessible to each assigned scenario agent, including but not limited to: historical work order records, knowledge entries and SOPs, user and device profiles, previous-hop intermediate outputs, channel and session metadata, etc., forming a unified context data set. This set is constrained by the field mapping of the task context diagram, ensuring consistency in field naming, type, and hierarchy between upstream outputs and downstream inputs, thereby providing a stable data view and traceable feedback channel for the subsequent collaborative inference stage, achieving a closed-loop connection from "dynamic assignment" to "data readiness."

[0068] In step S104, the system selects a collaborative mode based on task characteristics and constructs a corresponding collaborative topology: when the responsibility is singular, a single-hop routing table is generated using the routing mode; when cross-domain parallel analysis is performed, a collaborative mode is generated to create a set of parallel nodes; and when process-oriented processing is performed, a coordination mode is generated to create a sequence of sequential nodes. Subsequently, the context data set is rearranged or split according to the collaborative topology, and the scenario agent is triggered to execute node by node and the intermediate output is returned, and the candidate result set is aggregated.

[0069] In one embodiment, step S104 includes:

[0070] The context data set is subjected to task attribute evaluation processing to generate a collaborative decision vector;

[0071] The cooperative decision vector is subjected to pattern mapping processing to obtain a cooperative mode identifier; wherein, the cooperative mode identifier includes routing mode, cooperation mode and coordination mode;

[0072] A single-hop routing table is generated according to the routing mode, a parallel node set is generated according to the cooperation mode, and a sequential node sequence is generated according to the coordination mode, and then integrated to obtain a cooperative topology;

[0073] The collaborative topology is used to rearrange, copy, or split the context data set to obtain node input batches;

[0074] Based on the node input batch, the corresponding scenario agent is triggered according to the collaborative topology, and intermediate outputs are collected to obtain an intermediate output set;

[0075] The intermediate output set is subjected to pattern-consistent arrangement processing to generate a candidate result set.

[0076] In this embodiment, using the context data set as input, task attribute indicators are calculated for each subtask to be executed. These indicators include at least: task complexity, cross-domain nature (number of skills involved), dependency depth, real-time requirements, and uncertainty. Based on these indicators, a collaborative decision vector is assembled to characterize the objective features of the current subtask in the collaborative dimension. The collaborative decision vector is then mapped to determine the collaborative mode identifier. When the decision indicates clear responsibilities, shallow dependencies, and coverage by a single skill, it is mapped to a routing mode (Route), where the scheduler automatically routes messages or tasks to the single scenario agent with the highest matching degree. When the decision indicates a complex decision requiring the convergence of opinions from multiple domain experts, it is mapped to a collaborative mode (Collaborate), simultaneously activating multiple related scenario agents for parallel analysis and discussion, which is then summarized by the upper layer. When the decision indicates a strongly ordered, interlocking process, it is mapped to a coordinated mode (Coordinate), triggering different scenario agents sequentially according to a preset or dynamically generated order, ensuring that subsequent processing builds upon previous results.

[0077] After the collaborative mode identifier is determined, the system generates a corresponding collaborative topology: For routing mode, a single-hop routing table is constructed, recording the target Agent identifier, call route, return channel, timeout, and retry policy; for cooperative mode, a set of parallel nodes is constructed, each parallel node is assigned an independent session context, and an aggregation node for result aggregation and consistency verification is set; for coordination mode, a sequence of sequential nodes is constructed, and input / output field mappings and satisfied conditions (e.g., required fields, threshold judgments) are marked on the sequence edges to obtain executable timing constraints. After integration, a unified collaborative topology is obtained, serving as the execution blueprint for subsequent triggering and orchestration. Based on the collaborative topology, the context data set is organized. When in a set of parallel nodes, shared fields are copied and exclusive fields are split, generating node input batches for each parallel node; when in a single-hop or sequential node, data is rearranged and pruned according to field mapping relationships to ensure that upstream output and downstream input are consistent in field naming, type, and hierarchy, thus obtaining input batches divided by node.

[0078] After the node input batch is ready, the system triggers the corresponding scenario agent to execute one by one (or in parallel) according to the collaborative topology. During execution, intermediate outputs are sent back through the collaborative communication channel along with necessary metadata (timestamp, source node, evidence reference, etc.), accumulating to obtain an intermediate output set. When parallel paths exist, the intermediate outputs first complete alignment and conflict detection at the aggregation node before entering the unified integration process. Finally, the outputs generated by different modes are structurally merged and semantically aligned, including field alias mapping, unit, format standardization, evidence chain reference unification, and temporal rearrangement. The results of parallel branches are merged using a preset merging strategy (such as confidence weighting, majority consensus, or priority coverage) to generate candidate results for a single view. The results of sequential links are inherited and missing incomplete according to the topological order, outputting a candidate result set for subsequent evaluation and adaptive update processing.

[0079] In step S105, process evidence collection and consistency verification are carried out on the candidate result set. Messages between agents, external knowledge references and key point indexes are collected to construct evaluation samples. Measures such as integrity, consistency and time sequence compliance are calculated and evaluation signals are generated to drive the system to adaptively update (such as prompt word template parameters, scheduling weights or retrieval thresholds). After the update, the candidate results are reorganized to obtain an intermediate result set, realizing a closed loop of evaluation and parameter adjustment.

[0080] In one embodiment, step S105 includes:

[0081] Collect the subtask execution process corresponding to the candidate result set, and record the information exchange between the activated scenario agents to obtain the execution session;

[0082] Extract the external knowledge entries requested or provided by Agents in each scenario of the execution session to obtain an evidence set;

[0083] The key points of the evidence set and the candidate result set are indexed and aligned to generate evaluation samples;

[0084] The integrity metric, consistency metric, and temporal conformity metric of the evaluation samples are calculated separately and then integrated to obtain the original evaluation vector.

[0085] The original evaluation vector is normalized and thresholded to form discrete or continuous strength labels, thus obtaining the evaluation signal.

[0086] The parameters of at least one agent are updated based on the evaluation signal, and the candidate result set is reorganized to obtain an intermediate result set.

[0087] In this embodiment, the real-time dialogue and information exchange recorded by the collaborative communication bus are used as the main thread. The execution process of the sub-tasks corresponding to the candidate result set is collected to obtain the execution sessions arranged in chronological order. The execution session includes at least: the identifier of the activated scenario agent, the call route, the input and output summary, the message timestamp, and the transaction identifier. The cross-agent interactions generated through the bus are fully retained. For example, the equipment maintenance history and SOP retrieval requests initiated by the intelligent maintenance agent to the knowledge agent and their responses are recorded as structured events in the session for subsequent evidence collection and alignment processing. Then, evidence is extracted from the execution session to identify the external knowledge entries and reference fragments requested or provided by each scenario agent and to construct an evidence set. The evidence set includes, but is not limited to: knowledge base document number and fragment location, snapshot of query results from the business system (work order / CRM), hash fingerprint of OCR / ASR transcribed text, and reference relationship graph.

[0088] Furthermore, the system performs index alignment between the key points of the evidence set and the candidate result set to generate evaluation samples. Specifically, it uses the key fields of the candidate results as primary keys (such as conclusion items, disposal suggestion items, and instruction items) and retrieves corresponding supporting entries or cross-references in the evidence set. When multiple pieces of evidence exist, they are sorted by temporal proximity and source credibility, and a one-to-many mapping is established to ensure that the samples cover all the core information and key references of the candidate results. After the evaluation samples are generated, the system calculates multi-dimensional quantities to form the original evaluation vector: First, the completeness measure is calculated based on the coverage ratio of candidate points and evidence support, the field missing ratio, and the reference breakpoint ratio; second, the consistency measure is calculated based on the conflict rate between cross-agent outputs, the value difference of the same field, and the consistency verification results of the evidence content; third, the temporal conformity measure is calculated based on the temporal satisfaction rate from upstream output to downstream consumption in the dependency chain and the causal consistency of the event sequence within the session. These measurement vectors are attached to the corresponding candidate points in the form of standardized fields, serving as input for subsequent threshold mapping. Then, normalization and threshold mapping are performed on the original evaluation vector: each metric is normalized to the [0,1] interval using interval scaling or piecewise linear functions, and discrete or continuous strength and weakness labels are generated according to the preset threshold strategy to obtain the evaluation signal; the evaluation signal is represented in the form of a quadruple of "key point identifier - dimension label - strength and weakness label - confidence level", which is used to indicate the compliance status of the current candidate result in the three dimensions of completeness, consistency and time sequence.

[0089] After the evaluation signal is generated, the system updates the parameters of at least one agent online and restructures the candidate results to obtain an intermediate result set: when the integrity flag is below the threshold, the similarity threshold and recall cap of the retrieval agent are fine-tuned; when the consistency flag is abnormal, the template parameters or collaborative aggregation weights of the master agent are adjusted; when the timing is insufficient, the routing, retry, and cooldown time parameters of the scheduler are modified. After the parameters are updated, the system reselects or integrates the intermediate outputs based on the latest parameters, retrieves or re-infers missing fields, re-solves conflicting items according to the consistency strategy, and outputs an intermediate result set with a calibrated structure and index.

[0090] In step S106, the intermediate result set is aggregated and its consistency is verified by sending back the results. According to the preset data template, the field naming, hierarchical structure and data type are unified, and the rule-based arrangement is completed. Finally, a task processing object is generated, which includes a user-facing receipt payload and an operation instruction description for the back-end business system (work order, CRM, outbound call, etc.) so that the front-end presentation and back-end linkage execution can be achieved.

[0091] In one embodiment, step S106 includes:

[0092] The intermediate result set is subjected to result back-to-back aggregation processing to obtain a result aggregation package;

[0093] The aggregated results are subjected to consistency verification to obtain a set that passes the verification.

[0094] The field names, hierarchical structure, and data types of the validation pass set are unified using a preset data template to obtain a unified structure draft;

[0095] The unified structure draft is processed by rule arrangement to obtain a structured scheme;

[0096] Based on the structured scheme, an object representation containing both user feedback payload and backend business system operation instruction description is generated to obtain the task processing object.

[0097] In this embodiment, the system performs result aggregation processing on the feedback results from each assigned scenario Agent based on the collaborative communication bus. Intermediate outputs and accompanying metadata (source node, timestamp, evidence pointer, field mapping) are collected one by one according to session identifier and topological order. Deduplication, dependency chain concatenation, and source tracing are performed to obtain a result aggregation package containing multi-source result details, indexes, and transaction information. This aggregation process is triggered and controlled by the result integrator on the master control side to uniformly incorporate scattered results into the integration channel. The result aggregation package then undergoes consistency verification: on the one hand, structural consistency verification (whether field naming / type / hierarchy meets unified specifications, whether required fields and reference relationships are complete); on the other hand, semantic consistency verification (whether cross-Agent conclusions conflict, whether the evidence chain matches the corresponding key points, and whether the time series meets causal constraints). Records that pass all verifications are converged into a verified set; items that fail are marked according to a preset strategy and rolled back to the previous step or set to a pending completion state, not entering the current object generation stream.

[0098] Furthermore, the system utilizes preset data templates to unify field names, hierarchical structures, and data types: based on the unified data specification of "channel independence," alias fields are mapped and their units, codes, and time formats are standardized; records are organized into hierarchical paragraphs such as "task summary - evidence points - handling suggestions - action description - visual reference" according to the template definition, resulting in a unified structure draft covering commonalities on both the user and system sides. On this basis, the unified structure draft undergoes rule-based arrangement processing, i.e., applying business rules and display rules to generate a structured solution. These rules include, but are not limited to: a) the information density and display order of user receipts (conclusion first, then evidence, then explanation); b) the transaction boundaries and atomicity decomposition of backend actions (such as the dependency order and timeout / retry strategy for work order creation - outbound call registration - status write-back); c) multi-channel receipt adaptation (payload format and word count / rich text capabilities for mini-programs / APPs / web pages).

[0099] Finally, based on the structured scheme, an object representation is generated, producing a task processing object. This object adopts a hierarchical structure and contains two types of payloads: one is the user feedback payload (a summary of the conclusion, processing progress, necessary visual references, and evidence summaries for front-end presentation); the other is a description of the back-end business system operation instructions (an action list, parameter mapping, transaction, and idempotent key for the work order system, CRM, or outbound call system), and a mapping is established with the channel feedback channel. Based on this, the master agent synchronously distributes the final solution or processing status to the user and the back-end business system through the intelligent execution and feedback system, realizing closed-loop feedback and service closure after result integration.

[0100] In summary, this invention achieves seamless execution of processes such as "acceptance-classification-execution-quality inspection follow-up-status write-back" without manual intervention by implementing standardized access through multiple channels, master agent intent recognition and target decomposition, and scheduler assignment of scenario agents based on skills and dependencies. Furthermore, it achieves closed-loop orchestration with traceable processes on a collaborative communication bus. This results in an automation rate exceeding 80% for key nodes such as work order acceptance, effectively reducing manpower and stabilizing latency. Different sub-tasks are independently executed by specialized scenario agents with domain knowledge and tool access capabilities. Evaluation signals are generated through evidence extraction, key point alignment, and consistency verification, driving adaptive updates to routing weights, prompt word templates, or retrieval thresholds, forming a continuously optimized decision-making chain. This improves the accuracy of judgments in key stages such as work order classification and risk identification to over 95%.

[0101] This invention also significantly enhances system maintainability: it adopts a modular system of "master control agent + scenario agent pool + collaborative communication bus", and new capabilities are accessed by adding or replacing scenario agents without changing the core orchestration process; at the same time, the parameter-level updates driven by evaluation signals reduce the amount of manual rule maintenance, reducing the overall maintenance workload by about 50%, and shortening the new business launch cycle from several weeks to several days.

[0102] Combination Figure 2 As shown, Figure 2 A schematic block diagram of a multi-agent-based task processing device provided in an embodiment of the present invention. The multi-agent-based task processing device 200 includes:

[0103] The data receiving unit 201 is used to receive user service requests and parse the user service requests to obtain task request objects;

[0104] The intent recognition unit 202 is used to recognize the intent of the task request object and decompose the target according to the recognition result to construct a task context map.

[0105] Resource orchestration unit 203 is used to orchestrate resources in the task context diagram based on a preset multi-agent scheduling to obtain a context data set;

[0106] The collaborative reasoning unit 204 is used to perform collaborative reasoning on the context data set to generate a candidate result set;

[0107] The data scheduling unit 205 is used to evaluate the candidate result set, update the evaluation signal, adjust the parameters of at least one agent based on the evaluation signal, and integrate to obtain an intermediate result set.

[0108] The object output unit 206 is used to perform format unification processing on the intermediate result set and generate a task processing object corresponding to the task request object.

[0109] In this embodiment, the data receiving unit 201 receives a user service request and parses the user service request to obtain a task request object; the intent recognition unit 202 performs intent recognition on the task request object and decomposes the target according to the recognition result to construct a task context map; the resource orchestration unit 203 performs resource orchestration on the task context map based on a preset multi-agent scheduling to obtain a context data set; the collaborative reasoning unit 204 performs collaborative reasoning on the context data set to generate a candidate result set; the data scheduling unit 205 evaluates the candidate result set and updates the obtained evaluation signal, adjusts the parameters of at least one agent based on the evaluation signal, and integrates to obtain an intermediate result set; the object output unit 206 performs format unification processing on the intermediate result set to generate a task processing object corresponding to the task request object.

[0110] In one embodiment, the data receiving unit 201 is specifically used for:

[0111] Input streams from multiple channels are processed to obtain the original request packets;

[0112] The message payload is obtained by parsing the header and payload structure of the original request packet respectively.

[0113] Based on the message payload, determine the modal tags of text, voice, and image, and extract the corresponding content units to obtain structured units;

[0114] The structured units are standardized and transformed to obtain standardized task data;

[0115] The standardized task data is instantiated and constructed to generate a task request object.

[0116] In one embodiment, the intent recognition unit 202 is specifically used for:

[0117] The task request objects are segmented, part-of-speech tagging is performed, and slot extraction is performed to obtain semantic representations;

[0118] The semantic representation is subjected to intent classification and inference processing, and core intent tags are determined based on a preset intent set;

[0119] Locate the target decomposition template corresponding to the core intent tag from the preset task template library;

[0120] The target decomposition template is used to generate a corresponding set of subtasks;

[0121] The set of subtasks is subjected to dependency construction processing to determine directed dependency pairs based on the input and output constraints of each subtask, thereby obtaining a topological sequence;

[0122] The topological sequence is instantiated into a graph structure to construct the corresponding task context graph.

[0123] In one embodiment, the resource orchestration unit 203 is specifically used for:

[0124] The task context diagram is processed by a preset Agent scheduler to extract subtasks, resulting in a subtask list.

[0125] Extract the task type, urgency level, and required skills of each subtask in the subtask list to obtain an attribute table;

[0126] Based on the attribute table, at least one candidate scenario agent is selected from the preset scenario agent pool to obtain a candidate set;

[0127] The candidate set is subjected to matching and scoring calculation to generate corresponding assignment mapping parameters;

[0128] The assignment mapping parameters are initialized to establish a call route and session context, thereby obtaining an interaction channel.

[0129] The data sources associated with the assigned scenario Agent in the interaction channel are aggregated to obtain a context data set.

[0130] In one embodiment, the collaborative reasoning unit 204 is specifically used for:

[0131] The context data set is subjected to task attribute evaluation processing to generate a collaborative decision vector;

[0132] The cooperative decision vector is subjected to pattern mapping processing to obtain a cooperative mode identifier; wherein, the cooperative mode identifier includes routing mode, cooperation mode and coordination mode;

[0133] A single-hop routing table is generated according to the routing mode, a parallel node set is generated according to the cooperation mode, and a sequential node sequence is generated according to the coordination mode, and then integrated to obtain a cooperative topology;

[0134] The collaborative topology is used to rearrange, copy, or split the context data set to obtain node input batches;

[0135] Based on the node input batch, the corresponding scenario agent is triggered according to the collaborative topology, and intermediate outputs are collected to obtain an intermediate output set;

[0136] The intermediate output set is subjected to pattern-consistent arrangement processing to generate a candidate result set.

[0137] In one embodiment, the data scheduling unit 205 is specifically used for:

[0138] Collect the subtask execution process corresponding to the candidate result set, and record the information exchange between the activated scenario agents to obtain the execution session;

[0139] Extract the external knowledge entries requested or provided by Agents in each scenario of the execution session to obtain an evidence set;

[0140] The key points of the evidence set and the candidate result set are indexed and aligned to generate evaluation samples;

[0141] The integrity metric, consistency metric, and temporal conformity metric of the evaluation samples are calculated separately and then integrated to obtain the original evaluation vector.

[0142] The original evaluation vector is normalized and thresholded to form discrete or continuous strength labels, thus obtaining the evaluation signal.

[0143] The parameters of at least one agent are updated based on the evaluation signal, and the candidate result set is reorganized to obtain an intermediate result set.

[0144] In one embodiment, the object output unit 206 is specifically used for:

[0145] The intermediate result set is subjected to result back-to-back aggregation processing to obtain a result aggregation package;

[0146] The aggregated results are subjected to consistency verification to obtain a set that passes the verification.

[0147] The field names, hierarchical structure, and data types of the validation pass set are unified using a preset data template to obtain a unified structure draft;

[0148] The unified structure draft is processed by rule arrangement to obtain a structured scheme;

[0149] Based on the structured scheme, an object representation containing both user feedback payload and backend business system operation instruction description is generated to obtain the task processing object.

[0150] Since the embodiments of the apparatus and the embodiments of the method correspond to each other, please refer to the description of the embodiments of the method for the embodiments of the apparatus, which will not be repeated here.

[0151] This invention also provides a computer-readable storage medium storing a computer program thereon, which, when executed, can perform the steps provided in the above embodiments. The storage medium may include various media capable of storing program code, such as a USB flash drive, a portable hard drive, a read-only memory (ROM), a random access memory (RAM), a magnetic disk, or an optical disk.

[0152] This invention also provides a computer device, which may include a memory and a processor. The memory stores a computer program, and when the processor calls the computer program in the memory, it can implement the steps provided in the above embodiments. Of course, the computer device may also include various network interfaces, a power supply, a graphics card, etc., to utilize the graphics card's performance to operate the model, such as for inference and training.

[0153] The various embodiments in this specification are described in a progressive manner, with each embodiment focusing on its differences from other embodiments. Similar or identical parts between embodiments can be referred to interchangeably. For the systems disclosed in the embodiments, since they correspond to the methods disclosed in the embodiments, the descriptions are relatively simple; relevant parts can be referred to in the method section. It should be noted that those skilled in the art can make various improvements and modifications to this application without departing from the principles of this application, and these improvements and modifications also fall within the protection scope of the claims of this application.

[0154] It should also be noted that, in this specification, relational terms such as "first" and "second" are used only to distinguish one entity or operation from another, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Furthermore, the terms "comprising," "including," or any other variations thereof are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. Without further limitations, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes said element.

Claims

1. A multi-agent-based task processing method, characterized in that, include: Receive user service requests and parse the user service requests to obtain task request objects; The task request object is subjected to intent recognition, and the target is decomposed based on the recognition results to construct a task context map; Based on a preset multi-agent scheduling, the task context diagram is orchestrated to obtain a context data set. Collaborative reasoning is performed on the context data set to generate a candidate result set. This includes evaluating the context data set for task attributes to generate a collaborative decision vector; performing pattern mapping on the collaborative decision vector to obtain a collaborative mode identifier; wherein the collaborative mode identifier includes a routing mode, a cooperation mode, and a coordination mode; generating a single-hop routing table based on the routing mode, generating a parallel node set based on the cooperation mode, and generating a sequential node sequence based on the coordination mode, and integrating them to obtain a collaborative topology; rearranging, copying, or splitting the context data set using the collaborative topology to obtain node input batches; triggering corresponding scenario agents based on the node input batches according to the collaborative topology and collecting intermediate outputs to obtain an intermediate output set; and performing pattern-consistent orchestration on the intermediate output set to generate a candidate result set. The candidate result set is evaluated, and an evaluation signal is updated. Based on the evaluation signal, the parameters of at least one agent are adjusted, and an intermediate result set is obtained. This includes collecting the execution process of the sub-tasks corresponding to the candidate result set and recording the information exchange between activated scene agents to obtain an execution session; extracting external knowledge entries requested or provided by each scene agent in the execution session to obtain an evidence set; indexing and aligning the evidence set with the key points of the candidate result set to generate evaluation samples; calculating the integrity metric, consistency metric, and temporal compliance metric of the evaluation samples respectively, and integrating them to obtain an original evaluation vector; normalizing and threshold mapping the original evaluation vector to form discrete or continuous strength labels to obtain an evaluation signal; updating the parameters of at least one agent based on the evaluation signal, and reorganizing the candidate result set to obtain an intermediate result set. The intermediate result set is formatted uniformly to generate a task processing object corresponding to the task request object.

2. The multi-agent-based task processing method according to claim 1, characterized in that, The process of receiving a user service request and parsing the user service request to obtain a task request object includes: Input streams from multiple channels are processed to obtain the original request packets; The message payload is obtained by parsing the header and payload structure of the original request packet respectively. Based on the message payload, determine the modal tags of text, voice, and image, and extract the corresponding content units to obtain structured units; The structured units are standardized and transformed to obtain standardized task data; The standardized task data is instantiated and constructed to generate a task request object.

3. The multi-agent-based task processing method according to claim 1, characterized in that, The step of performing intent recognition on the task request object and decomposing the target based on the recognition results to construct a task context map includes: The task request objects are segmented, part-of-speech tagging is performed, and slot extraction is performed to obtain semantic representations; The semantic representation is subjected to intent classification and inference processing, and core intent tags are determined based on a preset intent set; Locate the target decomposition template corresponding to the core intent tag from the preset task template library; The target decomposition template is used to generate a corresponding set of subtasks; The set of subtasks is subjected to dependency construction processing to determine directed dependency pairs based on the input and output constraints of each subtask, thereby obtaining a topological sequence; The topological sequence is instantiated into a graph structure to construct the corresponding task context graph.

4. The multi-agent-based task processing method according to claim 1, characterized in that, The resource orchestration of the task context graph based on the preset multi-agent scheduling yields a context data set, including: The task context diagram is processed by a preset Agent scheduler to extract subtasks, resulting in a subtask list. Extract the task type, urgency level, and required skills of each subtask in the subtask list to obtain an attribute table; Based on the attribute table, at least one candidate scenario agent is selected from the preset scenario agent pool to obtain a candidate set; The candidate set is subjected to matching and scoring calculation to generate corresponding assignment mapping parameters; The assignment mapping parameters are initialized to establish a call route and session context, thereby obtaining an interaction channel. The data sources associated with the assigned scenario Agent in the interaction channel are aggregated to obtain a context data set.

5. The multi-agent-based task processing method according to claim 1, characterized in that, The step of standardizing the format of the intermediate result set to generate a task processing object corresponding to the task request object includes: The intermediate result set is subjected to result back-to-back aggregation processing to obtain a result aggregation package; The aggregated results are subjected to consistency verification to obtain a set that passes the verification. The field names, hierarchical structure, and data types of the validation pass set are unified using a preset data template to obtain a unified structure draft; The unified structure draft is processed by rule arrangement to obtain a structured scheme; Based on the structured scheme, an object representation containing both user feedback payload and backend business system operation instruction description is generated to obtain the task processing object.

6. A multi-agent-based task processing device, characterized in that, include: The data receiving unit is used to receive user service requests and parse the user service requests to obtain task request objects. An intent recognition unit is used to recognize the intent of the task request object and decompose the target based on the recognition result to construct a task context map. The resource orchestration unit is used to orchestrate the task context diagram based on a preset multi-agent scheduling to obtain a context data set. A collaborative reasoning unit is used to perform collaborative reasoning on the context data set to generate a candidate result set; A data scheduling unit is used to evaluate the candidate result set, update the evaluation signal, adjust the parameters of at least one agent based on the evaluation signal, and integrate to obtain an intermediate result set. An object output unit is used to perform format unification processing on the intermediate result set and generate a task processing object corresponding to the task request object. The collaborative reasoning unit is specifically used to perform task attribute evaluation processing on the context data set to generate a collaborative decision vector; perform pattern mapping processing on the collaborative decision vector to obtain a collaborative mode identifier; wherein, the collaborative mode identifier includes a routing mode, a cooperation mode, and a coordination mode; generate a single-hop routing table according to the routing mode, generate a parallel node set according to the cooperation mode, and generate a sequential node sequence according to the coordination mode, and integrate them to obtain a collaborative topology; use the collaborative topology to rearrange, copy, or split the context data set to obtain a node input batch; trigger the corresponding scenario agent according to the collaborative topology based on the node input batch and collect intermediate outputs to obtain an intermediate output set; perform pattern consistency orchestration processing on the intermediate output set to generate a candidate result set. The data scheduling unit is specifically used to collect the sub-task execution process corresponding to the candidate result set, and record the information exchange between the activated scenario agents to obtain an execution session; extract the external knowledge entries requested or provided by each scenario agent in the execution session to obtain an evidence set; index and align the evidence set with the key points of the candidate result set to generate evaluation samples; calculate the integrity metric, consistency metric, and temporal compliance metric of the evaluation samples respectively, and integrate them to obtain an original evaluation vector; normalize and threshold map the original evaluation vector to form discrete or continuous strong and weak labels to obtain an evaluation signal; update the parameters of at least one agent based on the evaluation signal, and reorganize the candidate result set to obtain an intermediate result set.

7. A computer device, characterized in that, It includes a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to implement the multi-agent-based task processing method as described in any one of claims 1 to 5.

8. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores a computer program that, when executed by a processor, implements the multi-agent-based task processing method as described in any one of claims 1 to 5.

Images