A method and system for orchestrating asynchronous intelligent agents in edge IoT

Abstract

This invention discloses an asynchronous intelligent agent orchestration method and system for edge IoT. Its features include: acquiring a computational task containing a directed acyclic graph (DAG); obtaining an extended address-event representation frame sequence through multi-channel pulse coding and frame serialization; dividing the DAG into multiple subgraphs; selecting target asynchronous agents for each subgraph based on the principle of minimum weighted cost; and using a global asynchronous-local synchronous strategy and a four-phase asynchronous handshake protocol for routing; executing each target asynchronous agent in parallel, encoding the results as pulse events for feedback; maintaining causal order relationships using vector clocks and merging them to obtain the task output vector; supporting bidirectional conversion between the extended address-event representation frame sequence and application layer protocols; and outputting the orchestration results. Its advantages include stable dynamic rerouting and causal order aggregation even in large-scale heterogeneous node clusters, fully meeting the stringent requirements of edge IoT for real-time performance, energy efficiency, and scalability.

Description

Technical Field

[0001] This invention relates to the fields of edge computing and neuromorphic engineering technology, and in particular to an asynchronous intelligent agent orchestration method and system for edge Internet of Things. Background Technology

[0002] Edge IoT refers to a distributed architecture that integrates sensing and computing capabilities at the network edge, close to the data source. Nodes typically operate as asynchronous agents—that is, they do not rely on a global clock or synchronous locksteps, but rather make independent decisions based on local events (such as pulse arrivals or task queue changes) and interact loosely with other nodes. Neuromorphic chips, with their event-driven spiking neural network computing paradigm, are naturally suited to this asynchronous agent characteristic, and address-event representation protocols are commonly used as the de facto standard for information exchange between nodes. However, when traditional address-event representation protocols were defined by Boahen in 2000, they only included neuron address and pulse timestamp fields, lacking application-layer orchestration information such as task identifiers, node identifiers, and priorities. This meant that cross-node task distribution and result aggregation had to rely on the TCP / IP protocol stack, significantly increasing the communication latency and power consumption required for millisecond-level real-time collaboration.

[0003] Existing neuromorphic single-chip orchestration solutions (such as Intel Loihi series) support multi-core scheduling within a single chip or board, but fail to provide task-level routing and runtime dynamic rerouting across heterogeneous edge nodes. Existing spiking neural network decomposition methods for edge clusters (such as EC-SNN) statically determine sub-model deployment during the training phase, and cannot perform dynamic rerouting between nodes based on changes in cluster load or spiking density during runtime, and still rely on upper-layer Ethernet and TCP / IP for node collaboration. Existing general multi-agent orchestration frameworks (such as AutoGen) achieve multi-turn conversational collaboration by calling large language models in the cloud, but their communication latency and single inference power consumption cannot meet the millisecond-level real-time requirements and milliwatt-level power budget of edge IoT, and are not based on neuromorphic event-driven communication. Summary of the Invention

[0004] The technical problem to be solved by the present invention is to provide an asynchronous intelligent agent orchestration method and system for edge IoT, so as to realize task-level dynamic routing and runtime rerouting across heterogeneous edge nodes, reduce communication latency and power consumption, and meet the millisecond-level real-time performance and milliwatt-level power consumption budget of edge IoT.

[0005] The technical solution adopted by this invention to solve the above-mentioned technical problems is: an asynchronous intelligent agent orchestration method for edge IoT, comprising the following steps: Step 1: Obtain the computation task containing the directed acyclic graph of the task. After multi-channel pulse coding, obtain the pulse sequence of task pulse events containing multi-channel output. Serialize each task pulse event in the pulse sequence together with the frame integrity check code into an extended address-event representation frame to form an extended address-event representation frame sequence. Step 2: Divide the task's directed acyclic graph into multiple subgraphs containing subgraph labels; Step 3: The router of the source asynchronous agent selects the target asynchronous agent for each subgraph according to the principle of weighted minimum cost, and obtains the mapping scheme from the subgraph to the target asynchronous agent. The extended address-event representation frame sequence is routed to the corresponding target asynchronous agent by adopting the global asynchronous local synchronization strategy and the four-phase asynchronous handshake protocol. Step 4: Each target asynchronous agent executes the assigned subgraph in parallel to obtain the corresponding subgraph calculation result; the subgraph calculation result is encoded element by element into a result pulse event through the result encoder; the subgraph identifier is written into the corresponding result pulse event, and then serialized into a result frame sequence and sent back to the source asynchronous agent; Step 5: The source asynchronous agent uses a vector clock to maintain the causal order of the computation results of each subgraph, collects and merges the computation results of the subgraph according to the causal order, and obtains the task output vector. Step 6: When the task output vector needs to be uploaded to the cloud, or when an external system needs to interact with the protocol stack, implement the bidirectional conversion between the extended address-event representation frame sequence and the application layer protocol, and output the orchestration result.

[0006] Compared with existing technologies, the advantages of this invention lie in extending the traditional address-event representation protocol to an extended address-event representation frame and serializing it into a frame sequence. This allows task impulse events to directly transmit application layer orchestration information between asynchronous agents, thereby avoiding reliance on the TCP / IP protocol stack for task distribution and result aggregation, significantly reducing communication latency and power consumption. Furthermore, the invention divides the task directed acyclic graph into multiple subgraphs with subgraph labels, dynamically selects the target asynchronous agent for each subgraph using the weighted minimum cost principle, and combines a global asynchronous local synchronization strategy and a four-phase asynchronous handshake protocol for routing. This allows the runtime to adjust according to cluster load or impulse density. The method re-plans the subgraph mapping path, realizing dynamic rerouting and loosely coupled collaboration across heterogeneous edge nodes, avoiding the limitations of static deployment. Each target asynchronous agent executes the subgraph in parallel, and writes the subgraph identifier into the result pulse event through the result encoder and then sends it back. The vector clock is used to maintain the causal order relationship between the calculation results of each subgraph, ensuring that out-of-order results can be merged in the correct order, thereby supporting real-time and reliable edge task aggregation. The extended address-event representation frame and application layer protocol bidirectional conversion capability enable this method to maintain the low power consumption advantage of event-driven neuromorphic chips, and seamlessly connect with the cloud or external systems as needed. Experimental verification shows that in the drone swarm scenario, the present invention achieves an F1 score of 89.3% and a task completion rate of 100%, proving its reliable task orchestration and collaborative execution capabilities in highly dynamic edge environments. In the medical sensor scenario, the anomaly detection sensitivity reaches 100%, the average node power consumption is only 0.825mW, and the battery life is as long as 30.4 days, fully verifying the event-driven communication advantage of the present invention, which can still maintain millisecond-level real-time response under a milliwatt-level power budget. In the industrial IoT scenario, the fault detection accuracy and system availability both reach 100%, indicating that the present invention can still achieve stable dynamic rerouting and causal order aggregation even in large-scale heterogeneous node clusters, fully meeting the stringent requirements of edge IoT for real-time performance, energy efficiency, and scalability.

