Task processing method and device based on end-cloud collaboration

By introducing AgentOS into the in-vehicle intelligent cockpit system, dynamic registration, task decomposition, and collaborative scheduling of multiple agents are realized, solving the problems of lack of multi-agent collaboration mechanism and low resource utilization efficiency in the existing technology, thereby improving task processing efficiency and user experience.

CN121728096APending Publication Date: 2026-03-24FAW CAR CO LTD
View PDF 0 Cites 1 Cited by

Patent Information

Application Number
CN202610023649.8
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Filing Date
2026-01-08
Publication Date
2026-03-24

AI Technical Summary

Technical Problem

The lack of multi-agent collaboration mechanisms, coarse-grained edge-cloud collaboration, heterogeneous agent operating environments, and fragmented context states in existing in-vehicle intelligent cockpit systems result in low efficiency in processing complex intents, numerous interaction rounds, inconsistent user experience, low resource utilization efficiency, and slow response speed.

Method used

By deploying an intelligent agent operating system (AgentOS) in the in-vehicle intelligent cockpit system, dynamic registration of multiple agents, task decomposition, collaborative scheduling, edge-cloud hybrid execution, and context consistency management are achieved. Core services such as task flow engine, collaborative scheduler, and context manager are adopted to achieve dynamic task decomposition and node-level fine-grained scheduling. Resource utilization and context synchronization are optimized through hybrid communication and incremental synchronization mechanisms.

Benefits of technology

It improved task processing efficiency, optimized edge-cloud resource utilization, reduced invalid network requests, enhanced the accuracy of personalized services and user experience, and significantly improved the system's response speed and consistency.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN121728096A_ABST
    Figure CN121728096A_ABST
Patent Text Reader

Abstract

The invention provides a task processing method and device based on end-cloud collaboration, is applied to a multi-agent collaboration system based on end-cloud collaboration, and relates to the technical field of data processing. The method comprises the following steps: firstly, converting user input into a structured intention message, and decomposing the structured intention message into a directed acyclic graph task flow; then, based on task node requirements and agent state information, dynamically allocating agents on the end side or the cloud to execute corresponding tasks; in the execution process, maintaining a global context state tree and realizing incremental synchronization between end clouds; and finally, all task results are fused and fed back to the user. Dynamic decomposition and node-level fine-grained scheduling of the composite task are realized, and the task processing efficiency is improved; end cloud resource utilization is optimized, and invalid network requests are reduced; and through context increment synchronization, the accuracy of personalized services is improved, and the user experience is remarkably enhanced.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] This invention relates to the field of data processing technology, and in particular to a task processing method and apparatus based on edge-cloud collaboration. Background Technology

[0002] With the increasing prevalence of intelligent connected vehicles, in-vehicle intelligent cockpits need to handle complex user requests, such as complex intents involving multiple sub-tasks, like "find a restaurant and make a reservation." Currently, the industry adopts an edge-cloud collaborative architecture, using lightweight models on the device side and large models in the cloud to jointly complete task processing.

[0003] However, existing solutions have significant shortcomings: First, the system lacks dynamic task decomposition capabilities, failing to automatically break down complex intentions into ordered sub-task flows, resulting in slow response times when handling complex requests; second, task scheduling is coarse-grained, only supporting a binary decision of "all tasks on the cloud" or "all tasks locally," unable to achieve fine-grained division of labor between the edge and cloud based on the characteristics of sub-tasks; finally, the lack of a unified context management mechanism prevents edge-cloud agents from maintaining state synchronization, affecting service continuity. These problems severely restrict the intelligence level of in-vehicle systems, leading to low resource utilization efficiency, slow response speed, and poor user experience.

[0004] Therefore, there is an urgent need for a new task processing method that can achieve dynamic task decomposition, fine-grained scheduling, and context consistency. Summary of the Invention

[0005] The purpose of this invention is to provide a task processing method and apparatus based on edge-cloud collaboration, which realizes dynamic decomposition of composite tasks and fine-grained scheduling at the node level, thereby improving task processing efficiency; optimizes edge-cloud resource utilization and reduces invalid network requests; and improves the accuracy of personalized services through context incremental synchronization, thereby significantly enhancing user experience.

[0006] In a first aspect, the present invention provides a task processing method based on edge-cloud collaboration, applied to a multi-agent collaborative system based on edge-cloud collaboration; the system includes: multiple agents; the agents are deployed on the edge or in the cloud; the method includes: It receives user input information and converts the input information into structured intent messages based on the pre-set speech recognition agent on the device. Based on the pre-defined intent recognition agent on the edge, the intent message is decomposed into a directed acyclic graph task flow containing multiple task nodes; wherein, the directed acyclic graph task flow includes the dependency relationships between task nodes. The task node of the directed acyclic graph task flow is traversed by a pre-set collaborative scheduler on the edge to determine the resource requirements and execution location suggestions of the task node, and the state information of each pre-set agent is obtained based on the agent registration list; wherein, the state information includes at least one of the following: capability tag, running location and real-time system status; Based on the resource requirements and execution location suggestions of task nodes, as well as the state information of the agents, each task node is dynamically assigned to the agent with the corresponding function for execution. During execution, a global context state tree is maintained based on a preset context manager, and the changes in context state are synchronized between the edge and the cloud through an incremental synchronization mechanism. After all task nodes have been executed, a preset result fusion node triggers a preset fusion agent to fuse the results, generate a final response, and then feed it back to the user through a preset output agent on the device side.

[0007] In some preferred embodiments of the present invention, the step of decomposing an intent message into a directed acyclic graph task flow containing multiple task nodes based on a pre-defined intent recognition agent on the edge includes: The intent recognition intelligent agent is a lightweight natural language understanding model deployed on the client side, which identifies the task type and key entity parameters from the intent message; Based on the task flow engine, the corresponding task flow template is called from the pre-set task template library according to the task type, and the template is instantiated using key entity parameters to generate a directed acyclic graph task flow.

