A multi-agent semantic communication offloading and acceleration method based on a data processor

Abstract

The application relates to a multi-agent semantic communication offloading and acceleration method based on a data processor, which comprises the following steps: deploying a DPU at each agent node and establishing a zero-copy transmission channel; responding to an agent cooperation request and matching a target agent node; interacting with a semantic negotiation control message and locking a shared context mode; performing format verification, semantic security detection and exception disposal; monitoring Token consumption and context history blocks and pruning the context; aggregating in the network and writing to a local agent memory; and adjusting host GPU reasoning resources, cognitive reasoning paths and cross-domain migration. The multi-agent semantic communication offloading and acceleration method based on the data processor can solve the problems of increasing agent communication load, Token consumption and host computing power occupation, can solve the problem of affecting reasoning resource utilization efficiency when historical context continuously accumulates, and can solve the problem of security filtering and state coordination lagging behind business data transmission caused by the lack of underlying processing capacity.

Description

Technical Field

[0001] This invention relates to the intersection of artificial intelligence, multi-agent systems, and underlying technologies of network infrastructure, specifically to a method for offloading and accelerating multi-agent semantic communication based on a data processor. Background Technology

[0002] In multi-agent distributed inference systems, different agents are typically deployed on different physical server nodes and complete task collaboration, tool invocation, state synchronization, and result exchange through traditional network protocol stacks and application-layer communication protocols. With the introduction of large language models into multi-agent systems, the content transmitted between agents is no longer just ordinary data fields, but also includes semantic information such as task intent, contextual constraints, historical interaction states, intermediate inference results, and target preferences. Existing communication architectures typically have the host CPU handling protocol stack and application-layer parsing, the host GPU executing model inference, and the network primarily handling data forwarding. This makes it difficult to pre-process semantic structure, contextual consistency, and security risks before data enters the host.

[0003] In existing technologies, semantic negotiation, format verification, context management, and state synchronization between agents largely rely on host-side applications. This approach easily leads to increased communication load, token consumption, and host computing power consumption. Furthermore, as historical context accumulates, invalid or low-relevance contexts may enter the inference process, impacting the efficiency of inference resource utilization. Simultaneously, traditional network protocols lack the underlying processing capabilities for semantic injection, semantic denial-of-service traffic, and changes in the sensitivity of multi-node decisions. This results in security filtering and state coordination lagging behind business data transmission, making it difficult to meet the requirements for low latency, high consistency, and elastic resource scheduling in large-scale multi-agent collaborative inference scenarios.

[0004] Therefore, existing technologies have shortcomings and need to be improved and developed. Summary of the Invention

[0005] This invention provides a method for offloading and accelerating multi-agent semantic communication based on a data processor. This method addresses the problems in existing technologies where semantic negotiation, format verification, context management, and state synchronization between agents largely rely on host-side applications. This approach easily leads to increased communication load, token consumption, and host computing power consumption. Furthermore, as historical context accumulates, invalid or low-relevance contexts may enter the reasoning process, affecting the efficiency of reasoning resource utilization. Simultaneously, traditional network protocols lack the underlying processing capabilities for semantic injection, semantic denial-of-service traffic, and changes in the sensitivity of multi-node decisions, causing security filtering and state coordination to lag behind business data transmission, making it difficult to meet the requirements for low latency, high consistency, and elastic resource scheduling in large-scale multi-agent collaborative reasoning scenarios.

[0006] This invention provides a method for offloading and accelerating multi-agent semantic communication based on a data processor, applied to a distributed inference network comprising multiple agent physical server nodes. Each agent physical server node includes host computing resources and a DPU, comprising:

[0007] Deploy DPUs on each agent's physical server node to establish a zero-copy transmission channel between the DPU and the host GPU memory, bypassing the main CPU. The DPU registers the semantic controller, extracts the capability tags of the large language model of the node, and publishes them to the distributed hash table.

[0008] In response to a collaboration request initiated by a local agent, the DPU intercepts the request, extracts intent metadata, and matches the target agent node in a distributed hash table;

[0009] The DPUs of both communicating parties negotiate the semantics of the control messages and lock the shared context mode.

[0010] The receiving DPU performs format verification, semantic security detection, and anomaly handling on the arriving payload based on the shared context mode.

[0011] The DPU monitors session token consumption and context history blocks, and prunes the context when triggering conditions are met.

[0012] The decision sensitivity signal is extracted by the DPU and aggregated within the network. After obtaining the state of the global coordination variable, it is written directly to the local agent memory.

[0013] The DPU calculates semantic error signals based on the DIKWP model and adjusts host GPU inference resources, cognitive inference paths, and cross-domain migrations according to PID control values.

[0014] Furthermore, the deployment of DPUs on each agent physical server node includes:

[0015] Install a DPU with a multi-core ARM computing cluster and an independent hardware acceleration engine on each participating agent physical server node;

[0016] The DPU establishes a direct transmission channel with the GPU memory or registered memory based on DOCA, RDMA, and GPUDirect.

[0017] The host computing resources are used to perform large language model inference, while the DPU is used to take over the processing of agent communication protocols and the parsing of network packets in the semantic negotiation layer.

[0018] The semantic controller scans the domain capability tags supported by the large language model of this node, encapsulates the domain capability tags, semantic context set, constraints and node addressing information into an agent capability card, and publishes the agent capability card to a distributed hash table.

[0019] Furthermore, the response to the cooperation request initiated by the local agent, which involves the DPU intercepting the request, extracting intent metadata, and matching the target agent node in the distributed hash table, includes:

[0020] The local DPU extracts intent metadata that characterizes the semantic intent of the collaborative task from the collaboration request, and maps the intent metadata into an intent vector;

[0021] The local DPU reads the agent capability card from the distributed hash table and performs similarity matching between the intent vector and the capability tag vector in the agent capability card;

[0022] When the similarity score reaches the preset routing threshold, the physical server node of the agent with the highest similarity score is determined as the target agent node.

[0023] Furthermore, the step of negotiating control messages and locking the shared context mode through DPU interaction between the two communicating parties includes:

[0024] The DPUs of both communicating parties exchange SNL-HELLO control messages, SNL-SELECT control messages, and SNL-LOCK control messages sequentially at the network interface card.

[0025] The SNL-HELLO control message is used to declare the set of semantic contexts and constraints supported by the local large language model;

[0026] The SNL-SELECT control message is used to select a shared context reference based on the set of semantic contexts supported by both parties;

[0027] The SNL-LOCK control message is used to lock the context interaction protocol and bind the context interaction protocol to a strongly typed JSON Schema.

[0028] Furthermore, the receiving DPU performs format verification, semantic security checks, and anomaly handling on the arriving payload based on the shared context mode, including:

[0029] Before the application layer communication load enters the receiver host memory, the receiver DPU captures the application layer communication load through a built-in hardware regular expression acceleration engine.

[0030] The receiving DPU converts the strongly typed JSON Schema into pattern matching rules and syntax validation rules, and performs pattern matching and syntax validation on the application layer communication load;

[0031] When the application layer communication load does not conform to the pattern matching rule or syntax validation rule, the receiving DPU constructs a retransmission request or clarification request to the sender at the network interface card.

[0032] The receiver DPU runs a quantized neural network inference model on a high-speed parallel data path to extract features from the JSON business payload that has passed syntax validation and output anomaly confidence.

[0033] When the anomaly confidence level reaches the preset anomaly threshold, and the anomaly type is a semantic injection command or semantic denial-of-service traffic, the receiving DPU discards the corresponding service payload on the network interface card side.

[0034] Furthermore, the DPU monitors session token consumption and context history blocks, and prunes the context when trigger conditions are met, including:

[0035] The DPU tracks the total number of tokens in the business application request messages in real time at the network transport layer and records the increment of the context history block over time. It also establishes a dynamic context baseline model for each active agent session.

[0036] Context pruning is triggered when the similarity between the current intent vector and the baseline intent vector in the dynamic context baseline model is lower than the preset switching threshold, or when the total number of accumulated historical interaction tokens reaches the host GPU's preset high-bandwidth memory KV Cache red line threshold.

[0037] The DPU assigns relevance weights to context history blocks based on the current session intent, reassembles the context data to be transmitted at the semantic agent layer, removes outdated task objective settings, and truncates redundant historical dialogue records into those with the most recent chronological order and the highest relevance weights. This interaction, among which... This indicates the preset number of interactions to retain.