[0007] In one feasible implementation, in step 1, the computation task sent by the application layer is obtained and a task identifier is assigned to it. The computation task includes task priority, task directed acyclic graph, d-dimensional feature vector and computational complexity. The multi-channel system includes rate coding channel, time coding channel, population coding channel and burst coding channel, which respectively map task priority, partial order relation of the task directed acyclic graph, d-dimensional feature vector and computational complexity into task pulse events with different frame type identifiers; The task pulse event includes at least an orchestration information field for identifying the task, subgraph, source node, and target node; The extended address-event representation frame adds an orchestration information field and a frame integrity verification field to the traditional address-event representation protocol, and is composed of multiple extended address-event representation frames concatenated end-to-end to form an extended address-event representation frame sequence. By mapping task priority, partial order relationship, feature dimension, and computational complexity to four channels—rate coding, time coding, population coding, and burst coding—and distinguishing them with different frame type identifiers, task attributes can be fully expressed in the pulse domain without adding additional time synchronization overhead. The setting of the orchestration information field in the extended address-event representation frame allows application layer information such as task identifier, subgraph identifier, source node, and target node to be directly carried in the event, eliminating the encapsulation and parsing delay of the upper-layer protocol stack, thereby establishing a complete application layer semantic context at the source of event-driven communication.

[0008] In one feasible implementation, in step 2, the subgraph consists of a subset of nodes in the task directed acyclic graph and a subgraph identifier. The specific method of step 2 is as follows: Step 2-1: Sort all edges of the directed acyclic graph of the task in descending order of weight, and merge the two end nodes of edges whose two-end nodes are not matched into super nodes to obtain the coarsened graph. Step 2-2: Sort the supernodes of the coarsened graph in descending order of weight, and use a greedy strategy to assign them to the partitions with the smallest load-to-capacity ratio, resulting in K partitions. K is monotonically increasing as the proportion of asynchronous agents in an asynchronous agent cluster composed of multiple asynchronous agents in an active or overloaded state increases, or as the average instantaneous pulse frequency of each asynchronous agent in the cluster increases, and does not exceed the total number of nodes in the directed acyclic graph of the task. Steps 2-3 involve migrating each node in the directed acyclic graph of the task to the partition containing either the predecessor or successor node that reduces the total cost. After iterative convergence, K subgraphs are obtained by grouping the nodes by partition. The predecessor node is a node with a directed edge pointing to the current node, and the successor node is a node with a directed edge pointing to the current node. The total cost is a weighted sum of the cross-partition communication cost, the node load balancing cost, and the critical path extension cost after partitioning.

[0009] By reducing the graph size through supernode merging in the coarsening phase, ensuring load balancing through greedy partitioning, and minimizing the total cost through node migration and iteration, the three collaboratively enable the directed acyclic graph of the task to dynamically adjust the number of partitions at runtime based on the proportion of active nodes in the cluster and the instantaneous pulse frequency. This ensures that the cross-partition communication cost between subgraphs, the load balancing of each agent, and the critical path latency are all in a weighted optimal state after partitioning, thereby improving the flexibility of rerouting and the real-time performance of task execution while ensuring partitioning efficiency.

[0010] In one feasible implementation, in step 3, the specific method by which the router of the source asynchronous agent selects the target asynchronous agent for each subgraph according to the principle of minimum weighted cost is as follows: Before selecting a target asynchronous agent for each subgraph, the source asynchronous agent will consider asynchronous agents that are in a ready state, or in a light sleep state and can be woken up, or in a deep sleep state and can be woken up as candidate asynchronous agents. The weighted cost of each candidate asynchronous agent is calculated based on the normalized load of each candidate asynchronous agent, the link delay between the source asynchronous agent and the candidate asynchronous agent, the energy consumption estimate of the candidate asynchronous agent in completing the subgraph, and the weighted sum of the affinity between the subgraph task type and the candidate asynchronous agent. The candidate asynchronous agent with the smallest weighted cost is selected as the target asynchronous agent of the subgraph. In the global asynchronous local synchronization strategy, the asynchronous agents do not share a global clock and exchange extended address-event representation frame sequences through a four-phase asynchronous handshake protocol. Each asynchronous agent maintains a local clock and a vector clock and advances the spiking neural network inference according to the local time step sequence. The four-phase asynchronous handshake protocol includes four phases: request, confirmation, data transmission, and completion confirmation.

[0011] The candidate asynchronous agent screening mechanism excludes unresponsive sleeping nodes, avoiding invalid routing. The weighted cost calculation of normalized load, link latency, energy consumption estimation, and affinity achieves a dynamic trade-off between communication overhead, execution energy consumption, and task matching degree, so that the target selection takes into account both the current network and node state and the subgraph task type. The global asynchronous local synchronization strategy, together with the four-phase handshake protocol, ensures that cross-node interaction can reliably complete frame exchange without a common clock, eliminates global synchronization waiting time, and improves the scalability of large-scale heterogeneous clusters and the robustness of event-driven communication.

[0012] In one feasible implementation, in step 4, the specific method for each target asynchronous agent to execute the assigned subgraph in parallel is as follows: if the target asynchronous agent is in a light sleep state or a deep sleep state, the source asynchronous agent generates a wake-up sequence to trigger the target asynchronous agent to enter the ready state. After receiving the extended address-event representation frame sequence, each target asynchronous agent enters the active state and then executes the assigned subgraph in parallel. The resulting pulse event includes ten fields: neuron address, timestamp, frame type, orchestration flag, priority, task identifier, subgraph identifier, source node, destination node, and sequence number.

[0013] In one feasible implementation, steps 4 and 5 further include: when a subgraph is not executed by the original target asynchronous agent and fails to return a complete result frame sequence to the source asynchronous agent within a preset time limit, the execution of the subgraph is determined to have failed, and a three-level retry mechanism is triggered to ensure the eventual consistency of the task: the first-level retry involves the original target asynchronous agent re-executing the subgraph; if the first level fails, the second-level retry calls the router of the source asynchronous agent to select a new target asynchronous agent for the subgraph and reroutes to the new target asynchronous agent for execution; if the second level still fails, the third-level retry calls the wake-up sequence to wake up a supplementary asynchronous agent in a shallow or deep sleep state to take over the subgraph, or performs overall degradation processing on the computation task.