[0008] In some preferred embodiments of the present invention, the real-time system state includes: the current CPU load and memory usage of the edge agent, and the current network latency between the edge and the cloud; the step of dynamically assigning each task node to an agent with a corresponding function for execution includes: The resource requirements of the task node are matched with the capability tags recorded in the agent registration list to determine the candidate agents that are successfully matched. Prioritize agents whose running location matches the execution location suggestion of the task node; if there are multiple candidate agents that match the running location suggestion, select the agent whose real-time system status indicates that the load is below a preset threshold.

[0009] In some preferred embodiments of the present invention, if the execution location of the task node is suggested to be the cloud and the current network latency is higher than a preset latency threshold, the task node is reassigned to the corresponding intelligent agent on the edge for execution.

[0010] In some preferred embodiments of the present invention, if the execution location of the task node is suggested to be on the edge and the current network latency is lower than a preset latency threshold, the task node is reassigned to the corresponding intelligent agent in the cloud for execution.

[0011] In some preferred embodiments of the present invention, during execution, the steps of maintaining a global context state tree based on a preset context manager and synchronizing changes in the context state between the device and the cloud through an incremental synchronization mechanism include: During execution, when any agent updates the local context, the context manager calculates the state changes of the context state tree caused by the update; The state changes generate differential patch data, which is then sent to the agent running on the other side via the cloud-edge collaboration interface.

[0012] In some preferred embodiments of the present invention, the method further includes: If the agent assigned to the task node does not return a valid result after execution, or if there is no agent in the agent registration list that supports the task node's requirements, then return status information containing an error status or an empty result to the result fusion node.

[0013] In some preferred embodiments of the present invention, the communication between agents in the system adopts a hybrid communication mechanism; the hybrid communication mechanism includes: a first communication mode and a second communication mode; the first communication mode is used to transmit control messages and metadata; the second communication mode is used to transmit large blocks of data generated during task execution; wherein, agents deployed in different physical locations communicate through the first communication mode, and agents deployed in the same computing unit communicate through the second communication mode.

[0014] In some preferred embodiments of the present invention, the agent runs in an independent agent container, which provides the agent with an isolated operating environment, resource quota management and lifecycle control.

[0015] Secondly, the present invention provides a task processing device based on edge-cloud collaboration, applied to a multi-agent collaborative system based on edge-cloud collaboration; the system includes: multiple agents; the agents are deployed on the edge or in the cloud; the device includes: The input data processing module is used to receive user input information and convert the input information into structured intent messages based on the pre-set speech recognition agent on the device side. The task decomposition module is used to decompose intent messages into directed acyclic graph task flows containing multiple task nodes based on the intent recognition agent preset on the edge side; wherein, the directed acyclic graph task flow includes the dependency relationships between task nodes. The agent determination module is used to traverse each task node of the directed acyclic graph task flow through a pre-set collaborative scheduler on the edge, determine the resource requirements and execution location suggestions of the task nodes, and obtain the state information of each pre-set agent based on the agent registration list; wherein, the state information includes at least one of the following: capability tag, running location, and real-time system status; The task execution module is used to dynamically allocate each task node to the corresponding intelligent agent for execution based on the resource requirements and execution location suggestions of the task node, as well as the state information of the intelligent agent. During the execution process, a global context state tree is maintained based on a preset context manager, and the changes in the context state are synchronized between the edge and the cloud through an incremental synchronization mechanism. The result feedback module is used to trigger a preset fusion agent to fuse the results after all task nodes have been executed, generate a final response, and then feed it back to the user through a preset output agent on the device side.

[0016] This invention brings the following beneficial effects: This invention provides a task processing method and apparatus based on edge-cloud collaboration, applied to a multi-agent collaborative system based on edge-cloud collaboration; the system includes: multiple agents; the agents are deployed on the edge or in the cloud; the method includes: receiving user input information; converting the input information into a structured intent message based on a pre-set speech recognition agent on the edge; decomposing the intent message into a directed acyclic graph task flow containing multiple task nodes based on a pre-set intent recognition agent on the edge; wherein the directed acyclic graph task flow includes dependencies between task nodes; traversing each task node of the directed acyclic graph task flow through a pre-set collaborative scheduler on the edge, determining the resource requirements and execution location suggestions of the task nodes, and obtaining the state information of each pre-set agent based on an agent registration list; wherein the state information includes at least one of the following: capability markers. The system dynamically assigns task nodes to corresponding agents based on their resource requirements, execution location, and real-time system status. During execution, a global context state tree is maintained using a pre-defined context manager, and context state changes are synchronized between the device and cloud via an incremental synchronization mechanism. After all task nodes have completed execution, a pre-defined result fusion node triggers a pre-defined fusion agent to fuse the results, generate a final response, and provide feedback to the user through a pre-defined output agent on the device. This system achieves dynamic decomposition of complex tasks and fine-grained scheduling at the node level, improving task processing efficiency. It also optimizes the utilization of device and cloud resources, reducing invalid network requests. Furthermore, incremental context synchronization improves the accuracy of personalized services, significantly enhancing the user experience. Attached Figure Description

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

[0018] Figure 1 A flowchart illustrating a task processing method based on edge-cloud collaboration provided in an embodiment of the present invention; Figure 2 This is a schematic diagram of a task processing device based on edge-cloud collaboration provided in an embodiment of the present invention.

[0019] Icons: 310 - Input data processing module; 320 - Task decomposition module; 330 - Agent determination module; 340 - Task execution module; 350 - Result feedback module. Detailed Implementation

[0020] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. The components of the embodiments of the present invention described and shown in the accompanying drawings can generally be arranged and designed in various different configurations.

[0021] Therefore, the following detailed description of the embodiments of the invention provided in the accompanying drawings is not intended to limit the scope of the claimed invention, but merely to illustrate selected embodiments of the invention. All other embodiments obtained by those skilled in the art based on the embodiments of the invention without inventive effort are within the scope of protection of the invention.

[0022] It should be noted that similar labels and letters in the following figures indicate similar items. Therefore, once an item is defined in one figure, it does not need to be further defined and explained in subsequent figures.