[0038] Furthermore, the DPU extracts decision sensitivity signals and performs intra-network aggregation, including:

[0039] The DPU intercepts unstructured decision-making reasoning data sent by the local agent, and extracts the partial derivatives or gradients of environmental variable changes on the current decision result through local lightweight parsing to form a sensitivity gradient.

[0040] Each level of the DPU acts as a distributed coordination agent for the ripple effect protocol, aggregating the sensitivity gradients transmitted from neighboring physical nodes at the network switching layer, and updating the state of the global coordination variables according to the following formula: ;in, This represents the current state of the global coordination variable. This represents the state of the global coordination variable at the next update time. Indicates the current moment. The aggregation step size parameter represents the convergence speed of the control system. This represents the total number of agent nodes participating in coordination within the current subnet. Indicates the sequence number of the intelligent agent node participating in the coordination. Represents intelligent agents exist Sensitivity representation value at time, Represents intelligent agents exist Sensitivity gradient at time, This refers to intelligent agents that assign trust or identity permissions based on network topology. The confidence weighting coefficient.

[0041] Furthermore, after obtaining the state of the global coordination variables, it is written directly to the local agent's memory, including:

[0042] When there is timing jitter in the arrival of sensitivity gradients of different agent nodes, the DPU writes the timestamped sensitivity gradients into a circular buffer and performs asynchronous gradient accumulation in the order of the timestamps.

[0043] DPU uses a preset momentum decay factor to smooth the current aggregation result and the historical aggregation result by an exponential moving average.

[0044] The DPU will calculate the state of the global coordination variables after convergence. The global coordination variable state is encapsulated as an INFORM control message and written directly to the local agent memory via Direct Memory Access (RDMA) across the host kernel protocol stack.

[0045] Furthermore, the DPU calculates the semantic error signal based on the DIKWP model and adjusts the host GPU inference resources according to the PID control input, including:

[0046] DPU maps the cognitive processes of large language models into data, information, knowledge, wisdom, and intention. Figure 5 Layered network model;

[0047] The DPU's internal control plane samples the set of intelligent decision-making layer output data generated by the host GPU in real time. And read the macro-level target of the intent layer preset during system initialization. ;

[0048] DPU uses a lightweight embedding model to... and They are mapped to high-dimensional latent space feature vectors respectively, and the cosine distance between the two high-dimensional latent space feature vectors is used as the real-time error signal. Alternatively, after normalizing the feature vectors of two high-dimensional latent spaces to form a semantic probability distribution, cross-entropy loss can be used as the real-time error signal. ;

[0049] The metacognitive controller on the DPU chip calculates the PID control input according to the following formula: ;in, express The set of intelligent decision-making layer output data generated by the host GPU at any moment. express The macro-level intention at the moment, express and The degree of deviation in semantic space, express The computing power allocation for the mainframe inference engine needs to be controlled at all times. Represents the proportional gain coefficient. Represents the integral gain coefficient. Represents the differential gain coefficient. Indicates the historical sampling time. Indicates from the initial time to Historical error accumulation term at time point This represents the rate of change of the error signal with respect to time.

[0050] Furthermore, the DPU adjusts the cognitive reasoning path and cross-domain transfer based on the PID control input, including:

[0051] The DPU will use the PID control quantity The inference computation upper limit control parameters are converted to host GPU inference computing limits. The inference control parameters include generation length parameters, sampling candidate range parameters, and retrieval enhancement parameters. The generation length parameter includes max_new_tokens, the sampling candidate range parameters include Top-P and Top-K, and the retrieval enhancement parameters include RAG knowledge base retrieval depth.

[0052] The DPU guides the host to evolve its cognitive state within the DIKWP model framework according to the following formula: ;in, express The data layer state at any given time. express The information layer state at any given moment. express The state of the knowledge layer at any given moment. express The state of the intelligence layer at any given moment. express The state of intent at any given moment. This indicates the data layer state at the next update time. Represents the dynamic evolution function;

[0053] When the real-time error signal Below the preset convergence threshold, or real-time error signal When the rate of change is lower than the preset steady-state threshold, the DPU triggers the early stop mechanism, cuts off the current inference generation process, and releases the GPU memory;

[0054] When the real-time error signal When the deviation exceeds the preset threshold, the DPU increases the PID control input. It guides the host to perform logical expansion of the mind tree or to re-reason by tracing back the historical cognitive path; when the amount of context data exceeds the preset context capacity threshold, the DPU triggers cross-domain scheduling, which migrates the current agent's state slice to the agent's physical server node with idle GPU computing power via a high-speed network.

[0055] Beneficial effects:

[0056] As can be seen from the above technical solutions, the present invention provides a method for offloading and accelerating multi-agent semantic communication based on a data processor, which has the following beneficial effects:

[0057] 1. Reduce the communication processing load on the host side and improve the efficiency of inference resource utilization.

[0058] This application offloads intelligent agent communication protocol processing, semantic negotiation message parsing, format verification, anomaly detection, and some state coordination tasks to the DPU for execution. This relieves the host CPU from bearing a large amount of application-layer communication parsing and repetitive verification work, and the host GPU from inference processing of obviously non-compliant, low-relevance, or risky payloads. Since the DPU is located at the network ingress, it can complete filtering, negotiation, and pruning before business payloads enter the host memory or GPU inference process, thus reducing the consumption of host resources by invalid prompts, redundant historical context, and abnormal traffic. Consequently, host computing resources can be more dedicated to the core inference tasks of large language models, and the distributed inference network can more easily maintain stable resource allocation and communication processing capabilities as the number of nodes increases.

[0059] 2. Improve the consistency and determinism of semantic communication among multi-agents.

[0060] This application enables both communicating parties to complete capability discovery, shared context selection, and interaction protocol locking before service payload transmission by publishing capability cards on the DPU side, matching intent vectors, and using SNL series semantic negotiation control messages. Compared to methods that rely on multi-turn dialogue in natural language to disambiguate, this scheme uses structured content such as semantic context sets, constraints, and JSON Schema as preconditions for communication, allowing both agents to collaborate under a unified data structure and semantic benchmark. The receiving DPU further performs format and syntax validation according to the locked shared context mode, thereby reducing collaboration failures caused by inconsistent context understanding, inconsistent field structures, or missing constraints, and improving communication controllability during multi-agent task collaboration.

[0061] 3. Improve the proactive nature of semantic security filtering and anomaly handling.

[0062] This application combines a hardware regular expression acceleration engine and a quantized neural network inference model on the receiver's DPU side to perform format verification, syntax verification, and semantic security detection on arriving payloads. This processing path occurs before business data enters host memory, thus enabling pre-interception of payloads that do not conform to the schema, semantic injection instructions, and semantic denial-of-service traffic. Compared to host application-layer detection, DPU-side detection does not require waiting for the payload to enter the model inference process, nor does it consume host GPU resources for inference and judgment of abnormal content. This mechanism can reduce the occupation of host memory, GPU memory, and model context window by malicious or abnormal payloads, improving the security processing capabilities of distributed intelligent agent systems in open collaborative environments.

[0063] 4. Reduce the impact of context inflation and semantic drift on reasoning quality.

[0064] This application utilizes a DPU to continuously monitor session token consumption and the growth of context history blocks, and performs context pruning based on intent switching thresholds, KV Cache redline thresholds, and relevance weight scores. This mechanism does not process historical context only after model output anomalies; instead, it adjusts the data packets to be transmitted during network transmission, removing outdated task objectives and low-relevance historical dialogues from subsequent inference inputs, retaining only interactions that are relevant to the current session intent and are more recent. This reduces memory consumption caused by the disordered accumulation of historical context, minimizes interference from low-relevance content in the model's understanding of the current task, and maintains a high degree of consistency between inference inputs and the current task objective.

[0065] 5. Improve the real-time performance and consistency of multi-node state coordination.