[0014] By leveraging existing weighted cost routing capabilities and wake-up sequences, eventual consistency of tasks is achieved without introducing an external coordinator. The granularity of the three-level retries is progressively relaxed, which avoids the jitter caused by frequent routing and enables rapid switching to global backup resources in the event of local failure. This significantly improves the task completion rate of the edge IoT asynchronous intelligent agent cluster under the conditions of node failure or link fluctuation.

[0015] In one feasible implementation, step 5 specifically includes: creating a vector clock for each asynchronous agent upon registration; before each subgraph is completed and ready to submit its computation results, the vector clock of the corresponding asynchronous agent increments and returns a deep copy snapshot, which is then written as a clock field along with the subgraph computation results to the source asynchronous agent; after receiving the subgraph computation results from all subgraphs, the source asynchronous agent sorts all subgraph computation results according to the causal order determined by the vector clock, where concurrent subgraph computation results are sorted lexicographically by timestamp and asynchronous agent identifier; based on the sorted subgraph computation results, the computation result arrays of each subgraph are sequentially extracted and vector-concatenated to obtain the task output vector. This method does not rely on a global clock or lockstep synchronization, but is entirely based on event-driven local clocks and vector logic clocks, naturally matching the asynchronous architecture of steps 1 to 4, achieving low-overhead, highly reliable result aggregation.

[0016] In one feasible implementation, in step 6, the orchestration result includes the task identifiers assigned in step 1, the K subgraphs obtained in step 2, the mapping scheme obtained in step 3, the task output vectors obtained in step 5, and the event streams, computational latency decomposition data, and network latency decomposition data generated during the execution of steps 1 to 5. The event streams are the event sequences published by the event bus and filtered according to the task identifiers in steps 1 to 5. The computational latency decomposition data is the maximum time required for each target asynchronous agent to execute the subgraph in parallel in step 4. The network latency decomposition data is the sum of the network latency from the source asynchronous agent to the target asynchronous agent in step 3 and the network latency from the target asynchronous agent to the source asynchronous agent in step 4.

[0017] In one feasible implementation, the system further includes driving a five-level power state machine to perform state transitions for each asynchronous agent during operation based on the instantaneous pulse frequency generated by the agent's pulse activity: when the instantaneous pulse frequency exceeds a preset threshold, the asynchronous agent transitions from the ready state to the active state; when the instantaneous pulse frequency is below the threshold and lasts for more than 2 seconds, the asynchronous agent reverts from the active state to the ready state; when the asynchronous agent has no pulse activity for 10 seconds, it descends to a shallow sleep state; when the asynchronous agent has no pulse activity for another 60 seconds, it descends to a deep sleep state; the wake-up path is reverse triggering: when a pulse event or task allocation signal is received, the asynchronous agent wakes up from the sleep state step by step; the activity decay adopts the Loihi2 fixed-point leak integral distribution model. The five-level power state machine, from low to high, includes ultra-deep sleep, deep sleep, light sleep, ready, and active states. This five-level power state machine achieves dynamic power management ranging from 0.001mW to 300mW, enabling each asynchronous intelligent agent to autonomously adjust its power consumption state according to actual computing needs. It eliminates the need for a central scheduler and is fully compatible with event-driven neuromorphic chips. Thus, it automatically enters a microwatt-level sleep mode when idle and provides milliwatt to hundreds of milliwatt-level computing power when active, meeting the stringent power budget requirements of edge IoT under different loads.

[0018] An edge IoT asynchronous intelligent agent orchestration system includes a pulse coding layer, a computation graph segmentation layer, a routing layer, a parallel execution layer, a result aggregation layer, and a protocol bridging layer; The pulse coding layer is used to obtain computational tasks containing directed acyclic graphs of tasks, and after multi-channel pulse coding, it generates extended address-event representation frame sequences. The computation graph segmentation layer is used to segment the task directed acyclic graph into multiple subgraphs containing subgraph identifiers; The routing layer is set in the source asynchronous agent and is used to select the target asynchronous agent for each subgraph according to the principle of minimum weighted cost. It also uses a global asynchronous local synchronization strategy and a four-phase asynchronous handshake protocol to route the extended address-event representation frame sequence to the corresponding target asynchronous agent. The parallel execution layer is set in each target asynchronous agent to execute the assigned subgraph in parallel, obtain the corresponding subgraph calculation results, and encode the subgraph calculation results into a result pulse event sequence and send it back to the source asynchronous agent; The result aggregation layer is set in the source asynchronous agent and is used to maintain the causal order relationship of the calculation results of each subgraph using a vector clock, and merge them to obtain the task output vector; The protocol bridging layer is used to implement bidirectional conversion between extended address-event representation frame sequences and application layer protocols, and output orchestration results.

[0019] By hierarchically dividing and coordinating the pulse coding layer, computation graph segmentation layer, routing layer, parallel execution layer, result aggregation layer, and protocol bridging layer, the generation of extended address-event representation frames, subgraph partitioning and dynamic mapping, asynchronous handshake routing, parallel execution, causal order aggregation, and protocol conversion are decoupled into independent functional modules. Each layer interacts with the others through event streams and standard interfaces, enabling the system to support runtime dynamic rerouting and fault-tolerant recovery, as well as flexibly adapt to cloud integration requirements. Overall, the modular architecture realizes a closed-loop end-to-end approach to edge IoT asynchronous intelligent agent orchestration, possessing the advantages of high cohesion and low coupling in systems engineering, and can be directly deployed on existing neuromorphic chip clusters. Attached Figure Description

[0020] Figure 1 A general flowchart of an edge IoT asynchronous intelligent agent orchestration method provided in an embodiment of the present invention; Figure 2 A field format diagram of a 128-bit extended address-event representation frame sequence provided in an embodiment of the present invention; Figure 3 A timing diagram of a four-phase asynchronous handshake protocol provided for an embodiment of the present invention; Figure 4 A transition diagram of a five-level power consumption state machine provided in an embodiment of the present invention; Figure 5 An architecture diagram of an edge IoT asynchronous intelligent agent orchestration system provided in an embodiment of the present invention; Figure 6 This is a schematic diagram of key performance indicators for Scenario 1 provided in an embodiment of the present invention; Figure 7 This is a schematic diagram of key performance indicators for Scenario 2 provided in this embodiment of the invention; Figure 8This is a schematic diagram of key performance indicators for Scenario 3 provided in the embodiments of the present invention. Detailed Implementation