[0023] In the description of this invention, it should be noted that the terms "center," "upper," "lower," "left," "right," "vertical," "horizontal," "inner," and "outer," etc., indicate the orientation or positional relationship based on the orientation or positional relationship shown in the accompanying drawings, or the orientation or positional relationship commonly used when the product of this invention is in use. They are only for the convenience of describing this invention and simplifying the description, and do not indicate or imply that the device or element referred to must have a specific orientation, or be constructed and operated in a specific orientation, and therefore should not be construed as a limitation of this invention. In addition, the terms "first," "second," "third," etc., are only used to distinguish descriptions and should not be construed as indicating or implying relative importance.

[0024] Furthermore, terms such as "horizontal," "vertical," and "sag" do not imply that components must be absolutely horizontal or suspended, but rather that they can be slightly tilted. For example, "horizontal" simply means that its direction is more horizontal relative to "vertical," and does not mean that the structure must be completely horizontal, but can be slightly tilted.

[0025] In the description of this invention, it should also be noted that, unless otherwise explicitly specified and limited, the terms "set," "install," "connect," and "link" should be interpreted broadly. For example, they can refer to a fixed connection, a detachable connection, or an integral connection; they can refer to a mechanical connection or an electrical connection; they can refer to a direct connection or an indirect connection through an intermediate medium; and they can refer to the internal connection of two components. Those skilled in the art can understand the specific meaning of the above terms in this invention based on the specific circumstances.

[0026] With the rapid development of intelligent connected vehicles and in-vehicle intelligent cockpit systems, users have placed higher demands on in-cabin human-machine interaction, scene perception, personalized services, and multimodal fusion capabilities. In recent years, Large Language Models (LLMs) and multi-agent architectures have been introduced into in-vehicle systems to improve the intelligence level of the cockpit. Against this backdrop, how to efficiently schedule multiple agents to collaboratively complete complex tasks has become a key challenge in the design of intelligent cockpit operating systems (such as AgentOS). Currently, the industry generally adopts an edge-cloud collaborative architecture of "lightweight models on the edge + large models in the cloud" to balance real-time performance and model capabilities.

[0027] However, some technical problems exist in existing technologies: (1) Lack of dynamic collaboration mechanism among multiple agents, resulting in rigid task flow: In existing solutions, agents usually work in a "single-point response" mode, that is, a user request is only processed by one agent (end or cloud), lacking the ability to negotiate, decompose tasks and merge results in real time among multiple agents. For example, when a user sends a complex intent such as "help me find a restaurant with high ratings and children's seats nearby and make a reservation for 7 pm tonight", the existing system often needs to interact multiple times or rely on a centralized scheduler to serially call multiple services, resulting in high response latency and fragmented user experience.

[0028] (2) The granularity of edge-cloud collaboration is coarse and the resource utilization efficiency is low: Current edge-cloud collaboration is mostly based on the binary decision of "all tasks on the cloud" or "all tasks locally", lacking fine-grained task decomposition and collaborative execution capabilities. For example, intent recognition can be completed on the edge, while semantic generation requires calling a large model in the cloud. However, existing systems are difficult to achieve this hybrid execution at the Agent level, resulting in unnecessary network transmission overhead or waste of edge computing power.

[0029] (3) The lack of a unified Agent runtime environment (AgentOS) leads to complex development and deployment: Agents with different functions (such as voice agent, navigation agent, entertainment agent) are usually developed by different teams and use heterogeneous frameworks (such as ROS, custom microservices, etc.), lacking a unified communication protocol, state management and lifecycle control mechanism. This not only increases the difficulty of system integration, but also limits the interoperability and dynamic replacement capability between agents.

[0030] (4) Context awareness and personalized memory are difficult to synchronize effectively between the end and the cloud: Context information such as user preferences and historical interaction records are usually stored separately on the end side (such as local cache) and the cloud (such as user profile database). Existing solutions lack a unified context management mechanism, which makes it impossible for the Agent to share a consistent user state during the collaboration process, affecting service continuity and personalization level.

[0031] The root of the aforementioned technical problems lies in the fact that existing in-vehicle systems still treat agents as isolated service units, rather than as a network of intelligent agents capable of collaborative evolution. Achieving efficient multi-agent end-to-cloud collaboration requires addressing multiple challenges simultaneously, including dynamic task decomposition, heterogeneous agent communication, context consistency maintenance, and low-latency scheduling. Especially in in-vehicle scenarios, network volatility, limited edge computing power, and functional safety requirements must also be considered, making it difficult to directly migrate traditional multi-agent solutions from cloud computing or mobile terminals.

[0032] This invention aims to address key technical bottlenecks in existing in-vehicle intelligent cockpit systems, such as the lack of multi-agent collaboration mechanisms, coarse-grained edge-cloud collaboration, heterogeneous agent operating environments, and fragmented context states. Specifically, it includes: (1) Solve the problem that the lack of dynamic negotiation and task coordination among multiple agents in the existing system leads to low efficiency in processing composite intents, many interaction rounds, and inconsistent user experience; (2) Solve the problem that the end-to-cloud collaboration only supports the coarse-grained task scheduling mode of "full end" or "full cloud", which cannot realize the fine-grained mixed execution of task sub-steps between the end side and the cloud agent, resulting in network bandwidth waste or end-to-end computing power idleness. (3) Solve the problems of heterogeneous development frameworks, incompatible communication protocols, and difficult lifecycle management caused by the lack of a unified runtime environment (AgentOS) for different functional Agents, and improve the maintainability and scalability of the system; (4) Solve the problem that user context information is stored in a scattered manner between the end and the cloud and cannot be synchronized in real time, which leads to inconsistent states and limited personalized service capabilities during multi-agent collaboration.

[0033] Solving these problems will collectively support the ability of in-vehicle intelligent cockpits to provide highly responsive, consistent, and intelligent services in complex scenarios.

[0034] This invention deploys a fully operational AgentOS within an in-vehicle intelligent cockpit system, enabling dynamic registration of multiple agents, task decomposition, collaborative scheduling, hybrid edge-cloud execution, and context consistency management. This method is executed collaboratively by a computer program on both the in-vehicle computing unit and a cloud server.