[0066] This application extracts sensitivity gradients from the decision-making and inference data of local agents using a Data Processing Unit (DPU), and aggregates the sensitivity gradients of multiple nodes at the network switching layer to form a globally coordinated variable state, which is then directly written to the local agent's memory via RDMA. This mechanism shifts the state synchronization in the multi-agent system from the application layer interaction between hosts to the DPU's intra-network computation path, avoiding the need to upload all micro-states to a central server for processing. By using confidence weights, timestamp circular buffers, and asynchronous gradient accumulation, the impact of link latency jitter on the aggregation results can be reduced, enabling different nodes to form a more consistent state response to changes in environmental variables, thereby reducing delay propagation and state oscillations in group decision-making.

[0067] 6. Implement closed-loop adjustment of inference resources driven by semantic error.

[0068] This application maps the large language model inference process to a five-layer DIKWP model. The DPU samples the semantic deviation between the intelligent decision-making layer output and the macro-level target of the intent layer, forming a real-time error signal. This signal is then used to adjust host inference parameters, cognitive inference paths, and cross-domain scheduling via PID control. This approach allows inference resource allocation to be based on feedback control rather than static parameters or manually preset strategies, rather than solely on the dynamic deviation between the current output and the target intent. When the error tends to converge, early stopping can be triggered and GPU memory released; when the error deviation is large, the inference budget can be increased or deeper inference can be guided. This improves the match between computational power investment and task complexity, reducing both over-generation and under-inference problems.

[0069] It should be understood that all combinations of the foregoing concepts and the additional concepts described in more detail below can be considered part of the inventive subject matter of this disclosure, provided that such concepts do not contradict each other.

[0070] The foregoing and other aspects, embodiments, and features of the teachings of the present invention will be more fully understood from the following description in conjunction with the accompanying drawings. Other additional aspects of the invention, such as features and / or beneficial effects of exemplary embodiments, will become apparent from the following description or may be learned through practice of specific embodiments according to the teachings of the present invention. Attached Figure Description

[0071] The accompanying drawings are not drawn to scale. In the drawings, each identical or nearly identical component shown in the various figures may be denoted by the same reference numeral. For clarity, not every component is labeled in each figure. Embodiments of various aspects of the invention will now be described by way of example and with reference to the accompanying drawings, wherein:

[0072] Figure 1 This is a flowchart illustrating a multi-agent semantic communication offloading and acceleration method based on a data processor, as described in this application.

[0073] Figure 2 This is a flowchart of step S104 of a multi-agent semantic communication offloading and acceleration method based on a data processor in an embodiment of this application.

[0074] Figure 3 This is a flowchart of step S106 of a multi-agent semantic communication offloading and acceleration method based on a data processor in an embodiment of this application.

[0075] Figure 4 This is a flowchart of step S108 of a multi-agent semantic communication offloading and acceleration method based on a data processor in an embodiment of this application.

[0076] Figure 5 This is a flowchart of step S110 of a multi-agent semantic communication offloading and acceleration method based on a data processor in an embodiment of this application.

[0077] Figure 6 This is an architecture diagram of a multi-agent semantic communication offloading and acceleration method based on a data processor, as described in an embodiment of this application.

[0078] Figure 7 This is a functional schematic diagram of a multi-agent semantic communication offloading and acceleration method based on a data processor, as described in an embodiment of this application.

[0079] Figure 8 This is a deployment diagram of a multi-agent semantic communication offloading and acceleration method based on a data processor, as described in an embodiment of this application.

[0080] Figure 9 This is a schematic diagram of an electronic device according to an embodiment of this application. Detailed Implementation

[0081] 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, not all, of the embodiments of the present invention. All other embodiments obtained by those skilled in the art based on the described embodiments of the present invention without creative effort are within the scope of protection of the present invention. Unless otherwise defined, the technical or scientific terms used herein should have the ordinary meaning understood by those skilled in the art to which this invention pertains.

[0082] The terms "first," "second," and similar words used in the specification and claims of this patent application do not indicate any order, quantity, or importance, but are merely used to distinguish different components. Similarly, unless the context clearly indicates otherwise, the singular forms of "an," "a," or "the," etc., do not indicate a quantity limitation, but rather indicate the presence of at least one. Terms such as "comprising" or "including" mean that the element or object preceding "comprising" encompasses the features, integrals, steps, operations, elements, and / or components listed following "comprising" or "including," and do not exclude the presence or addition of one or more other features, integrals, steps, operations, elements, components, and / or collections thereof. Terms such as "upper," "lower," "left," and "right" are used only to indicate relative positional relationships; these relative positional relationships may change accordingly when the absolute position of the described object changes.

[0083] In existing distributed collaborative communication architectures for multi-agent systems (MAS) and large language models (LLM), the industry generally relies on the traditional OSI seven-layer model, the TCP / IP protocol stack, and conventional application layer protocols (such as HTTP and JSON) to achieve data delivery and external tool invocation between cross-node agents. With the exponential increase in the number of large model parameters and the complexity of agent collaboration, existing architectures have exposed the following serious technical bottlenecks:

[0084] 1. The lack of semantic awareness in network protocols leads to "cognitive loops" and enormous communication overhead: Traditional network protocol stacks are designed solely for error-free deterministic data stream transmission, completely failing to understand the "intents" and "semantics" required for high-level agent collaboration at the network's underlying layer. This creates a severe "semantic gap" between the physical network and the cognition of large models. Consequently, before agents can formally execute collaborative tasks, the lack of mandatory semantic alignment at the network's underlying protocol layer forces them to engage in extremely expensive and non-deterministic multi-turn natural language dialogues through large language models to attempt to eliminate ambiguity (the so-called "cognitive loop"). As the number of agents in the network increases, the communication bandwidth consumption and token consumption costs of large models explode non-linearly at an O(n^2) level, severely limiting the horizontal scalability of multi-agent systems.

[0085] 2. The waste of host computing resources is extremely severe and easily induces "context bloat": Existing intelligent agent communication architectures heavily rely on host-side CPUs and GPUs for tedious natural language semantic parsing, JSON structure format validation, and long-term interaction state maintenance. Due to the lack of early filtering and cleaning mechanisms at the network edge (such as at the network interface card), massive amounts of invalid, highly ambiguous, or outdated historical prompts directly penetrate the network and flood into the core inference engine of large models. This disordered accumulation and unmanaged transmission of historical context data easily triggers "context bloat" and "semantic drift" problems in large models, not only reducing inference accuracy but also severely wasting the currently extremely valuable GPU high-bandwidth memory (HBM) capacity and expensive floating-point inference computing power.

[0086] 3. Security and state coordination strategies are too coarse-grained, and the network system lacks underlying consensus capabilities: Existing multi-agent distributed networks lack a global semantic-level security filtering and coordination view. Application-layer security protocols are unable to efficiently intercept novel "semantic injection" and "semantic denial-of-service (SDoS)" attacks specifically targeting large models at the network layer. Furthermore, when faced with minor environmental changes, the existing architecture cannot quickly and with low latency aggregate sensitivity signals among distributed physical nodes to achieve global state consensus, making it highly susceptible to the "bullwhip effect" and systemic behavioral oscillations in multi-agent group decision-making.

[0087] To thoroughly solve the aforementioned deep-seated problems, there is an urgent need for a cutting-edge technical solution that can dynamically perceive and verify the semantics of agent communication at the hardware level, based on global visibility at the network layer (i.e., the network card side), and deeply integrate the hardware acceleration offloading capabilities of the DPU (Data Processor) to perform automated context pruning, semantic injection prevention, and ultra-low latency state consensus offloading. This would completely free up the host's valuable computing power for core inference, and comprehensively improve the collaborative efficiency and robustness of multi-agent networks.

[0088] Therefore, embodiments of the present invention provide a method for offloading and accelerating multi-agent semantic communication based on a data processor, applied to a distributed inference network including multiple agent physical server nodes, each agent physical server node including host computing resources and a DPU, referring to... Figure 1 Flowchart, Figure 6 Architecture diagram, Figure 7 Functional diagram and Figure 8 The deployment diagram includes:

[0089] Step S102: Deploy DPUs on each agent physical server node, establish a zero-copy transmission channel between the DPU and the host GPU memory that bypasses the main CPU, and have the DPU register the semantic controller, extract the capability tags of the large language model of the node, and publish them to the distributed hash table.

[0090] Step S104: In response to the collaboration request initiated by the local agent, the DPU intercepts the request, extracts the intent metadata, and matches the target agent node in the distributed hash table.