[0021] The present invention will be further described in detail below with reference to the accompanying drawings and embodiments.

[0022] In this invention, the asynchronous agent refers to each computing entity in the neuromorphic edge computing system that possesses independent asynchronous characteristics. These asynchronous characteristics are manifested in the following ways: (1) Independent clock domain - Under the fully asynchronous local synchronous architecture, there is no global clock between nodes, and each node operates independently using its own clock; (2) Independent power state machine - Each node autonomously switches between five power states without relying on centralized scheduling; (3) Independent inference engine - Each node carries its own spiking neural network inference backend and power model; (4) Event-driven - Nodes respond to external requests by listening to ExtAER pulse frames, without polling overhead. The asynchronous agent runs on physical nodes, which are its hardware carriers, but in the method steps, the asynchronous agent acts as the subject of the action.

[0023] like Figure 1 As shown, an asynchronous intelligent agent orchestration method for edge IoT includes the following steps: Step 1: Obtain the computation task sent by the application layer and assign it a task identifier. The computation task includes task priority, directed acyclic graph of the task, d-dimensional feature vector, and computational complexity. After multi-channel pulse coding, a pulse sequence containing task pulse events produced by multiple channels is obtained. Each task pulse event in the pulse sequence, together with the frame integrity check code, is serialized into an extended address-event representation frame, forming an extended address-event representation frame sequence. The specific source of the computation task depends on the application scenario, such as UAV target detection task, medical physiological signal anomaly detection task, and industrial equipment predictive maintenance task. The multi-channel system includes rate coding channels, time coding channels, population coding channels, and burst coding channels. The specific method for multi-channel pulse coding is as follows: The rate-coded channel maps task priorities to pulse frequencies ranging from 10Hz to 1000Hz using the logarithmic mapping formula f = f_min × (f_max / f_min)^ratio, where ratio represents the normalized priority value, f_min represents the minimum pulse frequency, and f_max represents the maximum pulse frequency. It generates approximately f·T_w (frequency × time window) task pulse events (1 when P=1, 10 when P=10) with a frame type field of rate-coded frames. Compared to linear mapping, logarithmic mapping provides finer frequency resolution in the low-priority range. The time-encoded channel maps the partial order relationship of the task's directed acyclic graph to pulse timing through topological sorting. Each layer depth corresponds to a basic time window, and nodes in the same layer are subdivided according to micro time windows. It generates |V| (i.e., the total number of nodes in the task's directed acyclic graph) task pulse events with time-encoded frames as frame type fields, so that causal relationships are preserved in the time dimension. The swarm coding channel encodes a d-dimensional feature vector (default d=64) into a swarm activation pattern of M×d neurons (M=10) and uses phase coding to represent the sign of the feature values ​​(0 phase for positive values ​​and π phase for negative values). During the encoding process, the maximum value of the absolute value of the feature vector is saved to the pulse sequence metadata. During decoding, the original amplitude is automatically restored based on the metadata. It generates task pulse events with a frame type field of 0~M (number of neurons per group) per dimension (M=10) for swarm coding frames. A majority voting mechanism is used to enhance decoding robustness. The burst coding channel maps computational complexity to burst length using the logarithmic formula B=round(log2(C))+1, where C represents computational complexity and B represents burst length. It generates B=round(log2C)+1 task pulse events with burst coding frames as the frame type field. High-complexity tasks generate dense bursts with short pulse intervals, while low-complexity tasks generate sparse bursts with long pulse intervals. The task impulse events produced by the rate coding channel, time coding channel, population coding channel and burst coding channel are all structurally identical task impulse events. The only differences are that the frame type field of the task impulse event takes rate-coded frame, time-coded frame, population-coded frame and burst-coded frame respectively, and the distribution pattern of the task impulse event in terms of neuron address, timestamp and number are different. The task impulse event contains ten fields: neuron address, timestamp, frame type, orchestration flag, priority, task identifier, subgraph identifier, source node, destination node, and sequence number. The frame integrity check code is CRC-8 / 8 bits; the extended address-event representation frame is 128 bits, containing eleven fields: neuron address, timestamp, frame type, orchestration flag, priority, task identifier, subgraph identifier, source node identifier, target node identifier, sequence number, and frame integrity check code. Figure 2 As shown; An extended address-event representation frame sequence consists of multiple extended address-event representation frames joined end-to-end.

[0024] Step 2: Divide the task directed acyclic graph into multiple subgraphs containing subgraph labels. Each subgraph consists of a subset of nodes from the task directed acyclic graph and a subgraph label. The specific method is as follows: Step 2-1: Sort all edges of the directed acyclic graph of the task in descending order of weight, and merge the two end nodes of edges whose two-end nodes are not matched into super nodes to obtain the coarsened graph. Step 2-2: Sort the supernodes of the coarsened graph in descending order of weight, and use a greedy strategy to sequentially assign them to the partitions with the smallest load-to-capacity ratio, resulting in K partitions. K is monotonically constant as the proportion of asynchronous agents in an asynchronous agent cluster (composed of multiple asynchronous agents) that are in an active or overloaded state increases, or as the average instantaneous pulse frequency of each asynchronous agent in the cluster increases, and does not exceed the total number of nodes in the directed acyclic graph of the task. In this embodiment, the value of K is: when the cluster load < 0.3 and the average pulse frequency < 50spk / s. When the cluster load is >0.7 or the average pulse frequency is >500spk / s, In other cases, , The average pulse frequency is the arithmetic mean of the instantaneous pulse frequencies acquired by each asynchronous agent in the asynchronous agent cluster in the ready, active, or overloaded state within its respective monitoring time window (5ms in length). Instantaneous pulse frequency = total number of task pulse events counted within the monitoring time window ÷ length of the monitoring time window. The number of ready nodes represents the number of asynchronous agents in the asynchronous agent cluster that are in the ready state. The number of sleepable nodes that can be woken up represents the number of asynchronous agents in the asynchronous agent cluster that are in a light sleep or deep sleep state. The number of active nodes represents the number of asynchronous agents in the asynchronous agent cluster that are in an active state. The number of overloaded nodes represents the number of asynchronous agents in the asynchronous agent cluster that are in an overloaded state, and |V| represents the total number of nodes in the task's directed acyclic graph. Indicates rounding up; Steps 2-3: Migrate each node of the directed acyclic graph of the task to the partition where the predecessor or successor node is located, which reduces the total cost. After iterative convergence, group the nodes by partition to obtain K subgraphs. The predecessor node is a node with a directed edge pointing to the current node, and the successor node is a node with a directed edge pointing to the current node. The total cost is the weighted sum of cross-partition communication cost, node load balancing cost, and critical path extension cost after partitioning. In this embodiment, , α=1.0, β=1.0, γ=0.5; {part(u)≠part(v)} represents two edges u and v across partitions, and w(u,v) represents the edge weights of edges u and v, i.e., the task's directed acyclic graph communication. This represents the link delay between the partition containing edge u and the partition containing edge v; after partitioning, the critical path = max_vdist[v]. dist[v]=max_{u∈pred(v)}(dist[u]+w(u,v)+comm(u,v))+weight(v), when part(u)=part(v), comm=0, otherwise Pred(v) represents the set of predecessors of edge v, comm(u,v) represents the communication cost between edge u and edge v, weight(v) represents the node weight of edge v, and w represents the edge weight. The link delay is represented by the original critical path = max_vdist0[v], where dist0[v] = max_{u∈pred(v)}(dist0[u]+w(u,v))+weight(v). This not only optimizes the number of cut edges but also maintains the computational load balance of each subgraph. The fundamental difference between this and the existing METIS / hMETIS graph partitioning technology (Karypis 1998) lies in three points: (i) using pulse density to correct the routing cost weight, so that the pulse-dense subgraph is preferentially allocated to nodes with stronger computing power; (ii) simultaneously constraining the cross-partition communication cost, node load balancing cost, and critical path extension cost after partitioning; (iii) dynamically deciding the number of partitions (i.e., K) based on the cluster load and the cluster average pulse frequency at three granularities: coarse / medium / fine.