[0035] The following detailed description of some embodiments of the present invention is provided in conjunction with the accompanying drawings. Unless otherwise specified, the following embodiments and features can be combined with each other.

[0036] Example 1 This invention provides a task processing method based on edge-cloud collaboration, applied to a multi-agent collaborative system based on edge-cloud collaboration; the system includes: multiple agents; the agents are deployed on the edge or in the cloud.

[0037] Specifically, the multi-agent collaborative system based on edge-cloud collaboration constructs a unified agent operating system (AgentOS) as the runtime environment. On the edge, it is deployed on the in-vehicle computing unit, running lightweight agents such as speech recognition, intent recognition, and local map retrieval; on the cloud, it is deployed on a cloud server, running computationally intensive agents such as knowledge enhancement, appointment verification, and large language model dialogue management. Through core services provided by the AgentOS kernel, such as the task flow engine, collaborative scheduler, and context manager, unified registration, communication, and collaborative management of edge-cloud agents are achieved.

[0038] In some preferred embodiments of the present invention, the on-device (vehicle computing unit) includes: a Qualcomm SA8295P chip, comprising an 8-core CPU, Adreno GPU, and Hexagon NPU; 8GB LPDDR5 memory; an operating system of Android Automotive 13; and deployed agents including: - VoiceAgent: responsible for receiving microphone voice input; - ASRAgent: running a local ASR model (based on TensorFlow Lite, model size approximately 15MB); - IntentAgent: running a lightweight NLU model (based on ONNX format BERT-mini, approximately 22MB); - MapAgent: integrating the Gaode high-precision map SDK, supporting local POI retrieval; - OutputAgent: controlling TTS voice broadcasting and central control screen display; and AgentOS version v1.2, running as a system-level service on the Android system.

[0039] Cloud (Alibaba Cloud): Computing resources: ECS elastic computing instances; Large model service: Alibaba Cloud Bailian platform; Deployed agents include: - KnowledgeAgent: Connects to Dianping's open API and internal knowledge graph to obtain restaurant ratings and facility information; - ReservationAgent: Calls third-party reservation interfaces (such as Meituan Open Platform); - LLM-DM-Agent: Based on the Qwen-Max large language model, used to generate natural language responses; End-to-cloud communication uses the gRPCoverTLS1.3 protocol to ensure secure transmission.

[0040] See Figure 1 The flowchart shown in this embodiment of the invention provides a task processing method based on edge-cloud collaboration, the method including: Step S102: Receive user input information and convert the input information into a structured intent message based on the pre-set speech recognition agent on the device side.

[0041] Specifically, the system receives multimodal input from users via microphones, touchscreens, or cameras within the cabin. For example, if a user says, "Find me a restaurant nearby with a rating of 4.5 or higher, has child seats, and makes a reservation for 7 PM tonight," the voice recognition agent on the in-vehicle computing unit calls a locally deployed automatic voice recognition model (such as a lightweight model based on TensorFlow Lite) to convert the speech into text. This text, along with metadata such as timestamp, user ID, device ID, and current location, is then encapsulated into a structured intent message, represented in JSON format. For example: {"intent_type":"restaurant_recommendation_with_reservation","raw_text":"Find me a restaurant nearby with a rating of 4.5 or higher, has child seats, and makes a reservation for 7 PM tonight.","user_id":"U12345","device_id":"CAR_888","timestamp":1730123456,"location":{"lat":39.9042,"lng":116.4074}}. This standardized message format provides a unified input interface for subsequent intent parsing and task decomposition, ensuring the standardization of data interaction between various modules of the system.

[0042] Step S104: Based on the pre-set intent recognition agent on the edge, the intent message is decomposed into a directed acyclic graph task flow containing multiple task nodes; wherein, the directed acyclic graph task flow includes the dependency relationship between task nodes.

[0043] Specifically, the aforementioned intent message is sent to the intent recognition agent (IntentAgent) via the message bus within AgentOS. After receiving the intent message, the intent recognition agent invokes a locally deployed lightweight natural language understanding model (such as a BERT-mini model based on the ONNX format) to identify the main task type as "restaurant recommendation + reservation" and extracts key entities: rating threshold = 4.5, facility requirement = child seat, and reservation time = 7 pm tonight.

[0044] Furthermore, in some preferred embodiments of the present invention, the step of decomposing an intent message into a directed acyclic graph task flow containing multiple task nodes based on a pre-set intent recognition agent on the edge includes: the intent recognition agent calling a lightweight natural language understanding model deployed on the edge to identify the task type and key entity parameters from the intent message; based on the task flow engine, calling the corresponding task flow template from a pre-set task template library according to the task type, and instantiating the template using the key entity parameters to generate a directed acyclic graph task flow.

[0045] Specifically, after receiving the intent message, IntentAgent invokes a locally deployed lightweight Natural Language Understanding (NLU) model (e.g., a BERT-mini model based on the ONNX format) to identify the main task type as "restaurant recommendation + reservation" and extracts key entities: rating threshold = 4.5, facility requirement = child seat, and reservation time = 7 PM tonight. Subsequently, IntentAgent calls the TaskFlowEngine in the AgentOS framework layer. This engine has a built-in TaskTemplateLibrary containing a DAG template corresponding to "restaurant_recommendation_with_reservation". The engine instantiates this template based on the extracted entity parameters, generating a specific task flow graph with the following nodes and dependencies: Node A: Entity Normalization → Input the original entity, output structured parameters; Node B: Local POI search (LocalPOISearch) → Depends on A, calls the vehicle high-precision map SDK to query nearby restaurants; Node C: CloudKnowledgeEnrichment → Depends on A, calls the cloud knowledge graph API to obtain scores and facility details; Node D: Reservation Availability Verification (ReservationCheck) → Depends on C, calls the API of a third-party reservation platform; Node E: Result Fusion and Response Generation → Depends on B and D, calls the large language model to generate a natural language response.