[0091] Step S106: The DPUs of both communicating parties negotiate the semantic control message and lock the shared context mode.

[0092] Step S108: The receiving DPU performs format verification, semantic security detection, and anomaly handling on the arriving payload according to the shared context mode.

[0093] Step S110: The DPU monitors session token consumption and context history blocks, and prunes the context when the triggering conditions are met.

[0094] Step S112: The DPU extracts the decision sensitivity signal and performs intra-network aggregation. After obtaining the global coordination variable state, it is directly written to the local agent memory.

[0095] Step S114: The DPU calculates the semantic error signal based on the DIKWP model and adjusts the host GPU inference resources, cognitive inference path and cross-domain migration according to the PID control quantity.

[0096] Using the DPU as the network-side execution entity, a zero-copy transmission channel bypassing the main CPU is first established between the DPU and the host GPU memory. The DPU then extracts the local node's capability tags and publishes capability information. When a local agent initiates a cooperation request, the DPU extracts intent metadata at the network entry point and selects the target node based on a distributed hash table. Subsequently, the DPUs of both communicating parties interact to negotiate the semantic control message and lock the shared context mode. When the service payload arrives at the receiver, the DPU performs format verification, security detection, anomaly handling, context pruning, sensitivity aggregation, and DIKWP semantic error closed-loop control.

[0097] Capability discovery, intent routing, semantic handshake, security verification, context pruning, state consensus, and inference control in agent semantic communication are all performed collaboratively on the DPU side. This extends the DPU from a traditional network acceleration component to a semantic communication control node, enabling it to perform semantic-level preprocessing before the host CPU and GPU participate. Specifically, the semantic controller is a software module or hardware co-processing module residing in the DPU control plane; the shared context mode is a communication mode jointly determined by the semantic context set, constraints, and a strongly typed JSON schema; and cross-domain migration involves migrating session state slices, context summaries, KV cache indexes, or task states to a target node with idle GPU computing power when the amount of context data exceeds a threshold.

[0098] By using the DPU to handle high-frequency, repetitive, and latency-sensitive processing tasks in multi-agent communication, the number of times the host CPU participates in application-layer protocol parsing and semantic negotiation can be reduced, as can the entry of non-compliant or low-value payloads into the GPU inference process. Since intent routing, semantic negotiation, and format validation are all completed before business data enters the host, agents can collaborate based on structured context, reducing invalid communication and multiple rounds of clarification. Furthermore, combining context pruning, sensitivity aggregation, and PID control can improve the operational efficiency of distributed inference networks at multiple levels, including communication, security, state consistency, and computational power allocation.

[0099] In some embodiments, DPUs are deployed on each agent physical server node, including:

[0100] A DPU with a multi-core ARM computing cluster and an independent hardware acceleration engine is installed on each participating agent physical server node.

[0101] The DPU establishes a direct transmission channel with the GPU memory or registered memory based on DOCA, RDMA, and GPUDirect.

[0102] The host computing resources are used to perform large language model inference, while the DPU is used to take over the processing of agent communication protocols and the parsing of network packets in the semantic negotiation layer.

[0103] The semantic controller scans the domain capability tags supported by the large language model of this node, encapsulates the domain capability tags, semantic context set, constraints and node addressing information into agent capability cards, and publishes the agent capability cards to a distributed hash table.

[0104] Each participating agent physical server node is configured with a DPU featuring a multi-core ARM computing cluster and an independent hardware acceleration engine. A zero-copy transmission channel, bypassing the main CPU, is established with the host GPU memory via the DOCA Comch mechanism. The host side primarily handles large language model inference, while the DPU handles communication protocol processing and semantic negotiation layer network packet parsing. Simultaneously, the semantic controller scans the domain capability tags supported by the large language model on its node and encapsulates the domain capability tags, semantic context set, constraints, and node addressing information into agent capability cards, which are then published to a distributed hash table. The DPU can obtain domain capability tags through the model metadata interface, configuration files, model service registration interface, or a preset capability list. The agent capability card includes at least the node identifier, network address, model domain tag, supported context schema identifier, access constraints, and update timestamp.

[0105] By combining DPU deployment with agent capability discovery mechanisms, nodes are discovered not only through network addresses, but also semantically through capability tags, context sets, and constraints. This design enables subsequent intent routing to be matched based on task semantics and model capabilities, rather than solely on static addresses or manual configuration. To improve implementation clarity, capability cards should be further defined as data objects containing node identifiers, network addresses, model capability tags, schema identifiers, permission constraints, and update timestamps. The semantic controller can be executed by the DPU control plane or run as a service module residing on the DPU.

[0106] By combining DPU hardware deployment, zero-copy transmission, and capability card distribution, a semantic addressing foundation for agent nodes can be established during the system initialization phase. Zero-copy channels reduce the overhead of the main CPU participating in data movement, while capability card distribution provides a searchable data source for subsequent intent routing. Thus, host-side computing resources can be concentrated on model inference, while the DPU is responsible for network packet parsing and capability registration at the communication entry point, enabling multi-agent networks to maintain a clear division of resources and a robust node discovery mechanism as the node scale expands.

[0107] In some embodiments, reference is made to Figure 2 In response to a collaboration request initiated by the local agent, the DPU intercepts the request, extracts intent metadata, and matches the target agent node in a distributed hash table, including:

[0108] Step S1041: The local DPU extracts intent metadata that represents the semantic intent of the collaborative task from the collaboration request and maps the intent metadata to an intent vector.

[0109] Step S1042: The local DPU reads the agent capability card from the distributed hash table and performs similarity matching between the intent vector and the capability tag vector in the agent capability card.

[0110] Step S1043: When the similarity score reaches the preset routing threshold, the agent physical server node with the highest similarity score is determined as the target agent node.

[0111] The local DPU extracts metadata representing the semantic intent of the collaborative task from the collaboration request and maps it to an intent vector. It then reads the agent's capability card from a distributed hash table and performs similarity matching between the intent vector and the capability tag vector. When the similarity score reaches a preset routing threshold, the agent's physical server node with the highest score is identified as the target agent node. The intent metadata can include fields such as task type, domain keywords, input modality, expected output format, latency requirements, and permission constraints. Supplementary intent vectors can be generated by a lightweight embedding model, a hash vectorization model, or a pre-defined vocabulary encoding model. Similarity scoring can use cosine similarity, inner product similarity, or weighted matching scores, and the node with the highest score that reaches the threshold is selected as the target node.

[0112] This approach transforms the task semantics in agent collaboration requests into vectorized routing criteria, and completes target node selection on the DPU side, freeing semantic routing from complete reliance on the host application layer or central scheduling server. This method combines task intent, node capabilities, and network addressing within a single matching process. The DPU can extract intent and match capabilities locally based on the collaboration request, reducing the overhead of the host application layer's routing decisions and the number of communications required to query multiple candidate agents using natural language to determine capability matches. Since the distributed hash table stores structured capability cards, the node selection process is highly repeatable and interpretable. This mechanism enables multi-agent systems to quickly locate target nodes with corresponding capabilities after a collaboration request is generated, improving task assignment efficiency and reducing invalid reasoning and communication caused by erroneous routing.

[0113] In some embodiments, the DPUs of both communicating parties interact to negotiate control messages and lock the shared context mode, referring to... Figure 3 ,include:

[0114] Step S1061: The DPUs of both communicating parties exchange SNL-HELLO control messages, SNL-SELECT control messages, and SNL-LOCK control messages sequentially at the network card end.

[0115] Step S1062: The SNL-HELLO control message is used to declare the set of semantic contexts and constraints supported by the local large language model.

[0116] Step S1063: The SNL-SELECT control message is used to select a shared context reference based on the set of semantic contexts supported by both parties.

[0117] Step S1064: The SNL-LOCK control message is used to lock the context interaction protocol and bind the context interaction protocol to a strongly typed JSON Schema.

[0118] The two DPUs sequentially exchange SNL-HELLO, SNL-SELECT, and SNL-LOCK control messages at the network interface card (NIC). SNL-HELLO declares the set of semantic contexts and constraints supported by the local large language model, carrying at least a session identifier, capability summary, context set identifier, and constraints. SNL-SELECT selects a shared context baseline from the supported semantic context sets, carrying at least the selected context baseline identifier, version number, and schema candidate. SNL-LOCK locks the context interaction protocol, carrying at least an acknowledgment field, schema identifier, verification summary, and effective time, and binds the protocol to a strongly typed JSON schema. This scheme ensures that a defined context and structural constraints are established before service payload transmission, and allows for the return of a downgraded protocol or clarification request if negotiation fails.