[0025] Step 3: The router of the source asynchronous agent selects the target asynchronous agent for each subgraph according to the principle of weighted minimum cost, and obtains the mapping scheme from the subgraph to the target asynchronous agent. The global asynchronous local synchronization strategy and the four-phase asynchronous handshake protocol are adopted. The source asynchronous agent routes the extended address-event representation frame sequence to the corresponding target asynchronous agent according to the mapping scheme. The specific method for the router of the source asynchronous agent to select the target asynchronous agent for each subgraph according to the principle of minimum weighted cost is as follows: Before selecting a target asynchronous agent for each subgraph, the source asynchronous agent will consider asynchronous agents that are in a ready state, or in a light sleep state and can be woken up, or in a deep sleep state and can be woken up as candidate asynchronous agents. The weighted cost of each candidate asynchronous agent is calculated based on the normalized load of each candidate asynchronous agent, the link delay between the source asynchronous agent and the candidate asynchronous agent, the energy consumption estimate of the candidate asynchronous agent in completing the subgraph, and the weighted sum of the affinity between the subgraph task type and the candidate asynchronous agent. The candidate asynchronous agent with the smallest weighted cost is selected as the target asynchronous agent of the subgraph. In this embodiment, the weighted cost is defined as cost. Where load is the normalized load of the asynchronous agent, latency is the link delay between the source asynchronous agent and the asynchronous agent, energy is the energy consumption estimate for the asynchronous agent to complete the subgraph, and affinity is the affinity between the subgraph task type and the asynchronous agent, α1=0.4, β1=0.3, γ1=0.2, δ1=0.1; in this embodiment, load is obtained by weighting the normalized instantaneous pulse frequency, normalized membrane potential level, and normalized system utilization of the target asynchronous agent by 0.4, 0.3, and 0.3 respectively; latency is calculated based on the Euclidean distance between the three-dimensional spatial positions of the source asynchronous agent and the target asynchronous agent. The distance is estimated by multiplying by a unit delay factor of 0.01ms; energy is obtained by multiplying the steady-state power consumption of the target asynchronous agent in its current power state by the subgraph task weight; affinity is obtained by subtracting the normalized system utilization of the target asynchronous agent from 1; the initial value of the subgraph task weight is determined by the sum of the weights of all nodes in the subgraph and modulated according to the pulse density: when the pulse density is greater than a preset threshold, the subgraph task weight is amplified according to the monotonically increasing function of the pulse density, so that the pulse-dense subgraph is preferentially allocated to the asynchronous agent with stronger computing power or lower load; the pulse density is the ratio of the total number of task pulse events in the pulse sequence to the total number of nodes in the directed acyclic graph of the task; The global asynchronous and local synchronous strategies specifically include: Global Asynchronous: The global clock is not shared among the asynchronous agents. The extended address-event representation frame sequence across asynchronous agents is exchanged through a four-phase asynchronous handshake protocol. The delay of each phase of the four-phase asynchronous handshake protocol is sampled by the network simulator and accumulated to the local clock of the corresponding asynchronous agent. Local synchronization: Each asynchronous intelligent body maintains its own local clock and vector clock. The spiking neural network inference in the asynchronous intelligent body proceeds in the order of local time steps. The subgraph assigned to the asynchronous intelligent body proceeds in the asynchronous intelligent body in the state flow of ready state, running state and completed state. like Figure 3As shown, the four-phase asynchronous handshake protocol specifically includes: In the first phase, the source asynchronous agent sends a request signal carrying the target address and frame metadata; in the second phase, the target asynchronous agent returns an acknowledgment signal upon receiving the request, indicating readiness to receive; in the third phase, the source asynchronous agent sends data upon receiving the acknowledgment, i.e., the complete extended address-event representation frame; in the fourth phase, the target asynchronous agent returns a completion signal after successfully receiving the data, ending one handshake. The session local simulation time is incremented phase by phase (i.e., the handshake delay is sampled from the network simulator at ns-3 / 4), with no global clock throughout; if the target is not ready between the first and second phases, a negative acknowledgment is returned, and the handshake fails, falling back to the no-handshake route. The four-phase asynchronous handshake protocol eliminates the dependence on a global clock, allowing each node to operate in an independent clock domain, making it naturally suitable for scenarios where different nodes in heterogeneous edge networks have inconsistent clock frequencies.

[0026] Step 4: Each target asynchronous agent executes the assigned subgraph in parallel to obtain the corresponding subgraph calculation result; the subgraph calculation result is encoded element by element into a result pulse event with frame type result frame through the result encoder; the subgraph identifier is written into the subgraph identifier field of the corresponding result pulse event, and then serialized into a result frame, forming a result frame sequence and sent back to the source asynchronous agent; The specific method for each target asynchronous agent to execute the assigned subgraph in parallel is as follows: if the target asynchronous agent is in a light sleep state or a deep sleep state, the source asynchronous agent generates a wake-up sequence to trigger the target asynchronous agent to enter the ready state. After receiving the extended address-event representation frame sequence, each target asynchronous agent enters the active state and then executes the assigned subgraph in parallel. The resulting pulse event contains ten fields: neuron address, timestamp, frame type, orchestration flag, priority, task identifier, subgraph identifier, source node, destination node, and sequence number.