[0046] Each node is labeled with a suggested execution location (device / cloud) and Quality of Service (QoS) requirements. For example, nodes C and D are labeled "execute in the cloud, latency tolerance ≤800ms". This dynamic task decomposition mechanism enables structured processing of complex intents, improving task processing efficiency by more than 40% compared to traditional hard-coded rules.

[0047] Step S106: By using a pre-set collaborative scheduler on the edge, traverse each task node of the directed acyclic graph task flow to determine the resource requirements and execution location suggestions of the task nodes, and obtain the state information of each pre-set agent based on the agent registration list; wherein, the state information includes at least one of the following: capability tag, running location, and real-time system status.

[0048] Specifically, AgentOS's CollaborativeScheduler traverses each node in the task flow graph and queries the Agent registry, including: the scheduler accesses the Agent registry maintained by the AgentOS kernel, which records metadata of all available Agents, including AgentID, function tag (such as "knowledge_search"), running location (end / cloud), current CPU load, memory usage, network status, etc.

[0049] Furthermore, in some preferred embodiments of the present invention, the real-time system status includes: the current CPU load, memory usage, and current network latency between the edge and the cloud of the intelligent agent; the step of dynamically assigning each task node to an intelligent agent with corresponding function includes: matching the resource requirements of the task node with the capability tags recorded in the intelligent agent registration list to determine the candidate intelligent agents that are successfully matched; preferentially selecting intelligent agents whose running position conforms to the execution position suggestion of the task node; wherein, if there are multiple candidate intelligent agents that conform to the running position suggestion, the intelligent agent whose real-time system status indicates that the load is lower than a preset threshold is selected.

[0050] Specifically, for nodes A and B, the scheduler detects the existence of "EntityNormalizationAgent" and "LocalMapAgent" on the edge, and their load is below a threshold (e.g., CPU < 60%), therefore assigning them to the edge for execution. For nodes C and D, the scheduler detects that "KnowledgeAgent" and "ReservationAgent" only exist in the cloud, and the current network latency is < 200ms, therefore sending the task request to the cloud through the cloud-edge collaboration interface. The scheduler can make optimal task allocation decisions, achieving fine-grained edge-cloud collaboration, reducing invalid network requests by 30% compared to the "all tasks to the cloud" solution.

[0051] Step S108: Based on the resource requirements and execution location suggestions of the task nodes, as well as the state information of the agents, each task node is dynamically assigned to the agent with the corresponding function for execution; during execution, a global context state tree is maintained based on a preset context manager, and the changes in the context state are synchronized between the edge and the cloud through an incremental synchronization mechanism.

[0052] Specifically, the scheduler sends execution instructions to each selected agent. Edge agents are launched in their local agent core containers; cloud agents are scheduled and executed by the cloud platform. Agents interact with each other using the communication protocol defined by AgentOS.

[0053] Furthermore, in some preferred embodiments of the present invention, the communication between agents in the system adopts a hybrid communication mechanism; the hybrid communication mechanism includes: a first communication mode and a second communication mode; the first communication mode is used to transmit control messages and metadata; the second communication mode is used to transmit large blocks of data generated during task execution; wherein, agents deployed in different physical locations communicate through the first communication mode, and agents deployed in the same computing unit communicate through the second communication mode.

[0054] Specifically, control messages (such as task parameters and status updates) are transmitted using gRPC over TLS encryption, ensuring control command latency of <10ms; large data blocks (such as map tiles and restaurant images) are transmitted via shared memory (on the device side) to achieve zero-copy data transmission. This hybrid communication mechanism ensures that the overall response speed meets the real-time requirements of in-vehicle systems (<1s).

[0055] Furthermore, in some preferred embodiments of the present invention, if the execution location of the task node is suggested to be the cloud and the current network latency is higher than a preset latency threshold, the task node is reassigned to the corresponding intelligent agent on the edge for execution.

[0056] Specifically, if the cloud-based KnowledgeAgent times out (>800ms), the POI scoring data cached on the device side will be used instead (cache validity period is 24 hours). For example, when a vehicle enters a tunnel and causes a network interruption, the knowledge enhancement task originally assigned to the cloud can be downgraded to be assigned to the POI data agent cached on the device side to ensure that the service is not interrupted.

[0057] Furthermore, in some preferred embodiments of the present invention, if the execution location of the task node is suggested to be on the edge and the current network latency is lower than a preset latency threshold, the task node is reassigned to the corresponding intelligent agent in the cloud for execution.

[0058] Specifically, when network conditions are good, computationally intensive tasks can be dynamically moved to the cloud for execution, making full use of the cloud's powerful computing capabilities to improve task processing speed.

[0059] Furthermore, in some preferred embodiments of the present invention, if the reservation interface is unavailable, node D is skipped and the reply indicates "online reservation is not currently supported"; if the terminal memory is less than 1GB, the AgentOS kernel triggers the LRU eviction mechanism to unload non-core Agents (such as entertainment agents) to ensure core functions such as navigation and voice.

[0060] Furthermore, in some preferred embodiments of the present invention, during execution, the step of maintaining a global context state tree based on a preset context manager and synchronizing the changes in context state between the edge and the cloud through an incremental synchronization mechanism includes: during execution, when any agent updates the local context, the context manager calculates the state change of the context state tree caused by the update; generates differential patch data from the state change; and sends the differential patch data to the agent running on the other side through the cloud-edge collaboration interface.

[0061] Specifically, during task execution, AgentOS's ContextManager maintains a global context state tree (ContextStateTree), whose structure consists of nested key-value pairs in JSON format. Whenever any Agent updates its local context (e.g., KnowledgeAgent writes "restaurant_rating=4.7"), the ContextManager triggers an incremental synchronization mechanism: calculating the difference between the old and new states (using the JSONPatch algorithm), generating a differential patch (e.g., {"op":"replace","path":" / preferences / restaurant_rating","value":4.7}), and synchronizing the patch to the peer (edge ​​→ cloud or cloud → edge) via the cloud-edge collaboration interface. This mechanism ensures that all participating Agents always perform inference based on a consistent user state. This mechanism reduces communication data volume by 60% and maintains context consistency even in weak network environments.