[0119] The context alignment process, which would normally rely on multi-turn natural language communication between agents, is transformed into a structured control message handshake process executed on the DPU side. This handshake is not a simple connection establishment process, but rather a protocol negotiation oriented towards semantic context, constraints, and schema binding. Both communicating parties can determine the common context benchmark and data structure specifications to be followed before the formal service payload is transmitted, reducing subsequent parsing errors caused by inconsistencies in field structures, constraints, or task semantics. Since the negotiation is performed by the DPU at the network interface card, the number of times the host CPU and large language model are involved in context confirmation is reduced, as is the uncertainty caused by natural language communication. This mechanism provides a clear rule basis for subsequent DPU-side format verification, security detection, and anomaly handling.

[0120] In some embodiments, the receiving DPU performs format verification, semantic security detection, and anomaly handling on the arriving payload based on the shared context mode, referring to... Figure 4 ,include:

[0121] Step S1081: Before the application layer communication load enters the receiver host memory, the receiver DPU captures the application layer communication load through the built-in hardware regular expression acceleration engine.

[0122] Step S1082: The receiving DPU converts the strongly typed JSON Schema into pattern matching rules and syntax validation rules, and performs pattern matching and syntax validation on the application layer communication load.

[0123] Step S1083: When the application layer communication load does not conform to the pattern matching rule or syntax verification rule, the receiver DPU constructs a retransmission request or clarification request to the sender at the network interface card.

[0124] Step S1084: The receiver DPU runs a quantized neural network inference model on the high-speed parallel data path to extract features from the JSON business payload that has passed syntax verification and output the anomaly confidence level.

[0125] Step S1085: When the anomaly confidence level reaches the preset anomaly threshold and the anomaly type is semantic injection command or semantic denial-of-service traffic, the receiving DPU discards the corresponding service payload on the network interface card side.

[0126] Based on the already locked strong-typed JSON Schema, further restrictions are placed on the payload verification and security processing of the receiving DPU: Before the application layer communication load enters the receiving host memory, the receiving DPU captures the load through a hardware regular expression acceleration engine and converts the strong-typed JSON Schema into pattern matching rules and syntax validation rules; when the load does not conform to the rules, the DPU constructs a retransmission request or clarification request at the network interface card; for JSON business loads that pass syntax validation, the DPU runs a lightweight quantization classification model in the control plane or accelerated data path. The lightweight quantization classification model is used to classify anomalies based on field structure, field length, nesting depth, sensitive instruction features, token growth rate, and historical deviation features, and then outputs the anomaly confidence score. When the anomaly confidence score reaches a threshold and the anomaly type is a semantic injection instruction or semantic denial-of-service traffic, the load is discarded.

[0127] Structured format validation is combined with semantic security detection and deployed on the receiver's DPU side, with detection occurring before the payload enters host memory. This approach not only identifies format errors that do not conform to the schema but also identifies malicious semantic content disguised within a legitimate JSON structure. The neural network inference model's input includes JSON field structure, field length, nesting depth, sensitive instruction word vectors, token growth rate, and historical session deviation features; the output includes anomaly confidence and anomaly category labels. Anomaly handling can include at least one of the following: discarding the payload, generating a retransmission request, generating a clarification request, updating the blacklist, or reducing session privileges.

[0128] The receiver's Data Processing Unit (DPU) can perform format and semantic risk screening at the network ingress, preventing non-compliant or security-risk payloads from entering host memory and the model inference link. For non-compliant but repairable payloads, the DPU can return a retransmission request or clarification request; for high-risk payloads, the DPU can discard them directly. This reduces the resource consumption of the host CPU and GPU in processing abnormal data, and also reduces the impact of semantic injection and semantic denial-of-service traffic on the context window, GPU memory, and inference state of large language models.

[0129] In some embodiments, the DPU monitors session token consumption and context history blocks, and prunes the context when triggering conditions are met, referencing... Figure 5 ,include:

[0130] Step S1101: The DPU tracks the total number of tokens in the service application request message in real time at the network transport layer, records the increment of the context history block over time, and establishes a dynamic context usage baseline model for each active agent session.

[0131] Step S1102: When the similarity between the current intent vector and the baseline intent vector in the dynamic context using the baseline model is lower than the preset switching threshold, or when the total number of accumulated historical interaction tokens reaches the host GPU's preset high-bandwidth memory KVCache red line threshold, context pruning is triggered.

[0132] Step S1103: The DPU performs relevance weight scoring on the context history blocks based on the current session intent, reassembles the context data to be transmitted at the semantic agent layer, deletes outdated task objective settings, and truncates redundant historical dialogue records into those with the most recent time sequence and the highest relevance weight score. This interaction, among which... This indicates the preset number of interactions to retain.

[0133] The DPU tracks the total number of tokens in service application request messages in real time at the network transport layer and records the increment of context history blocks over time, establishing a dynamic context usage baseline model for each active agent session. When the similarity between the current intent vector and the baseline intent vector is lower than a preset switching threshold, or when the total number of accumulated historical interaction tokens reaches the host GPU's preset KV Cache red line threshold, context pruning is triggered. The DPU scores the context history blocks based on the current session intent with relevance weights and reassembles the context data to be transmitted at the semantic agent layer, deleting outdated task objective settings and truncating redundant historical dialogue records into those with the most recent time sequence and the highest relevance weight scores. This interaction.

[0134] Context governance is moved from the host model input stage to the DPU network transmission stage, and is triggered by token consumption, intent switching, and KV Cache thresholds. This approach does not simply delete historical records, but selectively retains them based on the relevance of the current session intent and historical context blocks. The DPU uses a token vocabulary consistent with the host's large language model, an equivalent token estimation table, or a synchronized lightweight token segmenter to count tokens; the dynamic context usage baseline model can include historical token growth rate, historical intent vector center, session duration, and KV Cache usage estimate; the relevance weight score can be determined by the similarity between the current intent vector and the historical context block vector, the time decay coefficient, and the task stage weight.

[0135] The DPU can filter and compress context data before it enters the host inference process, removing redundant, outdated, or historical content that is weakly related to the current intent. This approach reduces KV cache usage and the number of input tokens, thereby reducing GPU memory pressure and inference computation load. Simultaneously, the retained historical interactions are both chronologically recent and highly relevant, reducing the impact of historical noise on the understanding of the current task and improving the relevance and stability of context input in multi-turn collaborative scenarios.

[0136] In some embodiments, the decision sensitivity signal is extracted by the DPU and aggregated within the network, including:

[0137] The DPU intercepts unstructured decision-making reasoning data sent by the local agent, extracts the partial derivatives or gradients of environmental variable changes on the current decision result through local lightweight parsing, and forms a sensitivity gradient.

[0138] Each level of the DPU acts as a distributed coordination agent for the ripple effect protocol, aggregating the sensitivity gradients transmitted from neighboring physical nodes at the network switching layer, and updating the state of the global coordination variables according to the following formula: ;in, This represents the current state of the global coordination variable. This represents the state of the global coordination variable at the next update time. Indicates the current moment. The aggregation step size parameter represents the convergence speed of the control system. This represents the total number of agent nodes participating in coordination within the current subnet. Indicates the sequence number of the intelligent agent node participating in the coordination. Represents intelligent agents exist Sensitivity representation value at time, Represents intelligent agents exist Sensitivity gradient at time, This refers to intelligent agents that assign trust or identity permissions based on network topology. The confidence weighting coefficient.

[0139] The DPU intercepts unstructured decision-making reasoning data from local agents and extracts the partial derivatives or gradients of environmental variable changes on the current decision outcome through local lightweight parsing, forming a sensitivity gradient. Each level of the DPU acts as a distributed coordination agent for the ripple effect protocol, aggregating the sensitivity gradients from neighboring physical nodes at the network exchange layer and updating the state according to the global coordination variable state update formula. This design enables the aggregation and processing of minute state changes in the multi-agent decision-making process at the DPU network layer.