[0027] Step 5: The source asynchronous agent uses a vector clock to maintain the causal order of the computation results of each subgraph in the returned result frame sequence. It then collects and merges the subgraph computation results according to the causal order to obtain the task output vector. Specifically, this involves: creating a vector clock for each asynchronous agent during registration; before each subgraph is completed and ready to submit its computation results, the corresponding asynchronous agent's vector clock increments and returns a deep copy snapshot, which is then written to the source asynchronous agent as a clock field along with the subgraph computation results; after receiving the subgraph computation results of all subgraphs, the source asynchronous agent sorts all the subgraph computation results according to the causal order determined by the vector clock, where concurrent subgraph computation results are sorted lexicographically by timestamp and asynchronous agent identifier; and then, based on the sorted subgraph computation results, sequentially extracting the computation result arrays of each subgraph and concatenating them to obtain the task output vector.

[0028] Step 6: When the task output vector needs to be uploaded to the cloud, or when the external system needs to interact with the protocol stack, implement the bidirectional conversion between the extended address-event representation frame sequence and the application layer protocol, and output the orchestration result. The orchestration result includes the task identifier assigned in Step 1, the K subgraphs obtained in Step 2, the mapping scheme obtained in Step 3, the task output vector obtained in Step 5, and the event stream, computational delay decomposition data, and network delay decomposition data generated during the execution of Steps 1 to 5. Among them, the event stream is the event sequence published by the event bus and filtered according to the task identifier in Steps 1 to 5, the computational delay decomposition data is the maximum value of the time required for each target asynchronous agent to execute the subgraph in parallel in Step 4, and the network delay decomposition data is the sum of the network delay from the source asynchronous agent to the target asynchronous agent in Step 3 and the network delay from the target asynchronous agent to the source asynchronous agent in Step 4. The application layer protocols include traditional TCP, MQTT, or CoAP protocols. When the edge asynchronous agent needs to communicate with the cloud or a traditional TCP / IP network, it encapsulates a 128-bit extended address-event representation frame sequence into a TCP or MQTT (Message Queuing Telemetry Transmission) message payload. Conversely, it parses and encapsulates the received traditional protocol messages into an extended address-event representation frame sequence and injects it into the protocol stack, enabling the neuromorphic protocol stack of this invention to seamlessly connect to existing IoT infrastructure.

[0029] For example, EventBus publishes EventType events (an enumeration of 23 event types) in steps 1-5: TASK_SUBMITTED (task submitted) → TASK_ENCODED (task encoded) → TASK_PARTITIONED (task partitioned) → TASK_ROUTED (task routed) → WAKE_REQUESTED (wake-up request) → NODE_READY (node ​​ready) → SUBGRAPH_READY (subgraph ready) → SUBGRAPH_DISPATCHED (subgraph dispatched) → SUBGRAPH_FINISHED (subgraph completed) → TASK_COMPLETED (task completed). In case of exceptions, SUBGRAPH_TIMEOUT (timeout) / TASK_FAILED (failure) are inserted. The event log is obtained by filtering by task_id (task identifier).

[0030] In this embodiment, between steps 4 and 5, the following further applies: when a subgraph is not executed by the original target asynchronous agent and fails to return a complete result frame sequence to the source asynchronous agent within a preset time limit, the execution of the subgraph is determined to have failed, and a three-level retry mechanism is triggered to ensure the eventual consistency of the task: the first-level retry involves the original target asynchronous agent re-executing the subgraph; if the first level fails, the second-level retry calls the router of the source asynchronous agent to select a new target asynchronous agent for the subgraph and reroutes to the new target asynchronous agent for execution; if the second level still fails, the third-level retry calls the wake-up sequence to wake up a supplementary asynchronous agent in a shallow or deep sleep state to take over the subgraph, or performs overall degradation processing on the computation task.

[0031] In this embodiment, the system further includes state transitions for each asynchronous agent during operation, driven by a five-level power state machine based on the instantaneous pulse frequency generated by the agent's impulse activity: when the instantaneous pulse frequency exceeds a preset threshold, the asynchronous agent transitions from a ready state to an active state; when the instantaneous pulse frequency is below the threshold and lasts for more than 2 seconds, the asynchronous agent reverts from the active state to the ready state; when the asynchronous agent experiences 10 seconds of no impulse activity, it descends to a light sleep state; when the asynchronous agent experiences another 60 seconds of no impulse activity, it descends to a deep sleep state. The wake-up path is reverse-triggered: upon receiving a pulse event or task allocation signal, the asynchronous agent gradually wakes up from the sleep state. The activity decay adopts the Loihi2 fixed-point leak integral distribution model to ensure consistency with neuromorphic hardware, such as... Figure 4 As shown; The five-level power state machine, from low to high, includes ultra-deep sleep state (only the wake-up circuit is active), deep sleep state (the register state is maintained), shallow sleep state (can be quickly woken up), ready state (the peripheral is powered on but not performing calculations), and active state (executes SNN inference calculations at full speed), achieving dynamic power consumption range management from 0.001mW to 300mW.

[0032] like Figure 5 As shown, an edge IoT asynchronous intelligent agent orchestration system includes a pulse coding layer, a computation graph segmentation layer, a routing layer, a parallel execution layer, a result aggregation layer, and a protocol bridging layer; The pulse coding layer is used to obtain computational tasks containing a directed acyclic graph of tasks. After multi-channel pulse coding, a pulse sequence containing task pulse events produced by multiple channels is obtained. Each task pulse event in the pulse sequence, together with the frame integrity check code, is serialized into an extended address-event representation frame, forming an extended address-event representation frame sequence. The computation graph segmentation layer is used to segment the task's directed acyclic graph into multiple subgraphs containing subgraph identifiers; The routing layer is set up in the source asynchronous agent containing the router. The router selects the target asynchronous agent for each subgraph according to the principle of minimum weighted cost, and obtains the mapping scheme from the subgraph to the target asynchronous agent. The routing layer uses its router to route the extended address-event representation frame sequence to the corresponding target asynchronous agent using a global asynchronous local synchronization strategy and a four-phase asynchronous handshake protocol. The parallel execution layer is set in each target asynchronous agent. The parallel execution layer is used to execute the assigned subgraph in parallel and obtain the corresponding subgraph calculation results. The parallel execution layer contains a result encoder, which is used to encode the subgraph calculation results element by element into result pulse events, write the subgraph identifier into the corresponding result pulse events, and then serialize it into a result frame sequence and send it back to the source asynchronous agent. The result aggregation layer is set in the source asynchronous agent to maintain the causal order of the computation results of each subgraph using the vector clock, and to collect and merge the computation results of the subgraph according to the causal order to obtain the task output vector; The protocol bridging layer is used to implement bidirectional conversion between extended address-event representation frame sequences and application layer protocols when task output vectors need to be uploaded to the cloud or when external systems need to interact with the protocol stack, and output orchestration results.