[0062] Furthermore, in some preferred embodiments of the present invention, differential updates mainly include: calculating state differences using the JSONPatch algorithm; GZIP compression of patch data; dynamically adjusting the synchronization frequency according to network quality: real-time synchronization under Wi-Fi, and synchronization every 2 seconds under 4G; and enabling the local cached version when synchronization fails to ensure uninterrupted service.

[0063] Step S110: After all task nodes have been executed, a preset result fusion node triggers a preset fusion agent to fuse the results, generate a final response, and feed it back to the user through a preset output agent on the device side.

[0064] Specifically, once all dependent nodes are complete, the result fusion node E is triggered. This node calls the large language model dialogue management agent (LLM-DMAgent) deployed in the cloud, with inputs including: a local list of POIs, cloud-based augmentation information, and user preference context. LLM-DMAgent generates a natural language response text: "Found 'Sunny Family Restaurant' for you, rating 4.7, supports child seats, and has made a reservation for you tonight at 7 pm." This text is returned to the client side via the cloud-edge interface.

[0065] Furthermore, in some preferred embodiments of the present invention, the output agent on the device side receives the reply text, calls a local TTS engine (such as eSpeak or a manufacturer-customized engine) to convert it into speech, and broadcasts it through the in-vehicle audio system. Simultaneously, the reply text is displayed on the central control screen. The task flow engine marks the entire task flow as "completed" and releases related resources. The context manager persists key information from this interaction (such as the successfully booked restaurant ID) to a local SQLite database for use in subsequent sessions.

[0066] Furthermore, in some preferred embodiments of the present invention, the method further includes: if the agent assigned to the task node does not return a valid result after execution, or if there is no agent in the agent registration list that supports the requirements of the task node, then return status information containing an error status or an empty result to the result fusion node.

[0067] Specifically, for example, when the reservation interface is unavailable, the reservation verification agent returns the status information "online reservation is not supported at the moment," and the result fusion node will indicate this situation when generating the response to ensure the robustness of the system.

[0068] Furthermore, in some preferred embodiments of the present invention, the agent runs in an independent agent container, which provides the agent with an isolated operating environment, resource quota management, and lifecycle control.

[0069] Specifically, each agent runs in an independent agent core container, possessing standardized capabilities such as event processing, message flow, state machine management, context isolation, and plugin loading. This containerized architecture achieves fault isolation and hot-swapping; the failure of a single agent does not affect the overall system, significantly enhancing system stability. It also supports hot updates and dynamic replacement of agents, shortening the development cycle by approximately 35%.

[0070] Furthermore, tests were conducted on 100 similar requests in a real vehicle environment, and the results are as follows: the average task completion time of the proposed solution is 820 milliseconds; the average time of the traditional serial solution (all steps are executed sequentially without parallelism) is 1450 milliseconds; the average number of cloud API calls per request for this solution is 2.1, while that for the traditional solution is 3.8; the amount of network data transmitted is reduced from 45KB to 18KB; and the user satisfaction score (out of 5) is improved from 3.9 to 4.6.

[0071] It should be noted that each agent's state includes: INIT (initialization), RUNNING (running), PAUSED (paused), and TERMINATED (terminated). State transitions are event-driven: INIT → (initialization complete) → RUNNING; RUNNING → (received pause command) → PAUSED; PAUSED → (received resume command) → RUNNING; RUNNING → (task completed or encountered an error) → TERMINATED. State changes are broadcast via the AgentOS internal event bus for monitoring modules to subscribe to.

[0072] Furthermore, in some preferred embodiments of the present invention, the core logic of the cloud-edge collaboration interface includes: when the endpoint calls the submit_task_to_cloud method, the following operations are performed: a. serialize the task node into Protobuf binary format; b. send it to the cloud via gRPCstub; c. wait for a response, with a timeout period of max_latency_ms marked on the node; d. deserialize and return the result, and deliver it to the downstream Agent.

[0073] Furthermore, in some preferred embodiments of the present invention, the task is persistently stored: the status of incomplete task flows is serialized in Protobuf format and stored in the task_flows table of the SQLite database, with fields including: flow_id (unique ID of the task flow), user_id (associated user), dag_proto_blob (serialized DAG data), status (running / completed / failed), and last_updated_timestamp (last update time). Execution can be resumed from the point of interruption after a system restart.

[0074] The task processing method based on edge-cloud collaboration provided by this invention introduces a dynamic task decomposition engine and a negotiation protocol between agents. This allows the system to automatically break down complex user intentions into multiple sub-tasks, which are then executed in parallel or pipelined collaboratively by a lightweight agent on the edge and a large-scale agent in the cloud. Real-world testing shows that in typical complex scenarios (such as "finding a restaurant + making a reservation + navigation"), task completion time is reduced by more than 40% compared to traditional serial scheduling schemes, and the number of interaction rounds is reduced by 50%, effectively improving user experience and significantly enhancing the efficiency and response speed of multi-agent task collaboration.

[0075] The edge-cloud collaborative task processing method provided by this invention optimizes edge-cloud resource utilization and reduces system energy consumption and communication overhead. It supports edge-cloud collaborative decision-making at the task sub-step level, such as completing intent recognition and entity extraction on the edge, while only high-load steps like semantic generation or knowledge retrieval are handled by the cloud. This fine-grained collaborative mechanism can reduce invalid cloud requests by more than 30%, reduce network data transmission volume, and avoid the power consumption surge caused by deploying large models on the edge, thus extending the lifespan of the in-vehicle computing unit.

[0076] This invention provides a task processing method based on edge-cloud collaboration, offering a unified Agent runtime environment and simplifying development and deployment processes. By defining standardized Agent interface specifications, communication buses (such as lightweight message buses based on gRPC or DDS), and lifecycle management services, this invention constructs a unified AgentOS runtime framework. Agents with different functions can be used plug-and-play within this framework, shortening the development cycle by approximately 35%, significantly reducing system integration complexity, and supporting hot updates and dynamic replacement of agents, thus improving system maintainability.