[0140] The extraction and aggregation of sensitivity signals in multi-agent collaboration are migrated from the central server or host application layer to the computation path within the DPU network. The DPU not only forwards data but also extracts gradient information that can be used for group state coordination based on changes in environmental variables and decision outputs. Sensitivity gradients can be calculated through finite difference, changes in model output confidence, changes in policy scores, or responses to environmental variable perturbations.

[0141] By directly aggregating sensitivity gradients at the network switching layer using the DPU, the communication path for all nodes to report micro-states to the central server for redistribution can be reduced, thus lowering state coordination latency and reducing centralized processing pressure. Confidence weights allow the identity, permissions, topological location, or trust level of different nodes to influence the aggregation result, preventing low-trust nodes from unreasonably affecting global coordination variables. This mechanism is beneficial for forming more timely group state responses in multi-agent scenarios where environmental variables change rapidly, reducing the impact of state propagation lag on group decision consistency.

[0142] In some embodiments, after obtaining the state of the global coordination variable, it is written directly to the local agent's memory, including:

[0143] When there is timing jitter in the arrival of sensitivity gradients of different agent nodes, the DPU writes the timestamped sensitivity gradients into a circular buffer and performs asynchronous gradient accumulation in the order of the timestamps.

[0144] DPU uses a preset momentum decay factor to perform an exponential moving average smoothing of the current aggregation result and the historical aggregation result.

[0145] The DPU will calculate the state of the global coordination variables after convergence. Encapsulated as INFORM control messages, and bypassing the host kernel protocol stack via Direct Memory Access (RDMA), the state of global coordination variables is written directly to the local agent's memory.

[0146] The DPU writes the timestamped sensitivity gradients into a circular buffer and performs asynchronous gradient accumulation in time-stamp order; then, it smooths the current aggregation result and historical aggregation results using an exponential moving average with a preset momentum decay factor; after convergence, it reconciles the global coordination variable state. It is encapsulated as an INFORM control message and written directly to the local agent memory via RDMA, bypassing the host kernel protocol stack.

[0147] Building upon intra-network aggregation, this paper further considers the issue of inconsistent arrival times of sensitivity gradients in distributed networks, and reduces the impact of timing jitter on aggregation results through a timestamp circular buffer and asynchronous accumulation. Exponential moving average smoothing is used to reduce fluctuations in single aggregation results, making global coordination variable state updates more suitable for continuous collaboration scenarios. Convergence criteria can be designed as follows: the difference between two adjacent aggregation results is less than a preset convergence threshold, a preset number of iterations is reached, or a preset time window is reached. The circular buffer records fields including node identifier, timestamp, sensitivity gradient, confidence weight, and validity period. The RDMA write address is determined by the memory key and target address registered during the session initialization phase.

[0148] The DPU can process sensitivity gradients from different nodes and link delays without relying on host multi-threaded synchronization, making the aggregation results more adaptable to network jitter. By writing the converged global coordination variable state directly to the local agent's memory through RDMA, the host kernel protocol stack can be bypassed, reducing software stack overhead in the state delivery process. This allows the agent to read the global coordination variable state faster and adjust subsequent decision-making or inference behavior accordingly, improving the state synchronization efficiency in multi-node collaboration.

[0149] In some embodiments, the DPU calculates semantic error signals based on the DIKWP model and adjusts host GPU inference resources according to PID control values, including:

[0150] DPU maps the cognitive processes of large language models into data, information, knowledge, wisdom, and intention. Figure 5 Layered network model.

[0151] The DPU's internal control plane samples the set of intelligent decision-making layer output data generated by the host GPU in real time. And read the macro-level target of the intent layer preset during system initialization. .

[0152] DPU uses a lightweight embedding model to... and They are mapped to high-dimensional latent space feature vectors respectively, and the cosine distance between the two high-dimensional latent space feature vectors is used as the real-time error signal. Alternatively, after normalizing the feature vectors of two high-dimensional latent spaces to form a semantic probability distribution, cross-entropy loss can be used as the real-time error signal. .

[0153] The metacognitive controller on the DPU chip calculates the PID control input according to the following formula: ;in, express The set of intelligent decision-making layer output data generated by the host GPU at any moment. express The macro-level intention at the moment, express and The degree of deviation in semantic space, express The computing power allocation for the mainframe inference engine needs to be controlled at all times. Represents the proportional gain coefficient. Represents the integral gain coefficient. Represents the differential gain coefficient. Indicates the historical sampling time. Indicates from the initial time to Historical error accumulation term at time point This represents the rate of change of the error signal with respect to time.

[0154] DPU maps the cognitive processes of large language models into data, information, knowledge, wisdom, and intention. Figure 5 Layered network model; the DPU's internal control plane samples the set of intelligent decision-making layer output data generated by the host GPU in real time. And read the macro-level target of the intent layer preset during system initialization. Subsequently, a lightweight embedding model is used to map both into high-dimensional latent space feature vectors, and the real-time error signal is calculated using cosine distance or cross-entropy loss. Then, the metacognitive controller on the DPU chip calculates the computing power control limit based on the PID control law. .

[0155] Real-time error signals can be represented using cosine distance: In the formula, express Real-time error signal at any given moment; This represents the data set output by the intelligent decision-making layer. The high-dimensional latent space feature vector obtained by mapping; This indicates the macro-level goal from the intent layer. The high-dimensional latent space feature vector obtained by mapping; This represents the inner product of two eigenvectors in a high-dimensional latent space. express The second norm; express The 2-norm.

[0156] Real-time error signals can also be represented in the form of cross-entropy loss: In the formula, express Real-time error signal at any given moment; The dimension representing the normalized semantic probability distribution; Indicates the dimension number in the semantic probability distribution; Indicating the macro-level goal of the intent layer After normalization, at the first Probability values ​​in each dimension; This represents the set of data output by the intelligent decision-making layer. After normalization, at the first Probability values ​​in each dimension; Represents the natural logarithm operation.

[0157] The semantic deviation between the large language model's inference output and the task intent is quantified as an error signal in the control system, and then the DPU-side cognitive controller performs PID control calculations. This approach differs from statically setting model inference parameters; instead, it uses continuous sampling... and This creates dynamic feedback. It can consist of the model's current output, candidate answers, tool call results, or decision summaries. It can consist of task objectives, constraints, and expected output indicators; when implemented in a DPU, the integral and differential terms can be discretely calculated according to a fixed sampling period.

[0158] The DPU can dynamically calculate the inference resource allocation based on the real-time deviation between the model output and the target intent, providing feedback control for the host GPU inference process. When the semantic error is large, the control variable can guide an increase in the inference budget or the adoption of deeper retrieval and inference strategies; when the error is small or tends to stabilize, the control variable can reduce unnecessary generation overhead. This mechanism helps reduce resource waste or insufficient inference caused by fixed inference parameters, achieving a high degree of matching between computing power allocation and task difficulty and semantic deviation.

[0159] In some embodiments, the DPU adjusts the cognitive reasoning path and cross-domain migration based on the PID control input, including:

[0160] The DPU will control the PID input. The parameters are converted to host GPU inference computation upper limit control parameters. The inference control parameters include generation length parameters, sampling candidate range parameters, and retrieval enhancement parameters. Among them, the generation length parameter includes max_new_tokens, the sampling candidate range parameters include Top-P and Top-K, and the retrieval enhancement parameters include RAG knowledge base retrieval depth.

[0161] The DPU guides the host to evolve its cognitive state within the DIKWP model framework according to the following formula: ;in, express The data layer state at any given time. express The information layer state at any given moment. express The state of the knowledge layer at any given moment. express The state of the intelligence layer at any given moment. express The state of intent at any given moment. This indicates the data layer state at the next update time. This represents the dynamic evolution function.

[0162] When the real-time error signal Below the preset convergence threshold, or real-time error signal When the rate of change is lower than the preset steady-state threshold, the DPU triggers an early stop mechanism, truncates the current inference generation process, and releases the GPU memory.

[0163] When the real-time error signal When the deviation exceeds the preset threshold, the DPU increases the PID control input. It guides the host to perform logical expansion of the mind tree or to re-reason by tracing back the historical cognitive path; when the amount of context data exceeds the preset context capacity threshold, the DPU triggers cross-domain scheduling, which migrates the current agent's state slice to the agent's physical server node with idle GPU computing power via a high-speed network.