[0033] To verify the effectiveness of this invention, experimental tests were conducted in three typical edge IoT scenarios. Each scenario was repeated using five different random seeds (42, 123, 456, 789, 1024), and the mean ± standard deviation is reported. A three-layer LIF (Leaky Integrate-and-Fire) network was used for spiking neural network inference, and network communication simulation was based on the ns-3 platform.

[0034] like Figure 6 As shown, Scenario 1 is a collaborative detection scenario involving a drone swarm (i.e., 6 asynchronous agents). This scenario simulates a collaborative monitoring swarm of 6 drones performing 100 target detection tasks. The spiking neural network adopts a three-layer LIF architecture of 64→128→64→2. Experimental results show that the detection F1 score is 0.893±0.025, the computation latency is 6.46±0.51ms, the task completion rate is 100%, the swarm power consumption is 661.6mW, and the battery life is 111.9 hours.

[0035] like Figure 7As shown, Scenario 2 is a medical sensor network (i.e., 8 asynchronous agents). This scenario simulates 8 wearable physiological signal sensor nodes performing continuous monitoring for 720 hours (30 days). The spiking neural network adopts a three-layer LIF architecture of 32→64→32→2, combined with a BLE (Bluetooth Low Energy) 5.0 duty cycle power consumption model. Experimental results show: anomaly detection sensitivity of 100%±0%, average power consumption per node of 0.825±0.032mW, battery life of 30.4±1.2 days (600mAh / 3.7V lithium battery), and emergency response latency of 173.3ms.

[0036] like Figure 8 As shown, Scenario 3 is predictive maintenance for the Industrial Internet of Things (IIoT) (i.e., 50 asynchronous agents). This scenario simulates 50 industrial sensor nodes (45 leaf nodes + 5 gateway nodes) continuously monitoring equipment status for 365 days. The spiking neural network adopts a three-layer LIF architecture of 32→64→32→2. Experimental results show: fault detection accuracy of 100%±0%, false alarm rate of 0%, system availability of 100%, average acquisition cycle latency of 9.88±0.13ms, leaf node battery life of 691 days, and annual maintenance cost savings of $480,000±40,000.

[0037] In summary, the method proposed in this invention can work effectively in edge scenarios of different scales (6~50 asynchronous intelligent agents) and different application fields (military / medical / industrial), while maintaining ultra-low power consumption (i.e., node-level power consumption as low as 0.2mW) and high reliability (i.e., all detection indicators reach more than 90%).

Claims

1. A method for orchestrating asynchronous intelligent agents in edge IoT, characterized in that... Includes the following steps: Step 1: Obtain the computing task sent by the application layer and assign a task identifier to it. The computing task includes task priority, task directed acyclic graph, d-dimensional feature vector and computing complexity. After multi-channel pulse coding, a pulse sequence containing task pulse events produced by multiple channels is obtained. Each task pulse event in the pulse sequence, together with the frame integrity check code, is serialized into an extended address-event representation frame to form an extended address-event representation frame sequence. The multi-channel architecture includes a rate coding channel, a time coding channel, a population coding channel, and a burst coding channel, which respectively map task priority, the partial order relationship of the directed acyclic graph of tasks, the d-dimensional feature vector, and the computational complexity into task impulse events with different frame type identifiers. The task impulse event includes at least an orchestration information field for identifying the task, subgraph, source node, and target node. The extended address-event representation frame adds an orchestration information field and a frame integrity verification field to the traditional address-event representation protocol, and is composed of multiple extended address-event representation frames connected end to end to form an extended address-event representation frame sequence. Step 2: Divide the task's directed acyclic graph into multiple subgraphs containing subgraph labels; Step 3: The router of the source asynchronous agent selects the target asynchronous agent for each subgraph according to the principle of weighted minimum cost, and obtains the mapping scheme from the subgraph to the target asynchronous agent. The extended address-event representation frame sequence is routed to the corresponding target asynchronous agent by adopting the global asynchronous local synchronization strategy and the four-phase asynchronous handshake protocol. Step 4: Each target asynchronous agent executes the assigned subgraph in parallel to obtain the corresponding subgraph calculation result; the subgraph calculation result is encoded element by element into a result pulse event through the result encoder; the subgraph identifier is written into the corresponding result pulse event, and then serialized into a result frame sequence and sent back to the source asynchronous agent; Step 5: The source asynchronous agent uses a vector clock to maintain the causal order of the computation results of each subgraph, collects and merges the computation results of the subgraph according to the causal order, and obtains the task output vector. Step 6: When the task output vector needs to be uploaded to the cloud, or when an external system needs to interact with the protocol stack, implement the bidirectional conversion between the extended address-event representation frame sequence and the application layer protocol, and output the orchestration result.

2. The edge IoT asynchronous intelligent agent orchestration method according to claim 1, characterized in that... In step 2, the subgraph consists of a subset of nodes in the task's directed acyclic graph and a subgraph identifier. The specific method for step 2 is as follows: Step 2-1: Sort all edges of the directed acyclic graph of the task in descending order of weight, and merge the two end nodes of edges whose two-end nodes are not matched into super nodes to obtain the coarsened graph. Step 2-2: Sort the supernodes of the coarsened graph in descending order of weight, and use a greedy strategy to assign them to the partitions with the smallest load-to-capacity ratio, resulting in K partitions. K is monotonically increasing as the proportion of asynchronous agents in an asynchronous agent cluster composed of multiple asynchronous agents in an active or overloaded state increases, or as the average instantaneous pulse frequency of each asynchronous agent in the cluster increases, and does not exceed the total number of nodes in the directed acyclic graph of the task. Steps 2-3 involve migrating each node in the directed acyclic graph of the task to the partition containing either the predecessor or successor node that reduces the total cost. After iterative convergence, K subgraphs are obtained by grouping the nodes by partition. The predecessor node is a node with a directed edge pointing to the current node, and the successor node is a node with a directed edge pointing to the current node. The total cost is a weighted sum of the cross-partition communication cost, the node load balancing cost, and the critical path extension cost after partitioning.