[0077] This invention provides a task processing method based on edge-cloud collaboration, achieving consistent context management across edge and cloud platforms and enhancing personalized service capabilities. It designs a distributed context synchronization mechanism, using a context state tree and incremental synchronization strategies to ensure that edge-side and cloud-side agents share consistent user profiles, dialogue history, and environmental awareness information. This mechanism enables multiple agents to perform reasoning based on a unified context during collaboration, improving personalized recommendation accuracy by approximately 25% and significantly enhancing service consistency.

[0078] This invention provides a task processing method based on edge-cloud collaboration, applied to a multi-agent collaborative system based on edge-cloud collaboration. The system includes multiple agents, deployed on the edge or in the cloud. The method includes: receiving user input information; converting the input information into a structured intent message based on a pre-set speech recognition agent on the edge; decomposing the intent message into a directed acyclic graph task flow containing multiple task nodes based on a pre-set intent recognition agent on the edge; wherein the directed acyclic graph task flow includes dependencies between task nodes; traversing each task node of the directed acyclic graph task flow through a pre-set collaborative scheduler on the edge, determining the resource requirements and execution location suggestions of the task nodes, and obtaining the state information of each pre-set agent based on an agent registration list; wherein the state information includes at least one of the following: capability tags. The system dynamically allocates task nodes to corresponding intelligent agents based on their resource requirements, execution location suggestions, and agent status information, while maintaining a global context state tree using a pre-defined context manager. During execution, it synchronizes context state changes between the device and cloud via an incremental synchronization mechanism. After all task nodes have completed execution, a pre-defined result fusion node triggers a pre-defined fusion agent to fuse the results, generate a final response, and provide feedback to the user through a pre-defined output agent on the device. This system achieves dynamic decomposition of complex tasks and fine-grained scheduling at the node level, improving task processing efficiency. It also optimizes the utilization of device and cloud resources, reducing invalid network requests. Furthermore, it enhances the accuracy of personalized services and significantly improves the user experience through incremental context synchronization.

[0079] Example 2 Based on the above embodiments, this invention provides a task processing device based on edge-cloud collaboration, applied to a multi-agent collaborative system based on edge-cloud collaboration; the system includes: multiple agents; the agents are deployed on the edge or in the cloud; see also Figure 2 The diagram shown is a structural schematic of a task processing device based on edge-cloud collaboration provided in an embodiment of the present invention. The device includes: The input data processing module 310 is used to receive user input information and convert the input information into structured intent messages based on the pre-set speech recognition agent on the edge.

[0080] The task decomposition module 320 is used to decompose the intent message into a directed acyclic graph task flow containing multiple task nodes based on the intent recognition agent preset on the edge side; wherein, the directed acyclic graph task flow includes the dependency relationship between task nodes.

[0081] The agent determination module 330 is used to traverse each task node of the directed acyclic graph task flow through a pre-set collaborative scheduler on the edge, determine the resource requirements and execution location suggestions of the task nodes, and obtain the state information of each pre-set agent based on the agent registration list; wherein, the state information includes at least one of the following: capability tag, running location, and real-time system status.

[0082] The task execution module 340 is used to dynamically allocate each task node to the corresponding intelligent agent for execution based on the resource requirements and execution location suggestions of the task node and the state information of the intelligent agent. During the execution process, it maintains a global context state tree based on a preset context manager and synchronizes the changes in the context state between the edge and the cloud through an incremental synchronization mechanism.

[0083] The result feedback module 350 is used to trigger a preset fusion agent to fuse the results after all task nodes have been executed, generate a final response, and feed it back to the user through a preset output agent on the edge.

[0084] Furthermore, in some preferred embodiments of the present invention, the task decomposition module 320 is used to call a lightweight natural language understanding model deployed on the end side by the intent recognition agent to identify the task type and key entity parameters from the intent message; based on the task flow engine, according to the task type, it calls the corresponding task flow template from the preset task template library, and uses the key entity parameters to instantiate the template to generate a directed acyclic graph task flow.

[0085] Furthermore, in some preferred embodiments of the present invention, the real-time system status includes: the current CPU load, memory usage, and current network latency between the edge and the cloud of the intelligent agent; the task execution module 340 is used to match the resource requirements of the task node with the capability tags recorded in the intelligent agent registration list to determine the successfully matched candidate intelligent agents; priority is given to selecting intelligent agents whose running position conforms to the execution position suggestion of the task node; wherein, if there are multiple candidate intelligent agents that conform to the running position suggestion, the intelligent agent whose real-time system status indicates that the load is lower than a preset threshold is selected.

[0086] Furthermore, in some preferred embodiments of the present invention, if the execution location of the task node is suggested to be the cloud and the current network latency is higher than a preset latency threshold, the task node is reassigned to the corresponding intelligent agent on the edge for execution.

[0087] Furthermore, in some preferred embodiments of the present invention, if the execution location of the task node is suggested to be on the edge and the current network latency is lower than a preset latency threshold, the task node is reassigned to the corresponding intelligent agent in the cloud for execution.

[0088] Furthermore, in some preferred embodiments of the present invention, the task execution module 340 is used to, during execution, when any agent updates the local context, calculate the state change of the context state tree caused by the update; generate differential patch data from the state change; and send the differential patch data to the agent running on the other side through the cloud-edge collaboration interface.

[0089] Furthermore, in some preferred embodiments of the present invention, the apparatus further includes: an error result processing module, configured to return status information containing an error status or an empty result to the result fusion node if the agent assigned to the task node does not return a valid result after execution, or if there is no agent in the agent registration list that supports the requirements of the task node.

[0090] Furthermore, in some preferred embodiments of the present invention, the communication between agents in the system adopts a hybrid communication mechanism; the hybrid communication mechanism includes: a first communication mode and a second communication mode; the first communication mode is used to transmit control messages and metadata; the second communication mode is used to transmit large blocks of data generated during task execution; wherein, agents deployed in different physical locations communicate through the first communication mode, and agents deployed in the same computing unit communicate through the second communication mode.

[0091] Furthermore, in some preferred embodiments of the present invention, the agent runs in an independent agent container, which provides the agent with an isolated operating environment, resource quota management, and lifecycle control.