[0164] The DPU will control the PID input. The inference control parameters are converted to host GPU parameters, including max_new_tokens, Top-P, Top-K, and RAG knowledge base retrieval depth. The DPU guides the host to evolve its cognitive state according to the DIKWP model framework. When the real-time error signal meets the convergence or steady-state conditions, early stopping is triggered and GPU memory is released. When the error signal is higher than the deviation threshold, the control input is increased and the host is guided to perform mind tree logic expansion or backtrack the historical cognitive path for re-inference. When the amount of context data exceeds the threshold, cross-domain migration of state slices is triggered.

[0165] The PID control input is further transformed into specific control parameters that can be applied to the host large language model inference process. Combined with DIKWP state evolution, early stopping, deep inference, and cross-domain migration, a complete inference scheduling closed loop is formed, linking semantic error control results with inference resource adjustment, inference path adjustment, and node migration. Specifically, the inference computation upper limit control parameter is the inference control parameter; `max_new_tokens` and `RAG` retrieval depth are used to control computational load; and Top-P and Top-K are used to control the candidate token sampling range. State slices include session identifier, context digest, current DIKWP state, KV Cache reference information, permission token, and migration verification digest. The migration target node is determined by a distributed hash table or a resource monitoring table containing nodes with idle GPU computing power that meet permission constraints.

[0166] The DPU can translate semantic error feedback into specific inference parameter adjustments, enabling the inference process of large language models to dynamically change according to the task state. When the output is close to the target intent, the early stopping mechanism can reduce token consumption and GPU memory usage caused by continued generation; when the output deviates from the target, increasing control variables and introducing thought tree expansion or historical path backtracking can improve the sufficiency of inference in complex tasks; when the amount of context data exceeds the carrying capacity of the current node, state slice cross-domain migration can transfer the task to a node with idle GPU computing power, thereby improving the elastic utilization of distributed inference resources.

[0167] Another embodiment of the present invention provides a multi-agent semantic communication offloading and acceleration device based on a data processor, applied to a distributed inference network including multiple agent physical server nodes, each agent physical server node including host computing resources and a DPU, including:

[0168] A module is created to deploy DPUs on each agent's physical server node, establish a zero-copy transmission channel between the DPU and the host GPU memory that bypasses the main CPU, and have the DPU register the semantic controller, extract the capability tags of the large language model of the node, and publish them to the distributed hash table.

[0169] The response module is used to respond to collaboration requests initiated by the local agent. The DPU intercepts the request, extracts intent metadata, and matches the target agent node in the distributed hash table.

[0170] The interaction module is used for semantic negotiation of control messages and locking of shared context modes between the DPUs of the two communicating parties.

[0171] The verification module is used by the receiver DPU to perform format verification, semantic security detection, and anomaly handling on the arriving payload based on the shared context mode.

[0172] The monitoring module is used by the DPU to monitor session token consumption and context history blocks, and to prune the context when trigger conditions are met.

[0173] The extraction module is used to extract decision sensitivity signals from the DPU and perform intra-network aggregation. After obtaining the state of the global coordination variables, it is written directly to the local agent memory.

[0174] The computation module is used by the DPU to calculate semantic error signals based on the DIKWP model, and adjust the host GPU inference resources, cognitive inference paths and cross-domain migrations according to the PID control input.

[0175] It should be noted that although several units or sub-units of the device have been mentioned in the detailed description above, this division is merely exemplary and not mandatory. In fact, according to embodiments of this application, the features and functions of two or more units described above can be embodied in one unit. Conversely, the features and functions of one unit described above can be further divided and embodied by multiple units.

[0176] Based on the same inventive concept as the above method embodiments, this application also provides an electronic device, including a memory, a processor, and a computer program stored in the memory and executable on the processor. When the processor executes the computer program, it enables the electronic device to implement the control method described in the above embodiments.

[0177] In one embodiment, the electronic device may be a server, and in this embodiment, the structure of the electronic device may be as follows: Figure 9 As shown, it includes a memory, a communication module, and one or more processors.

[0178] Memory is used to store computer programs executed by the processor. Memory can be mainly divided into a program storage area and a data storage area. The program storage area can store the operating system and programs required to run instant messaging functions, etc.; the data storage area can store various instant messaging information and operation instruction sets, etc.

[0179] Memory can be volatile memory, such as random access memory (RAM); memory can also be non-volatile memory, such as read-only memory, flash memory, hard disk drive (HDD), or solid-state drive (SSD); or memory can be any other medium capable of carrying or storing a desired computer program having the form of instructions or data structures and accessible by a computer, but is not limited thereto. Memory can be a combination of the above-mentioned types of memory.

[0180] A processor may include one or more central processing units (CPUs) or digital processing units, etc. A processor is used to implement the aforementioned data processing methods when a computer program stored in memory is invoked.

[0181] The communication module is used to communicate with terminal devices and other servers.

[0182] This application embodiment does not limit the specific connection medium between the above-described memory, communication module, and processor. This application embodiment... Figure 9 The memory and processor are connected via a bus, and the bus is in... Figure 9 The connections between other components are illustrated with arrows and are for illustrative purposes only, not as limiting information. Buses can be categorized as address buses, data buses, control buses, etc. For ease of description, Figure 9 The text uses only one arrow to describe it, but does not indicate that there is only one bus or one type of bus.

[0183] Based on the same inventive concept as the above-described method embodiments, embodiments of the present invention also provide a computer-readable storage medium for storing a computer program. When the computer program is run on a computer, it enables an electronic device to implement the control methods described in the above embodiments. The computer-readable storage medium can be a readable signal medium or a readable storage medium. A readable storage medium can be, for example, but not limited to, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination thereof. More specific examples of readable storage media (a non-exhaustive list) include: an electrical connection having one or more wires, a portable disk, a hard disk, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage device, magnetic storage device, or any suitable combination thereof.

[0184] Based on the same inventive concept as the above-described method embodiments, embodiments of the present invention also provide a computer program product. The computer program product includes a computer program that, when run on an electronic device, causes the electronic device to perform the steps of the control methods described above according to various exemplary embodiments of this application. The program product may take the form of any combination of one or more readable media. These computer program commands can be provided to a processor of a general-purpose computer, special-purpose computer, embedded processor, or other programmable data processing device to produce a machine, such that the commands executed by the processor of the computer or other programmable data processing device generate a process for implementing... Figure 1One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0185] While the present invention has been disclosed above with reference to preferred embodiments, it is not intended to limit the invention. Those skilled in the art can make various modifications and refinements without departing from the spirit and scope of the invention. Therefore, the scope of protection of the present invention shall be determined by the claims.

Claims

1. A method for offloading and accelerating multi-agent semantic communication based on a data processor, applied to a distributed inference network comprising multiple agent physical server nodes, each agent physical server node including host computing resources and a DPU, characterized in that, include: Deploy DPUs on each agent's physical server node, establish a zero-copy transmission channel between the DPU and the host GPU memory that bypasses the main CPU, and have the DPU register the semantic controller, extract the capability tags of the large language model of the node, and publish them to the distributed hash table. In response to a collaboration request initiated by a local agent, the DPU intercepts the request, extracts intent metadata, and matches the target agent node in a distributed hash table; The DPUs of both communicating parties negotiate the semantics of the control messages and lock the shared context mode. The receiving DPU performs format verification, semantic security detection, and anomaly handling on the arriving payload based on the shared context mode. The DPU monitors session token consumption and context history blocks, and prunes the context when triggering conditions are met. The decision sensitivity signal is extracted by the DPU and aggregated within the network. After obtaining the state of the global coordination variable, it is written directly to the local agent memory. The DPU calculates semantic error signals based on the DIKWP model and adjusts host GPU inference resources, cognitive inference paths, and cross-domain migrations according to PID control values.

2. The method for offloading and accelerating multi-agent semantic communication based on a data processor according to claim 1, characterized in that, The deployment of DPUs on each agent's physical server node includes: Install a DPU with a multi-core ARM computing cluster and an independent hardware acceleration engine on each participating agent physical server node; The DPU establishes a direct transmission channel with the GPU memory or registered memory based on DOCA, RDMA, and GPUDirect. The host computing resources are used to perform large language model inference, while the DPU is used to take over the processing of agent communication protocols and the parsing of network packets in the semantic negotiation layer. The semantic controller scans the domain capability tags supported by the large language model of this node, encapsulates the domain capability tags, semantic context set, constraints and node addressing information into an agent capability card, and publishes the agent capability card to a distributed hash table.