3. The edge IoT asynchronous intelligent agent orchestration method according to claim 2, characterized in that... In step 3, the specific method by which the router of the source asynchronous agent selects the target asynchronous agent for each subgraph according to the principle of minimum weighted cost is as follows: Before selecting a target asynchronous agent for each subgraph, the source asynchronous agent will consider asynchronous agents that are in a ready state, or in a light sleep state and can be woken up, or in a deep sleep state and can be woken up as candidate asynchronous agents. The weighted cost of each candidate asynchronous agent is calculated based on the normalized load of each candidate asynchronous agent, the link delay between the source asynchronous agent and the candidate asynchronous agent, the energy consumption estimate of the candidate asynchronous agent in completing the subgraph, and the weighted sum of the affinity between the subgraph task type and the candidate asynchronous agent. The candidate asynchronous agent with the smallest weighted cost is selected as the target asynchronous agent of the subgraph. In the global asynchronous local synchronization strategy, the asynchronous agents do not share a global clock and exchange extended address-event representation frame sequences through a four-phase asynchronous handshake protocol. Each asynchronous agent maintains a local clock and a vector clock and advances the spiking neural network inference according to the local time step sequence. The four-phase asynchronous handshake protocol includes four phases: request, confirmation, data transmission, and completion confirmation.

4. The edge IoT asynchronous intelligent agent orchestration method according to claim 3, characterized in that... In step 4, the specific method for each target asynchronous agent to execute the assigned subgraph in parallel is as follows: if the target asynchronous agent is in a light sleep state or a deep sleep state, the source asynchronous agent generates a wake-up sequence to trigger the target asynchronous agent to enter the ready state. After receiving the extended address-event representation frame sequence, each target asynchronous agent enters the active state and then executes the assigned subgraph in parallel. The resulting pulse event includes ten fields: neuron address, timestamp, frame type, orchestration flag, priority, task identifier, subgraph identifier, source node, destination node, and sequence number.

5. The edge IoT asynchronous intelligent agent orchestration method according to claim 4, characterized in that... Between steps 4 and 5, the following further applies: If a subgraph is not executed by the original target asynchronous agent and fails to return a complete result frame sequence to the source asynchronous agent within a preset time limit, the execution of the subgraph is determined to have failed, and a three-level retry mechanism is triggered to ensure the eventual consistency of the task: The first-level retry involves the original target asynchronous agent re-executing the subgraph; if the first level fails, the second-level retry calls the router of the source asynchronous agent to select a new target asynchronous agent for the subgraph and reroutes to the new target asynchronous agent for execution; if the second level still fails, the third-level retry calls the wake-up sequence to wake up a supplementary asynchronous agent in a shallow or deep sleep state to take over the subgraph, or performs overall degradation processing on the computation task.

6. The edge IoT asynchronous intelligent agent orchestration method according to claim 4, characterized in that... Step 5 specifically includes: creating a vector clock for each asynchronous agent during registration; before each subgraph is completed and ready to submit its computation results, the vector clock of the corresponding asynchronous agent increments and returns a deep copy snapshot, which is then written as a clock field along with the subgraph computation results to the source asynchronous agent; after receiving the subgraph computation results from all subgraphs, the source asynchronous agent sorts all the subgraph computation results according to the causal order determined by the vector clock, where concurrent subgraph computation results are sorted lexicographically by timestamp and asynchronous agent identifier; based on the sorted subgraph computation results, the computation result arrays of each subgraph are sequentially extracted and concatenated to obtain the task output vector.

7. The edge IoT asynchronous intelligent agent orchestration method according to claim 6, characterized in that... In step 6, the orchestration result includes the task identifiers assigned in step 1, the K subgraphs obtained in step 2, the mapping scheme obtained in step 3, the task output vectors obtained in step 5, and the event streams, computational latency decomposition data, and network latency decomposition data generated during the execution of steps 1 to 5. The event stream is the sequence of events published by the event bus and filtered by the task identifier in steps 1 to 5. The computational latency decomposition data is the maximum value of the time required for each target asynchronous agent to execute the subgraph in parallel in step 4. The network latency decomposition data is the sum of the network latency from the source asynchronous agent to the target asynchronous agent in step 3 and the network latency from the target asynchronous agent to the source asynchronous agent in step 4.

8. The edge IoT asynchronous intelligent agent orchestration method according to claim 1, characterized in that... It also includes state transitions for each asynchronous agent during operation, driven by a five-level power state machine based on the instantaneous pulse frequency generated by the agent's pulse activity: when the instantaneous pulse frequency exceeds a preset threshold, the asynchronous agent transitions from the ready state to the active state; when the instantaneous pulse frequency is below the threshold and lasts for more than 2 seconds, the asynchronous agent reverts from the active state to the ready state; when the asynchronous agent has no pulse activity for 10 seconds, it descends to a light sleep state; when the asynchronous agent has no pulse activity for another 60 seconds, it descends to a deep sleep state; the wake-up path is reverse triggering: when a pulse event or task allocation signal is received, the asynchronous agent wakes up from the sleep state step by step; the activity decay adopts the Loihi2 fixed-point leak integral distribution model. The five-level power state machine, from low to high, includes ultra-deep sleep state, deep sleep state, light sleep state, ready state, and active state.

9. An edge IoT asynchronous intelligent agent orchestration system, characterized in that, The system employs the edge IoT asynchronous intelligent agent orchestration method described in claim 1, comprising a pulse coding layer, a computation graph segmentation layer, a routing layer, a parallel execution layer, a result aggregation layer, and a protocol bridging layer; The pulse coding layer is used to obtain computational tasks containing directed acyclic graphs of tasks, and after multi-channel pulse coding, it generates extended address-event representation frame sequences. The computation graph segmentation layer is used to segment the task directed acyclic graph into multiple subgraphs containing subgraph identifiers; The routing layer is set in the source asynchronous agent and is used to select the target asynchronous agent for each subgraph according to the principle of minimum weighted cost. It also uses a global asynchronous local synchronization strategy and a four-phase asynchronous handshake protocol to route the extended address-event representation frame sequence to the corresponding target asynchronous agent. The parallel execution layer is set in each target asynchronous agent to execute the assigned subgraph in parallel, obtain the corresponding subgraph calculation results, and encode the subgraph calculation results into a result pulse event sequence and send it back to the source asynchronous agent; The result aggregation layer is set in the source asynchronous agent and is used to maintain the causal order relationship of the calculation results of each subgraph using a vector clock, and merge them to obtain the task output vector; The protocol bridging layer is used to implement bidirectional conversion between extended address-event representation frame sequences and application layer protocols, and output orchestration results.

Images