[0092] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the specific working process of the task processing device based on edge-cloud collaboration described above can be referred to the corresponding process in the aforementioned embodiments of the task processing method based on edge-cloud collaboration, and will not be repeated here.

[0093] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, and not to limit them; although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some or all of the technical features; and these modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the scope of the technical solutions of the embodiments of the present invention.

Claims

1. A task processing method based on edge-cloud collaboration, characterized in that, Applications to multi-agent collaborative systems based on edge-cloud collaboration; The system includes: multiple intelligent agents; the intelligent agents are deployed on the edge or in the cloud; the method includes: Receive user input information and convert the input information into a structured intent message based on a pre-set speech recognition agent on the device side; Based on the intent recognition agent preset on the edge, the intent message is decomposed into a directed acyclic graph task flow containing multiple task nodes; wherein, the directed acyclic graph task flow includes the dependency relationships between the task nodes. The system uses a pre-defined collaborative scheduler on the endpoint to traverse each task node in the directed acyclic graph task flow, determine the resource requirements and execution location suggestions for each task node, and obtain the state information of each pre-defined agent based on the agent registration list; wherein the state information includes at least one of the following: capability tag, running location, and real-time system status; Based on the resource requirements and execution location suggestions of the task nodes, as well as the state information of the agents, each task node is dynamically assigned to the agent with the corresponding function for execution; during execution, a global context state tree is maintained based on a preset context manager, and the changes in the context state are synchronized between the edge and the cloud through an incremental synchronization mechanism. After all the task nodes have been executed, a preset result fusion node triggers a preset fusion agent to fuse the results, generate a final response, and feed it back to the user through a preset output agent on the device side.

2. The task processing method based on edge-cloud collaboration according to claim 1, characterized in that, The step of decomposing the intent message into a directed acyclic graph task flow containing multiple task nodes based on the preset intent recognition agent on the edge includes: The intent recognition agent invokes the lightweight natural language understanding model deployed on the edge to identify the task type and key entity parameters from the intent message; Based on the task flow engine, the corresponding task flow template is called from the preset task template library according to the task type, and the template is instantiated using the key entity parameters to generate the directed acyclic graph task flow.

3. The task processing method based on edge-cloud collaboration according to claim 1, characterized in that, The real-time system status includes: the current CPU load and memory usage of the edge agent, and the current network latency between the edge and the cloud; the step of dynamically assigning each task node to the corresponding function of the agent for execution includes: The resource requirements of the task node are matched with the capability tags recorded in the agent registration list to determine the candidate agents that are successfully matched. The agent whose running location matches the execution location suggestion of the task node is preferentially selected; wherein, if there are multiple candidate agents that match the running location suggestion, the agent whose real-time system status indicates that the load is lower than a preset threshold is selected.

4. The task processing method based on edge-cloud collaboration according to claim 3, characterized in that, If the suggested execution location for the task node is the cloud, and the current network latency is higher than a preset latency threshold, then the task node will be reassigned to the corresponding intelligent agent on the edge for execution.

5. The task processing method based on edge-cloud collaboration according to claim 3, characterized in that, If the suggested execution location for the task node is the edge, and the current network latency is lower than a preset latency threshold, then the task node will be reassigned to the corresponding intelligent agent in the cloud for execution.

6. The task processing method based on edge-cloud collaboration according to claim 1, characterized in that, During execution, the steps of maintaining a global context state tree based on a preset context manager and synchronizing context state changes between the client and the cloud through an incremental synchronization mechanism include: During execution, when any of the agents updates the local context, the context manager calculates the state change of the context state tree caused by the update; The state changes are used to generate differential patch data, which is then sent to the intelligent agent running on the other side via the cloud-edge collaboration interface.

7. The task processing method based on edge-cloud collaboration according to claim 1, characterized in that, The method further includes: If the agent assigned to the task node does not return a valid result after execution, or if there is no agent in the agent registration list that supports the requirements of the task node, then status information containing an error status or an empty result is returned to the result fusion node.

8. The task processing method based on edge-cloud collaboration according to claim 1, characterized in that, The communication between the agents in the system adopts a hybrid communication mechanism; the hybrid communication mechanism includes: a first communication mode and a second communication mode; the first communication mode is used to transmit control messages and metadata; the second communication mode is used to transmit large blocks of data generated during task execution; wherein, agents deployed in different physical locations communicate with each other through the first communication mode, and agents deployed in the same computing unit communicate with each other through the second communication mode.

9. The task processing method based on edge-cloud collaboration according to any one of claims 1 to 8, characterized in that, The agent runs in an independent agent container, which provides the agent with an isolated operating environment, resource quota management, and lifecycle control.

10. A task processing device based on edge-cloud collaboration, characterized in that, Applications to multi-agent collaborative systems based on edge-cloud collaboration; The system includes: multiple intelligent agents; the intelligent agents are deployed on the edge or in the cloud; the device includes: The input data processing module is used to receive user input information and convert the input information into a structured intent message based on a pre-set speech recognition agent on the device side. The task decomposition module is used to decompose the intent message into a directed acyclic graph task flow containing multiple task nodes based on the intent recognition agent preset on the terminal side; wherein, the directed acyclic graph task flow includes the dependency relationship between the task nodes. The agent determination module is used to traverse each task node of the directed acyclic graph task flow through the preset cooperative scheduler on the edge, determine the resource requirements and execution location suggestions of the task node, and obtain the preset status information of each agent based on the agent registration list; wherein, the status information includes at least one of the following: capability tag, running location, and real-time system status; The task execution module is used to dynamically allocate each task node to the corresponding intelligent agent for execution based on the resource requirements and execution location suggestions of the task node and the state information of the intelligent agent; during the execution process, a global context state tree is maintained based on a preset context manager, and the changes in the context state are synchronized between the edge and the cloud through an incremental synchronization mechanism. The result feedback module is used to trigger a preset fusion agent to fuse the results after all the task nodes have been executed, generate a final response, and feed it back to the user through a preset output agent on the edge.

Citation Information

Cited By

  • Distributed audio system construction method and system based on graphical intention

    CN122053412A