3. The method for offloading and accelerating multi-agent semantic communication based on a data processor according to claim 1, characterized in that, The response to the collaboration request initiated by the local agent involves the DPU intercepting the request, extracting intent metadata, and matching the target agent node in the distributed hash table, including: The local DPU extracts intent metadata that characterizes the semantic intent of the collaborative task from the collaboration request, and maps the intent metadata into an intent vector; The local DPU reads the agent capability card from the distributed hash table and performs similarity matching between the intent vector and the capability tag vector in the agent capability card; When the similarity score reaches the preset routing threshold, the physical server node of the agent with the highest similarity score is determined as the target agent node.

4. The method for offloading and accelerating multi-agent semantic communication based on a data processor according to claim 1, characterized in that, The process of semantic negotiation and control messages between the DPUs of both communicating parties, and locking the shared context mode, includes: The DPUs of both communicating parties exchange SNL-HELLO control messages, SNL-SELECT control messages, and SNL-LOCK control messages sequentially at the network interface card. The SNL-HELLO control message is used to declare the set of semantic contexts and constraints supported by the local large language model; The SNL-SELECT control message is used to select a shared context reference based on the set of semantic contexts supported by both parties; The SNL-LOCK control message is used to lock the context interaction protocol and bind the context interaction protocol to a strongly typed JSON Schema.

5. The method for offloading and accelerating multi-agent semantic communication based on a data processor according to claim 4, characterized in that, The receiving DPU performs format verification, semantic security checks, and anomaly handling on the arriving payload based on the shared context mode, including: Before the application layer communication load enters the receiver host memory, the receiver DPU captures the application layer communication load through a built-in hardware regular expression acceleration engine. The receiving DPU converts the strongly typed JSON Schema into pattern matching rules and syntax validation rules, and performs pattern matching and syntax validation on the application layer communication load; When the application layer communication load does not conform to the pattern matching rule or syntax validation rule, the receiving DPU constructs a retransmission request or clarification request to the sender at the network interface card. The receiver DPU runs a quantized neural network inference model on a high-speed parallel data path to extract features from the JSON business payload that has passed syntax validation and output anomaly confidence. When the anomaly confidence level reaches the preset anomaly threshold, and the anomaly type is a semantic injection command or semantic denial-of-service traffic, the receiving DPU discards the corresponding service payload on the network interface card side.

6. The method for offloading and accelerating multi-agent semantic communication based on a data processor according to claim 1, characterized in that, The DPU monitors session token consumption and context history blocks, and prunes the context when trigger conditions are met, including: The DPU tracks the total number of tokens in the business application request messages in real time at the network transport layer and records the increment of the context history block over time. It also establishes a dynamic context baseline model for each active agent session. Context pruning is triggered when the similarity between the current intent vector and the baseline intent vector in the dynamic context using the baseline model is lower than the preset switching threshold, or when the total number of accumulated historical interaction tokens reaches the host GPU's preset high-bandwidth memory KV Cache red line threshold. The DPU assigns relevance weights to context history blocks based on the current session intent, reassembles the context data to be transmitted at the semantic agent layer, removes outdated task objective settings, and truncates redundant historical dialogue records into those that are most recent in time and have the highest relevance weights. This interaction, among which... This indicates the preset number of interactions to retain.

7. The method for offloading and accelerating multi-agent semantic communication based on a data processor according to claim 1, characterized in that, The decision sensitivity signal is extracted by the DPU and aggregated within the network, including: The DPU intercepts unstructured decision-making reasoning data sent by the local agent, and extracts the partial derivatives or gradients of environmental variable changes on the current decision result through local lightweight parsing to form a sensitivity gradient. Each level of the DPU acts as a distributed coordination agent for the ripple effect protocol, aggregating the sensitivity gradients transmitted from neighboring physical nodes at the network switching layer, and updating the state of the global coordination variables according to the following formula: ;in, This represents the current state of the global coordination variable. This represents the state of the global coordination variable at the next update time. Indicates the current moment. The aggregation step size parameter represents the convergence speed of the control system. This represents the total number of agent nodes participating in coordination within the current subnet. Indicates the sequence number of the intelligent agent node participating in the coordination. Represents intelligent agents exist Sensitivity representation value at time, Represents intelligent agents exist Sensitivity gradient at time, This refers to intelligent agents that assign trust or identity permissions based on network topology. The confidence weighting coefficient.

8. The method for offloading and accelerating multi-agent semantic communication based on a data processor according to claim 7, characterized in that, After obtaining the state of the global coordination variables, write it directly to the local agent's memory, including: When there is timing jitter in the arrival of sensitivity gradients of different agent nodes, the DPU writes the timestamped sensitivity gradients into a circular buffer and performs asynchronous gradient accumulation in the order of the timestamps. DPU uses a preset momentum decay factor to perform an exponential moving average smoothing of the current aggregation result and the historical aggregation result; The DPU will calculate the state of the global coordination variables after convergence. The global coordination variable state is encapsulated as an INFORM control message and written directly to the local agent memory via Direct Memory Access (RDMA) across the host kernel protocol stack.

9. The method for offloading and accelerating multi-agent semantic communication based on a data processor according to claim 1, characterized in that, The DPU calculates semantic error signals based on the DIKWP model and adjusts the host GPU inference resources according to the PID control input, including: DPU maps the cognitive process of the large language model into a five-layer network model of data, information, knowledge, wisdom and intention; The DPU's internal control plane samples the set of intelligent decision-making layer output data generated by the host GPU in real time. And read the macro-level target of the intent layer preset during system initialization. ; DPU uses a lightweight embedding model to... and They are mapped to high-dimensional latent space feature vectors respectively, and the cosine distance between the two high-dimensional latent space feature vectors is used as the real-time error signal. Alternatively, after normalizing the feature vectors of two high-dimensional latent spaces to form a semantic probability distribution, cross-entropy loss can be used as the real-time error signal. ; The metacognitive controller on the DPU chip calculates the PID control input according to the following formula: ;in, express The set of intelligent decision-making layer output data generated by the host GPU at any moment. express The macro-level intention at the moment, express and The degree of deviation in semantic space, express The computing power allocation for the mainframe inference engine needs to be controlled at all times. Represents the proportional gain coefficient. Represents the integral gain coefficient. Represents the differential gain coefficient. Indicates the historical sampling time. Indicates from the initial time to Historical error accumulation term at time point This represents the rate of change of the error signal with respect to time.

10. A method for offloading and accelerating multi-agent semantic communication based on a data processor according to claim 9, characterized in that, The DPU adjusts the cognitive reasoning path and cross-domain transfer based on the PID control input, including: The DPU will use the PID control quantity The inference computation upper limit control parameters are converted to host GPU inference computing limits. The inference control parameters include generation length parameters, sampling candidate range parameters, and retrieval enhancement parameters. The generation length parameter includes max_new_tokens, the sampling candidate range parameters include Top-P and Top-K, and the retrieval enhancement parameters include RAG knowledge base retrieval depth. The DPU guides the host to evolve its cognitive state within the DIKWP model framework according to the following formula: ;in, express The data layer state at any given time. express The information layer state at any given moment. express The state of the knowledge layer at any given moment. express The state of the intelligence layer at any given moment. express The state of intent at any given moment. This indicates the data layer state at the next update time. Represents the dynamic evolution function; When the real-time error signal Below the preset convergence threshold, or real-time error signal When the rate of change is lower than the preset steady-state threshold, the DPU triggers the early stop mechanism, cuts off the current inference generation process, and releases the GPU memory; When the real-time error signal When the deviation exceeds the preset threshold, the DPU increases the PID control input. It guides the host to perform logical expansion of the mind tree or to re-reason by tracing back the historical cognitive path; when the amount of context data exceeds the preset context capacity threshold, the DPU triggers cross-domain scheduling, which migrates the current agent's state slice to the agent's physical server node with idle GPU computing power via a high-speed network.

Images