Neuromorphic Edge Computing Framework for Real-Time Swarm Robotics with Adaptive Collective Intelligence

1. Introduction

The quick growth of autonomous robotic systems in Industry 4.0 applications has generated an enormous demand for computerized systems capable of real-time multi-object detection and tracking, ultra-low energy consumption, and scalability over heterogeneous robotic swarms. Traditional approaches that rely on the cloud have fundamental limitations when it comes to applications that require low-latency. On the other hand, conventional artificial neural networks (ANNs) experience energy efficiency constraints due to the presence of resource-limited edge environments. The combination of challenges has generated strong interest in neuromorphic computing architectures that can replicate the brain's remarkable efficiency at processing time-dependent and spatial data [1–6]. This work addresses the core AI/ML challenge of multi-object detection and tracking for swarm autonomy, where each robot must simultaneously detect, track, and coordinate around multiple dynamic objects in real-time.

New progresses have been made by combining with multi-agent reinforcement learning (MARL) [31–34] and distributed optimization that demonstrated the potential of swarm control, but their continuous communication or centralization learning phase are less practical in practice. Neuromorphic computing, which is motivated by biological neural circuits, achieves unique energy efficiency based on the event-driven computation [35–37]. However, to the best of our knowledge, current neuromorphic approaches mainly deal with single-agent vision and perception oriented applications with no comprehensive framework for multi-agent detection and tracking collaboration. The combination of neuromorphic SNNs and swarm intelligence is an interesting, albeit unexplored, approach to the development of autonomous multi-agent systems.

State-of-the-art edge-computing robotics designs make heavy use of conventional ANNs, which, as we have seen, require 5–10× the power of the neuromorphic counterpart [38–40]. Moreover, the centralized swarm robotics frameworks, like the ones in [41–43] are based on polling communication protocols that add high latency overhead especially when the size of the swarm increases. The intersection of the limitations forms a critical void in the existing literature: there is no framework in place on how to coalesce neuromorphic processing efficiency with scalable coordination in a swarm system.

According to [1], through SNNs (spiking neural networks), neuromorphic computing is a paradigmatic shift towards brain-inspired computation. It aims to help with the computational bottlenecks of contemporary robotic systems. As per Maass, SNNs are the Third Generation of Neural Networks. SNNs were proven to be more computationally expressive than perceptrons and sigmoidal neural networks. Recent large-scale surveys on neuromorphic algorithms and their hardware implementations have revealed substantial advances in training methodologies and deployment strategies [3]. The development of neuromorphic processors on robotics platforms for autonomous behavior has become an important research area known as embodied neuromorphic intelligence [4]. Additionally, the research on the biological plausibility of neuromorphic systems has provided critical insights on how the brain can inspire the design of robotic systems that are more efficient and adaptive [5].

Simultaneously, swarm robotics is becoming a major force for the coordination of multi-agents and is based on the collective behavior of nature. In-depth surveys of swarm intelligence have classified diverse models and applications displaying the versatility of bio-inspired algorithms for solving complex optimization and coordination issues [6]. In recent years, collective decision-making mechanisms have improved the autonomy and adaptability of robotic swarms, particularly in scenarios that require distributed consensus without centralized control [7]. Swarm robotics has made a considerable journey from a mere idea to an implementation. Consequently, swarm robotics research is gaining momentum with more and more applications being tested in the world. Further, the application fields include search and rescue, environmental monitoring, and industrial automation [8]. Importantly, much recent work on decentralized UAV swarms has shown that fully decentralized swarms can achieve similar behaviors without communication, indicating the potential for truly autonomous swarms [9].

Merging neuromorphic computing with edge-based architectures offers a variety of energy-efficient robotic application processing techniques. Event-driven graph neural network accelerators (EGNNAs) achieved remarkable performance in edge vision tasks due to significant savings in compute and latency [10]. According to a study, spike-based language model development has increased applicability of neuromorphic techniques to complex sequential processing tasks. The skills of advanced spiking neural network architectures with improved recurrence dynamics for temporal pattern characterization and sequential learning have improved [12]. Temporal pruning methods targeting SNNs having ultra-low latency have been successful in achieving decent accuracy with low processing delays. In addition, improvements and innovations in training methodologies of energy-efficient single-step SNNs have tackled fundamental neuromorphic learning algorithms issues [14].

Robotic vision applications seem to be especially well-suited to event-based processing paradigms, which leverage the temporal sparseness of visual information to act more efficiently. Event-Based Optical Flow (EBOF) estimation has seen improved performance using adaptive spiking networks with learnable neuronal dynamics. Such systems greatly outperform traditional optical flow methods while offering significant reductions in energy consumption. The sensor fusion applications of hybrid spiking-analog architectures have led to excellent outcomes, such as efficient optical flow estimation [16]. Spiking architecture-based object recognition methods with event-driven nature have shown efficiency in isolated temporal events and tracking [17]. Recent research on hybrid ANN-SNN architectures has successfully been able to combine the best of both worlds for visual perception with low power and low latency [18]. Advanced hybrid architectures have shown that there are synergistic benefits to using spiking and artificial neural networks for event-based processing [19]. Neuromorphic Planners that take into account Physics have been found to be physically efficient in robot navigation tasks, combining event-based processing with path planning algorithms [20]. Datasets developed for testing responsive behavioral characteristics of flying robots have been instrumental in benchmarking neuromorphic vision applications [21], whereas temporally-binned object flow estimation has led to high-speed energy-efficient detection and tracking [22].

Mechanisms of coordination that are bio-inspired have been very successful as far as swarm robotics applications are concerned. Models of spike-based neural networks that can self-organize while colliding with each other are reward-modulated neural networks comprising many neurons. Multi-agent reinforcement learning methods have demonstrated robustness in agricultural applications, especially for UAV coverage optimization of fields [24]. Recent examinations of swarm engineering technology for spacecraft applications assert that distributed coordination is a critical component of advanced space exploration missions.

The development of neuromorphic hardware has made significant strides with specialized architectures for spike-based computation. According to the study [26], in-memory computing and routing solutions for small-world neuromorphic networks offer notable benefits in energy consumption and processing speed. Processors based on spiking recurrent neural networks that work irrespective of the nature of the task have been shown to enable on-chip, extended time-scale learning and, thus, show learning behaviours in real time [27]. Ultra-low-power hybrid neural network processors demonstrate impressive energy efficiency measures capable of supporting few-shot class-incremental learning [28]. The methods of meta-learning for spiking neural networks have advanced the search methodologies for quick adaptation to new tasks [29]. Comprehensive benchmarking frameworks now provide guidelines for evaluating algorithms and systems of neuromorphic computing [30].

Nevertheless, there exist substantial gaps in the ongoing research, despite all these developments. First, present approaches to neuromorphic largely deal with single agents and lack a formal framework to deal with swarm robots for multi-agent co-ordination. Next, even if they demonstrate potential in a vision task, event-based processing is often poorly integrated with the organized distributed decision-making needed for autonomous swarm operation. In addition, current edge computing solutions that rely on centralized coordination violate the basic principles of swarm autonomy. Fourth, the protocols used for communication in swarm systems are largely polling-based, which incurs latency and energy overhead. Ultimately, there are no mechanisms available that enable learning from prior experiences and changing behaviors in real-time depending on the environment and mission.

This study tackles these crucial deficits by creating a unique neuromorphic edge computing framework for real-time swarm robots with adaptive collective intelligence. We fundamentally rethink swarm coordination using neuromorphic processing at the robot level and thus do not require cloud infrastructure. The present paper introduces a new event-driven communication protocol which has low latency and is robust to variations. The framework includes a new adaptive collective intelligence algorithm that supports dynamic topology reconfiguration and task reallocation based on real-time environmental evaluation. Additionally, we develop a decentralized learning mechanism through which each of them continuously optimizes their own behavior based on local sensory information and knowledge sharing with nearby agents.

The primary contributions of this work are threefold. To begin with, we introduce the very first comprehensive neuromorphic edge computing framework specifically designed for swarm robotics applications which integrates spiking neural networks with distributed coordination mechanisms. Also, a new event-driven communication protocol is introduced to achieve considerable latency reduction with system robustness and fault tolerance. The third use is an adaptive collective intelligence algorithm that fosters dynamic and emergent coordination while eliminating centralized control. In various important aspects like energy efficiency, task completion time and scalability, we experimentally establish the performance capabilities of the proposed approach in improving significantly.

The remainder of this paper is organized as follows. The detailed methodology of the neuromorphic edge computing framework, including system architecture, communication protocols, and learning algorithms, is presented in Section 2. A description of the experimental setup and performance evaluation metrics are given in Section 3. Section 4 presents comprehensive experimental results demonstrating the strengths of our approach across different scenarios. The implications of this study and various applications are discussed in Section 5. In conclusion, the paper ends in Section 6 with future directions.

2. Methodology

The introduced neuromorphic edge computing system uses a mathematically rigorous distributed architecture that integrates spiking neural networks with event-driven coordination mechanisms. This section provides complete theoretical background, algorithms and system design specifications.

2.1 Neuromorphic Processing Architecture

The framework incorporates a hierarchical spiking neural network architecture that contains a multi-layer neuromorphic processor in each robot agent. The central processing unit employs Leaky Integrate-and-Fire neurons with adaptable thresholds, mathematically expressed as follows.

This is the equation used for the receipt with the input current, where \(V_i(t)\) is the membrane potential of neuron \(i\), \(\tau_m = 20\,\text{ms}\) is the membrane time constant, \(V_{rest} = -70\,\text{mV}\) is the resting potential, \(R_m = 10\,\text{M}\Omega\) is the membrane resistance and \(I_i(t)\) is the input current. A spike is said to be generated when \(V_i(t) \ge \theta_i(t)\); the thresholds are adaptive.

With \(\theta_{base} = -55\,\text{mV}\), \(\Delta\theta = 5\,\text{mV}\), and \(\tau_\theta = 30\,\text{ms}\). The adaptive process prevents over-firing while remaining sensitive to specific input patterns. The network topology consists of three hierarchical layers: a sensory processing layer with 256 neurons for feature extraction, an intermediate layer with 128 neurons for temporal pattern recognition, and a decision layer with 64 neurons for action selection. The modifications to synaptic weight follow STDP rules.

where \(\Delta t = t_{post} - t_{pre}\), \(A_+ = 0.01\), \(A_- = 0.005\), \(\tau_+ = 20\,\text{ms}\), and \(\tau_- = 25\,\text{ms}\) [15,29]. As exhibited in the essential architecture of neuromorphic edge computing, the three-tier distributed system has individual processing nodes for each robot on ground, local swarm coordination clusters, and global swarm management layers. The architecture shows how neuromorphic processing units inserted at each tier are designed for autonomous decision-making without reliance on the cloud.

The neuromorphic framework employs a hybrid sensing approach combining standard RGB cameras with event-driven processing simulation. Visual frames from robot cameras (640×480 at 30 FPS) are converted to spike trains using temporal difference encoding:

where \(S_i(t)\) is the spike output for pixel \(i\), \(I_i(t)\) is the intensity value, \(\Delta t = 33.3\,\text{ms}\) (frame interval), and \(\theta_{pixel} = 15\) (adaptive threshold). Positive intensity changes generate ON spikes, negative changes generate OFF spikes.

The overall processing of the spikes takes place in four stages as shown below. Initial stages involved pre-processing of frame with Gaussian blur (σ = 1.0) and contrast normalisation. The motion was then detected using temporal differencing. Then the spiking events were generated (rate coding where each pixel maximum 100 Hz). Finally a spatial pooling (8×8 to one neuron) was performed which generated an 80×60 spikes. The first layer consists of 4800 paired ON/OFF channel 80×60 spatial cell (one channel per pixel) neurons. The second layer consists of 256 LIF neurons with 20 ms time constants. The third layer comprises 128 neurons with 50 ms integration windows. The decision layer consists of 64 neurons which decide the action. Throughout all experiments performed, we measure our entire processing pipeline as having a latency of 35.2 ms ± 3.1 ms.

2.2 Event-Driven Communication Protocol

The communication protocol works on an event-triggered asynchronous way, which lowers the network load while ensuring reliable information. Each communication event \(E_i\) is defined as a 6-tuple.

The symbol \(t_i\) identifies the timestamp, \(s_i\) indicates the source agent identifier, \(p_i\), which has a range from 0 to 1, indicates the priority level, \(d_i\) is the data payload, \(\tau_i\) is the time-to-live parameter, and \(\phi_i\) is the routing path vector. The threshold at which an event takes place is changed automatically depending on how engaged things are at the area where the event takes place and how congested the network is internationally.

where \(L(t)\) represents local activity level, \(C(t)\) represents network congestion, \(\alpha = 0.3\), and \(\beta = 0.5\). Local activity is quantified as:

According to [10],[22], where \(S_j(\tau)\) = the spike train from neuron \(j\) and \(\tau_L = 100\,\text{ms}\) is the integration window. The flowchart of the event-driven communication protocol is elaborate in nature. The communication protocols determine whether the processes of sensory input will take place. The decision module checks whether the event exceeds the threshold and applies priority spreading if needed. Further choice assessment takes place to check for priority spreading. The protocol also defines the acknowledgement mechanism and routing decisions. The protocol has time complexity \(O(\log n + h)\) where \(n\) is the swarm size and \(h\) is the number of hops. It typically achieves latencies between 2–8 ms.

The distributed consensus algorithm guarantees a coherent global picture through local information fusion. The consensus protocol works according to Algorithm 1, which is followed by the weight calculation for the neighbour state information.

and the state update mechanism combines local and global estimates using:

where \(\lambda = 0.1\) is the temporal decay factor and \(\alpha = 0.7\) is the local state persistence coefficient [9,26].

Algorithm 1: Asynchronous Gossip-Based Consensus Protocol
Input:  Local state Si, neighbor set Ni, consensus threshold δ, timeout T_max
Output: Updated global state estimate Gi

 1: INITIALIZE consensus_round ← 0, timeout_counter ← 0
 2: WHILE |Gi - Gi-1| > δ AND timeout_counter < T_max DO
 3:   // Asynchronous gossip phase
 4:   FOR each neighbor j ∈ Ni (non-blocking) DO
 5:     TRY:
 6:       SEND_ASYNC state_vector(Si, timestamp, confidence, ttl=3)
 7:       message_j ← RECEIVE_ASYNC(timeout=50ms)
 8:       IF message_j.received THEN
 9:         buffer.add(message_j)
10:       END IF
11:     CATCH timeout_exception:
12:       neighbor_failures[j] ← neighbor_failures[j] + 1
13:       IF neighbor_failures[j] > 3 THEN
14:         Ni.remove(j)   // Remove unreliable neighbor
15:       END IF
16:     END TRY
17:   END FOR
18:
19:   // State update with available information
20:   weight_sum ← 0, weighted_state ← 0
21:   FOR each message Sj in buffer DO
22:     age_factor  ← exp(-λ(current_time - Sj.timestamp))
23:     reliability ← 1.0 - neighbor_failures[j]/10.0
24:     wj ← age_factor × reliability × Sj.confidence
25:     weighted_state ← weighted_state + wj × Sj.state
26:     weight_sum ← weight_sum + wj
27:   END FOR
28:
29:   IF weight_sum > 0 THEN
30:     Gi ← weighted_state / weight_sum
31:     Si ← α × Si + (1-α) × Gi
32:   END IF
33:
34:   consensus_round ← consensus_round + 1
35:   timeout_counter ← timeout_counter + 1
36:   SLEEP(random(10ms, 50ms))   // Prevent synchronization
37: END WHILE
38:
39: // Convergence guarantee: If no progress after T_max iterations,
40: // use local state with degraded confidence
41: IF timeout_counter ≥ T_max THEN
42:   confidence ← confidence × 0.5
43: END IF
44: RETURN Gi, confidence

2.3 Adaptive Collective Intelligence Algorithm

The collaboration intelligence process uses reactions and reflexes that can respond over a short time and be able to respond strategically over a long time. The framework executes an algorithmic function at three different scales. The reactive scale (1–10 ms) is responsible for preventing collision and evasive maneuvers, while the tactical scale (100–1000 ms) is responsible for local coordination and formation. Further global mission planning and resource allocation is done by the strategic scale (1–10 s). The decision fusion mechanism integrates results from various time scales through an expression for dynamic weight assignment.

where \(a_k(t)\) represents the action from scale \(k\) and weights are computed using a softmax function:

with utility functions \(u_k(t)\) that measure the relevance of each temporal scale on the basis of current environmental conditions with \(\beta = 2.0\) [23]. The structure integrates multi-scale temporal processing with layers of spiking neural networks. Moreover, the dynamic weight fusion mechanisms and cooperation learning synchronize different features. Furthermore, there also exists the distributed learning features which is made with STDP learning and knowledge sharing.

The algorithm for task allocation balances load distribution, energy consumption, and mission criticality by optimizing them jointly. The allocation problem is modelled as follows as a constrained allocation.

subject to the constraints:

The notation \(x_{ij} \in \{0,1\}\) denotes the allocation of task \(i\) to agent \(j\). \(c_{ij}\) is the cost of the allocation. The average load is \(\bar{L}\). \(E_j\) is the energy state of agent \(j\), while \(\lambda_1 = 0.3\), \(\lambda_2 = 0.5\) are weighting parameters [6,25]. The distributed implementation system uses Algorithm 2, where the mechanism contains a design that maximizes utility as well as load balance.

Algorithm 2: Distributed Task Allocation
Input:  Task set T, agent capabilities C, energy states E
Output: Optimal assignment matrix X

 1: INITIALIZE assignment matrix X ← 0
 2: COMPUTE local utility for each task-agent pair
 3: FOR each task i ∈ T DO
 4:   candidates ← sort_agents_by_utility(i)
 5:   FOR each agent j ∈ candidates DO
 6:     IF capacity_available(j) AND energy_sufficient(j) THEN
 7:       bid_j ← compute_bid(i, j, C_j, E_j)
 8:       BROADCAST bid(i, j, bid_j)
 9:     END IF
10:   END FOR
11:
12:   WAIT FOR all_bids_received()
13:   winner ← argmax_j(bid_j - λ₃ × load_penalty_j)
14:   X[i][winner] ← 1
15:   UPDATE capacity(winner) ← capacity(winner) - 1
16: END FOR
17: RETURN X

where \(\lambda_3 = 0.4\) is the load balancing penalty coefficient.

2.4 Distributed Learning and Adaptation

Through local experience, we implement a Distributed Learning Mechanism. To each agent we associate a local experience buffer \(B_i\) which contains state-action-reward tuples \((s_t, a_t, r_t)\). The agents update their policy online using a modified form of temporal difference learning.

with learning rate \(\alpha = 0.01\) and discount factor \(\gamma = 0.95\). The knowledge transfer protocol exchanges behavioral policies through compressed spike pattern representations, where the transferred knowledge \(K_{ij}\) from agent \(j\) to agent \(i\) is weighted by communication reliability and temporal relevance:

\(R_{ij}(t)\) is the communication link reliability, \(\delta\) is the temporal decay coefficient, and \(P_j(s,a)\) is the policy distribution of agent \(j\) [11,29]. An investigation into the system complexity reveals that the consensus formation has \(O(n \log n)\) complexity, when \(n\) is swarm size, and that local neuromorphic processing which involved \(m\) active neurons has \(O(m)\) complexity. Communication overload increases according to the formula \(O(d \cdot k)\), in which \(d\) indicates the normal network degree and \(k\) indicates the normal message size.

2.5 Multi-Object Tracking Framework

The neuromorphic framework implements a distributed multi-object tracking system based on a Kalman filter and Hungarian algorithm based data association. Using a modified Kalman filter and adaptive process noise, each robot has local tracklets.

where \(x_k\) represents the state vector \([x, y, v_x, v_y]\), \(z_k\) is the detection measurement, and the Kalman gain \(K_k\) adapts based on neuromorphic confidence estimates. The data association employs the Hungarian algorithm with an IoU-based cost matrix:

Track management takes care of births, deaths and occlusions. Tracks are created when there are no matches for a track for \(\tau_{birth} = 3\) frames. Also, tracks are deleted after \(\tau_{death} = 10\) frames without a match. Occlusion handling consists of prediction of motion which helps in mitigating track discontinuity. The distributed ID management protocol will ensure that the track identities across the swarm stay consistent. In the same way, the IDs will get synchronized through consensus. Thus, it will avoid cases of duplicate assignment and achieve coherence for global tracking.

2.6 Training and Inference Configuration

The neuromorphic detection network is trained using a combination of cross-entropy and IoU losses:

where \(\lambda_{IoU} = 0.5\) balances classification and localization objectives. We applied temporal jittering of (±5 ms), spatial rotation of (±15°) and synthetic occlusion masks (10–40% coverage) to enhance robustness. The fine-tuning of the inference settings is done for real-time performance and is set to data standard: Non-Maximum Suppression (NMS) IoU threshold = 0.5, confidence threshold = 0.3, and detection frame rate = 30 FPS per robot. The event-driven processing limits computation only when spike activity exceeds the adaptive thresholds given by Equation (5). The distributed inference protocol uses consensus (Algorithm 1) across the swarm to coordinate the detection of the same object with limited computation. Every robot processes its own local sensory input, sharing information only when sufficiently confident with neighbouring agents to reduce communication.

3. Experimental Design and Evaluation Framework

The experimental evaluation framework allows us to test the performance of our measures in a range of operational scenarios and system configurations, demonstrating the efficiency of our neuromorphic edge computing development. To ensure that theoretical predictions translate to real-world implementations, we use high-fidelity simulation environments and physical robot deployments. The methodology also ensures that the experiments are scientific, reproducible, and statistically sound. The simulation framework implements a custom developed neuromorphic simulator, based on the NEST framework with extensions for robotics, with realistic timing characteristics based on modern neuromorphic hardware specifications such as those for Loihi and Intel research platforms [30].

According to the specifications cited in [27,28], the implementations of the neuromorphic hardware models involve spike generation latencies of 1–5 μs, synaptic transmission delays of 0.1–1 ms and energy consumption of 0.1–1 nJ per spike. The physics simulation is carried out using the Gazebo robotics simulator with Open Dynamics Engine (ODE) physics. The ODE physics runs at an update frequency of 1 kHz. Thus, ODE physics gives accurate dynamics representation of the device under different environmental conditions. Experiments will use a heterogeneous robotic testbed, comprising 12 modified DJI Tello EDU quadcopters for aerial operations; 8 TurtleBot3 robots equipped with Raspberry Pi 4 and custom neuromorphic acceleration boards for ground-based operations; and a set of 20 stationary environmental sensor nodes configured using BeagleBone AI platforms, which are useful in monitoring applications. The system supporting network communication is based on IEEE 802.11n wireless networking that uses software-defined radio technology and is able to provide protocol independence and realistic network characteristics such as packet loss, varying latency and interference effects typical of real-world systems.

The evaluation of performance is done through the use of a number of measures which are used to analyse the efficiency of each agent as well as the swarm on various characteristics. The energy efficiency evaluation assesses the power taken (per agent) using the formula \(P_i(t) = P_{proc}(t) + P_{comm}(t) + P_{motor}(t)\). It calculates the total system energy consumption \(E_{total} = \int E_i(t)\, dt\). The energy spent per task completion \(\eta\) is given by the formula \(E_{total} / N_{completed}\). The neuromorphic efficiency ratio \(R_{neuro} = E_{ANN} / E_{SNN}\) compares traditional artificial networks against spiking implementations. The metrics of task completion involve individual task time \(t_{task} = t_{complete} - t_{start}\). The overall mission time \(T_{mission} = \max_i(t_{task,i})\). The success rate \(S = N_{successful} / N_{attempted} \times 100\%\). And system throughput \(\Theta = N_{completed} / T_{total}\). Scalability assessment studies how the system behaves as the swarm size increases. This can be done by measuring the communication overhead \(O_{comm}(n) = \sum_i B_i(n) / B_{total}\), the efficiency of coordination \(\xi(n) = T_{optimal}(n) / T_{actual}(n)\), and the convergence time of consensus \(T_{consensus}(n) = E[t_{converge}]\). The evaluation of fault tolerance consists of injection of systematic failure scenarios. It measures the recovery times, that is \(T_{recovery} = t_{restore} - t_{failure}\). Moreover, it also measures performance degradation which is \(\Delta P = (P_{normal} - P_{degraded}) / P_{normal}\) and minimum swarm size that is \(n_{min}\), \(S(n_{min}) \ge 0.8\).

The baseline comparison framework consists of three different approaches for thorough benchmarking against state-of-the-art alternatives. The centralized cloud-based baseline employs a central server featuring a 32-core Intel Xeon processor. This implementation setup runs PyTorch neural networks with ReLU activation functions and is managed by HTTP/REST API communication having an average latency of 50 ms. Furthermore, Mixed Integer Programming is used for centralized optimization concerning coordination decisions. The edge nodes consist of NVIDIA Jetson Xavier NX running TensorRT-optimized CNNs. Furthermore, the gRPC message queuing mechanism and the usage of the Raft consensus algorithm were used for coordination [8]. The standard baseline of swarm robots uses well-known algorithms like Particle Swarm Optimization and Ant Colony Optimization. This is with a bio-inspired ZigBee mesh networking, flocking and foraging behaviors, and other algorithms in addition to standard Python implementations on ARM Cortex-A72 processors.

The purpose of the experimental scenarios is to test how well the system works in different situations that could really occur. The assembly task which demonstrates cooperation of multiple robots consists of 20–50 robots that have to build a modular structure in a well-organised indoor environment. The measuring metrics here are the assembly completion time, efficiency of coordination, and the energy consumption of the multi-robot systems. The robots will undergo a trial of 15 minutes for each configuration having 10 repetitions for each configuration setup. Assessment of capabilities for estimating environmental parameters and monitoring using mobile sensor networks is done in a scenario that involves operation over an outdoor area that has obstacles as well as uneven terrain conditions. More specifically, the assessment aims at how well these networks are able to maintain accurate data while optimizing lifetime performance during continuous operations for a period of 60 minutes. The search and rescue simulation scenario challenges the system to find and rescue the target in a complex indoor facility with dynamic obstacles and dead zones of communication, measuring the time for target discovery, the efficiency of rescue operation and fault tolerance performance in emergency scenarios of 30 minutes [9,20]. The scenario for formation control and navigation assesses the system's ability to maintain coordinated formations while navigating through a sequence of waypoints. The evaluation will take place in a mixed indoor/outdoor environment with both static and dynamic obstacles using actual onboard sensor data. The KPIs include formation maintenance error and trajectory smoothness. The evaluation will run for 20 minutes and use formation sizes of 5, 20, 50, and 200 agents.

3.1 Multi-Object Detection and Tracking Evaluation Protocol

The assessment process follows standard MOT protocols, creating data splits specific to robot IDs. The dataset is split into the following categories: Training (8 robots from drones, 5 robots from ground), Validation (2 robots from drones, 2 robots from ground), Testing (2 robots from drones, 1 robot from ground). Unseen robot IDs and view-points help validate cross-platform generalization. Primary evaluation metrics include: detection performance measured by Average Precision at IoU = 0.5 (AP@0.5) and Log-Average Miss Rate (LAMR); tracking performance evaluated using Multiple Object Tracking Accuracy (MOTA), Identification F1-score (IDF1), and Higher Order Tracking Accuracy (HOTA). Other metrics consist of ID switches (IDs) and tracking precision/recall. Stress testing is used to study the robustness under a specified condition. The tracklet-length analysis classifies performance into short (< 10 frames), medium (10–50 frames) and long (50 or more frames) trajectories. Occlusion stress tests use synthetic masks that cover 10%, 25%, and 40% of the target object to test tracking continuity. To ensure reproducibility, we ran everything with fixed random seeds (3 independent runs) and report the mean ± standard deviation. All the experiments run with the same detector thresholds: NMS IoU = 0.5, confidence threshold = 0.3 and evaluation framerate = 30 FPS.

Statistical analysis uses rigorous methods to validate and replicate results for any experimental setup. Each experimental setup is performed with \(n_{trials} = 30\) independent runs by using Latin Hypercube Sampling to effectively explore the complete parameter space with representative coverage of operating conditions. Two-way Analysis of Variance (ANOVA) with post-hoc Tukey Honestly Significant Difference (HSD) tests with α = 0.05 significance level is implemented for statistical significance testing to identify meaningful differences in performance between system configurations. Confidence intervals are constructed from B = 1000 bootstrap samples using a robust bootstrap resampling process of the means. The effect size analyses will use Cohen's d for pairwise comparisons and eta-squared (η²) for factorial effects. This is to provide information about the practical significance of the results that goes beyond just their statistical significance. Power analysis helps choose sample sizes with statistical power (β) = 0.8 that are useful and minimize Type II errors.

The experimental control procedures propose extensive randomization and standardization to remove potentially confounding factors and obtain unbiased performance assessment. The starting positions of the robots are randomized using Halton sequences to ensure their uniform distribution in space as well as to remove possible systematic positioning impacts. Environmental conditions are subjected to intensive monitoring and control for error tolerances including temperature, lighting and wireless interference. The difficulty levels, timing of tasks and resources available are varied according to well designed experimental design matrices. The failure injection scenarios adopt an exponential distribution with λ = 0.01. The data collection system runs at 100 Hz for motion data collection and 1 kHz for neuromorphic data collection. The data is stored in compressed HDF5 format. The system has the capability of having up-to-10 ms update rates through custom telemetry which allows detection of anomalous behavior in real-time, providing safety of the experiment, and ensuring output quality of the data, all throughout the various evaluations.

3.2 Reproducibility and Implementation Details

All experiments in this paper are performed with fixed random seeds (seeds: 42, 123, 456) over three independent runs with the mean ± standard deviation reported. The dataset splits are defined as follows: the training split uses drones D1–D8 and ground robots G1–G5, the validation split uses drones D9–D10 and ground robots G6–G7, and the testing split uses drones D11–D12 and ground robot G8. The software versions were kept constant for all the experiments, which include NEST v3.4 for the neuromorphic simulation, Gazebo v11.10 with ODE physics engine, PyTorch v1.12 for the baseline comparisons, and CUDA v11.6 for the GPU acceleration of the NVIDIA Jetson Xavier NX platforms. The evaluations follow protocols used in MOTChallenge, a standard. For the considered system, Raspberry Pi 4 (1.5 GHz ARM Cortex-A72, 4 GB RAM) with custom neuromorphic acceleration boards; for the baseline, NVIDIA Jetson Xavier NX (8 GB VRAM); and IEEE 802.11n wireless networking, with software-defined radio for realistic comms modelling. All results that are being reported can be re-created based on the configuration scripts, evaluation protocols and parameter settings. The characteristics of the neuromorphic processor conform to Intel Loihi specifications with a spike generation latency of 1–5 μs and a spike operation energy of 0.1–1 nJ.

4. Results

The experimental results show that the suggested framework of neuromorphic edge computing outperforms the existing one in all metrics and cases. This section offers detailed results from simulation studies and real robot deployments, showing compelling quantitative results for the framework that allows swarm robotics to be autonomously adaptive with collective intelligent behaviour. The neuromorphic edge computing system is significantly more energy efficient than standard edge computing systems in all the tests. The proposed system achieves a total energy consumption reduction of 68% compared to the centralized cloud approaches. Further, there is an improvement of 45% compared to the distributed edge computing baselines. Neuromorphic spiking neural networks are highly efficient, consuming an average power of 2.3 W per robot compared to 7.8 W for artificial neural networks. Therefore, \(R_{neuro} = 3.39\), an energy efficiency ratio. The metric \(\eta\) associated with energy per task completion is growing at the same rate from smaller formations to larger formations, despite the fact that it is becoming difficult to coordinate the swarm in bigger sizes.

The event-driven message protocol delivers a 73% reduction in latency compared with conventional polling-based devices, while preserving robust information propagation across mesh topologies.

Table 1 data clearly shows that a neuromorphic framework surpasses other methods when it comes to the combination of speed and precision. The proposed SNN-based approach achieves 87.3% AP@0.5, representing a 6.1% improvement over centralized baselines while maintaining 28.4 FPS processing speed. Research has shown the miss rates for this project to fall in the middle class of 0.12. This rate indicates a solid detection of objects in all scales and conditions. The neuromorphic approach significantly outperforms traditional swarm methods by 11.9% in AP@0.5 while achieving 2.3× faster processing speeds. Table 2 exposes the performance advantages of tracking found in the distributed neuromorphic architecture. The combination of SNN-based detection coupled with the Kalman + Hungarian tracking method outperformed other methods. It maintains long-term tracking consistency and stable identity preservation profiles. The framework processes real mixed tasks at a high volume and accuracy while occurring at 27.8 frames per second. The performance data shown in Table 3 provide evidence of the robustness under the extreme situations.

Table 4's runtime analysis confirms that all processing modules demonstrate real-time efficiency with the neuromorphic system. The robots utilize the SNN-based perception for an average processing time of 35.2 ms, allowing them to operate at 28.4 FPS. Latency of the communication protocol achieves sub-3 ms owing to the event-driven approach (73% better than polling based). The method used for updating the consensus will scale well with the size of the swarm. Thus, it will be of reasonable \(O(n \log n)\) complexity even for say at least 200 agents. A latency of 67.3 ms in actuation from end-to-end makes for well-coordinated swarms.

The energy efficiency gains primarily result from the event-driven communication protocol and sparse spiking neural network activations. A detailed energy breakdown analysis reveals that neuromorphic processing reduces computational energy by 72%, event-driven communication decreases transmission energy by 58%, and adaptive threshold mechanisms minimize idle power consumption by 41%. The STDP learning mechanism contributes to long-term efficiency improvements by optimizing neural pathways and reducing unnecessary computations over extended operation periods [14,15].

The adaptive collective intelligence algorithm has shown considerable enhancement over the experimental scenarios in task completion efficiency and coordination quality. The overall mission completion time improved by 45% over centralized baselines and by 32% over distributed edge versions. The analysis of success rates shows that all configurations achieve greater than 95% success. Even under a condition producing a 40–50% performance loss in the baselines, the proposed framework maintains a success rate that is greater than 95%.

The multi-scale temporal processing architecture enhances coordination through adaptive decision fusion, as described in Equation 9. The proposed framework achieves a coordination efficiency \(\xi(n) = 0.87 \pm 0.05\) for different swarm sizes which is considerably better than the efficiency of centralized coordination (\(\xi = 0.62 \pm 0.12\)) and traditional swarm approaches (\(\xi = 0.71 \pm 0.08\)). Algorithm 2's distributed task allocation algorithm ensures optimal load balancing as the standard deviation of assigned tasks per agent does not exceed 1.2 for all scenarios tested.

The event-driven communication protocol allows for latency drops and ensures a reliable presence of information in the swarm. The communication latency analysis shows that there is 73% less average communication delay as compared to polling based protocols, with average message transmission times of 2.8 ms ± 0.6 ms and 10.4 ms ± 2.1 ms for baseline approaches. According to Equation (5), the adaptive threshold mechanism minimizes network congestion and accepts critical information reaching all relevant agents within an acceptable time.

This has shown that in terms of consensus time, \(T_{consensus}(n) = 23.7\,\text{ms} + 1.2\,\text{ms} \cdot \log(n)\), which is feasible under 200 agents. Likewise, the quality analysis shows that 94.3% of the time convergence occurs at global optimums and the rest 5.7% cases achieve near-optimal solutions within 2.1% of the theoretical optimum. The communication failures show that the protocol can still perform if you fail the communication links. Specifically, the functionality can still happen even if you cut off 30% of the communication links.

The framework exhibits strong scalability behavior, with the complexity increasing almost linearly for swarm sizes ranging from 5 to as high as 200 agents. The total scalability analysis indicates that the computational overhead for consensus formation scales as \(O(n \log n)\) while the overhead for local neuromorphic processing scales as \(O(m)\). The measured performance closely aligns with the expected performance. Even in the largest configurations tested, the total communication overhead \(O_{comm}(n)\) remains constantly below 15% of total available bandwidth. Apparently, a lot more scaling is possible beyond the ranges tested.

The neuromorphic processing layout provides each agent with the same performance, no matter the swarm size, generating spike processing delays of 0.3 ms ± 0.1 ms and memory use which scales linearly at 2.4 MB per agent. System throughput \(\Theta\) increases proportionally with swarm size and individual agents retain efficiency. The maximum throughput of 847 tasks per minute was achievable by 200 agent configurations during collaborative assembly scenarios.

The distributed architecture has been shown to be resistant to faults and to fail gracefully. Fault tolerance analysis of the system shows that it is able to continue doing over 80% of work even with 25% of the agents not working. However, the centralized baselines work at only 45% efficiency under the same scenario. The results from recovery time analysis show that \(T_{recovery}\) for single agent failures is 3.2 s ± 0.8 s, and \(T_{recovery}\) for multiple agent failures is 7.6 s ± 1.4 s.

The adaptive learning mechanism to compensate in degrading conditions brings the norm back to near-optimal performance thanks to distributed knowledge and learning from each other's behaviour. The learning innovation analysis shows agents do adapt their coordination strategies when they operate with a lower number of swarms. Further, they converge to a new optimum behaviour in around 45 seconds. The analysis for minimum viable swarm size showed that \(n_{min} = 8\) agents are required to keep the basic functionalities working. Also, \(n_{min} = 15\) agents are required to give optimum performance in the tested scenarios.

As evidenced by the comprehensive results presented in Table 1, the proposed neuromorphic edge computing framework consistently outperforms all baseline systems. Based on normalised metrics for energy efficiency, task completion time, scalability, fault tolerance, and coordination quality, the proposed system executes better than the best baseline, which scores below 0.72 on almost all aspects. The performance scores of the different aspects for the proposed system are above 0.85.

The results of statistical significance testing conducted through two-way ANOVA show that there are significant differences in performance, with p-values being less than 0.001 for all primary metrics. Furthermore, through both the energy efficiency and coordination performance comparisons, the effect size analysis shows Cohen's d in excess of 1.2, indicating large practical significance. Confidence intervals, effect sizes, and performance distribution all show that the observed improvements are robust and repeatable over the multiple experimental trials and environmental conditions.

Across the various performed experiments, it has been validated that the neuromorphic edge computing framework can effectively close the existing research gaps while significantly enhancing performance across all computing metrics. The findings show practicality and feasibility for real-world applications in Industry 4.0 where autonomous swarm coordination is required along with energy and latency limitations.

5. Discussion

The results of the experiments provide clear proof that the proposed neuromorphic edge computing framework can solve the fundamental challenges of swarm robotics while offering substantial performance improvement in many aspects. The efficient energy and communication usage of our swarming algorithm will allow the deployment of a swarm of autonomous systems (different varieties of platforms such as UAVs, ground vehicles, and aquatic vehicles) in resource-constrained environments such as a disaster site or nuclear leak once proven in the field.

The energy efficiency improvements are due to the joint effect of sparse spiking neural network processing and event-driven communication. In contrast to standard artificial neural networks that actively process information regardless of the relevance of information to the task at hand, the neuromorphic framework only engages in inference when there are powerful temporal patterns, providing a large savings in computations. The adaptive threshold mechanism defined by Equation (2) maintains the neuron's responses to relevant signals, avoiding excessive, energy-wasting activation. This biological inspiration is shown to be effective in robotics applications in which sensory inputs typically contain substantial temporal sparsity, which allows the system to take advantage of the information's natural structure to drive computation.

The event-driven communication protocol overcomes a key limitation of existing swarm coordination techniques that unnecessarily poll others periodically regardless of information relevance. The formulation (5) ensures that network utilization and information timeliness are balanced. Hence, coordination messages are sent in a timely manner using a little bit of bandwidth. The distributed consensus algorithm exhibits an impressive scalability of \(O(n \log n)\), efficiently executing coordination of larger swarms while remaining free from centralized bottlenecks that restrict conventional algorithms.

The adaptive collective intelligence algorithm is a major advancement in multi-agent coordination through the integration of reactive, tactical, and strategic decision-making at different time scales. The dynamic weight fusion mechanism described in (9) and (10) allows for an appropriate deliberation of behavior selection, which allows agents to act immediately to situations while still being aligned with long-term mission objectives. The hierarchical methodology is useful in environments where rigid coordination strategies cannot adapt to unexpected conditions.

The framework is able to learn continuously and improve performance based on local experience and knowledge sharing among agents. The adaptation based on STDP presented in Equation (3) enables real-time adaptation of neural pathways, while the knowledge transfer protocol detailed in Equation (15) allows fast sharing of effective behavior among the swarm. This ability is critical for long-term autonomous operation since programmed actions won't be enough to deal with new environmental conditions or mission requirements.

The decentralized framework exhibits efficiency benefits with increasing swarm size. The distributed architecture avoids the communication and computational bottlenecks experienced by centralized frameworks. The near-linear growth in complexity allows for practical real-world deployment of large-scale swarms in dynamic environments. The fault tolerance characteristics indicate that the system is more resilient than necessary for many practical applications, and graceful degradation ensures mission performance under adverse conditions.

Our comparisons with state-of-the-art baseline systems confirm that the improvements that we achieved are actual improvements and not just incremental improvements. Although the centralized cloud-based baseline has computational power, it suffers communication latencies and single points of failure, making it ill-suited for latency-critical applications. The baseline model, while delivering improved response time at the edge through distributed edge computing, is not energy-efficient or adaptive enough for full autonomous operations. Conventional swarm robot methods give distributed resilience. However, they do not achieve the coordination quality and efficiency required for complex multi-agent work.

There are several implementation issues that arise from experimental validation with respect to implementation scenarios. Though specialized, neuromorphic hardware requirements can be satisfied by emerging commercial products, including Intel's Loihi processors, and brain-inspired computing platforms being developed by companies such as IBM and Google. Implementing the communication protocol involves careful adjustment of threshold parameters for optimising performance for different operational settings. However, the adaptive mechanisms are less sensitive to the choice of initial parameters. Learning algorithms initially have training periods to develop a baseline behavioral repertoire, but this repertoire can be adapted online and improved throughout the lifetime of the system.

Many other domains requiring autonomous multi-agent coordination can be a component of this framework. Dedicated robotic application assembly systems can enhance energy efficiency through coordination, while distributed sensing and fault tolerance can benefit the environmental monitoring network. Search-and-rescue functions are a particularly interesting use case, where the combination of a rapid response time, energy efficiency, and resilience to equipment failures impacts the success rate of the mission directly.

Future research will look into larger swarm sizes in order to probe ultimate scalability limits. Other possible avenues include interfacing with upcoming neuromorphic hardware platforms for even greater energy efficiency, and exploring heterogeneous swarms of aerial, ground, and aquatic platforms. The learning algorithms could be encoded with meta-learning capabilities to allow fast adaptation to new environments while the communication protocols could be designed with functionalities based on next-generation wireless technologies for machine-to-machine communication. The significance for producing autonomous systems goes beyond swarm robotics but also to other artificial intelligence applications that need distributed processing, adaptive behavior, and energy efficiency. The effectiveness of bio-inspired computing models suggests a great potential for neuromorphic solutions to be helpful in the computer science domain where traditional architectures will become inadequate for new applications.

5.1 Limitations

Our research is based on swarm-specific data collected in controlled indoor/outdoor environments using a heterogeneous testbed. Generalization to dense urban scenes and bad weather has, however, not been tested. Though the test scenarios are diverse and exhaustive, they are structured environments. As a result, they may not cover the full deployment conditions under heavy rain, fog, cold, etc. We measure how long it takes to run our code on one type of board, the Raspberry Pi 4 plus our own custom-made chips. We expect performance to vary a lot from chip to chip, from compiler to compiler and from implementation to implementation. The examination of scalability is confined to 200 agents and behavior beyond this limit needs further study. We do not use contour-refinement methods (e.g. CRFs) or sophisticated appearance models in our detection and tracking framework, which would improve accuracy in crowded scenes at more computation cost. The focus on energy efficiency rather than full accuracy may hinder performance in high-complexity settings with lots of objects. The communication protocol employs the IEEE 802.11n wireless network. However, it has not been tested with other network standards, under different bandwidth conditions, and under electromagnetically noisy conditions. Furthermore, the need for initial calibration periods of the adaptive threshold mechanisms may affect system responsiveness.

6. Conclusion

This paper offers an integrated neuromorphic edge computing framework that not only tackles serious limitations facing swarm robotics currently, but also provides significant performance enhancements in the aspects of energy efficiency, task completion time, communications latency and fault tolerance. The suggested method shows a significant change from cloud-based to brain-based coordination. This allows for truly autonomous swarm operation in low-capacity environments.

This integrated architecture for swarm robotics is neuromorphic and designed for edge computing applications. The event-driven spiking neural networks described in this paper deliver state-of-the-art performance and efficiency for coordination of multiple agents. The new method for transferring messages from event-driven devices shows a 73% reduction in latency when compared to conventional polling-based devices. It also ensures a robust degree of information propagation over mesh topologies. The adaptive collective intelligence algorithm can combine multi-scale temporal processing. Individual agents can balance immediate reactive decisions and long-term goals through the internal decision fusion mechanism.

The results of the experimental testing are quite satisfactory as they show that the proposed framework achieves a 68% enhancement of energy efficiency. Apart from this, there is also a 45% decrease of task completion time. Finally, it demonstrates a strong scalability performance for swarm sizes greater than 200 agents. The ability to learn through the distributed process which involves spike-timing-dependent plasticity and knowledge sharing from agent to agent allows for adaptability in behavior. Therefore, through extended autonomous operation, the same performance can be sustained on a permanent basis. The fault tolerance analysis shows graceful degradation which maintains above 80% operational efficacy under 25% agent failure rates, substantially higher than the conventional approaches.

By evaluating against state-of-the-art baseline systems like centralized cloud computing, distributed edge processing, and conventional swarm algorithms, significant quantitative evidence is provided for the strengths of the neuromorphic approach across all metrics. According to the statistical analysis, not only are the improvements significant, but they also lead to notable practical implications. Further, the benefits of the framework are consistent whenever the experiments are carried out.

Consequently, the proposed research will lead to a scalable distributed intelligence. Most importantly, it will have the potential to change smart manufacturing, environmental monitoring and off-site missions. Likewise, it will aid swarm robotics. The efficacy of bio-inspired computing paradigms suggests that neuromorphic approaches can exploit ample space owing to the limitations of traditional architectures in addressing the needs of emerging applications.

Future research directions will include the examination of larger swarm configurations to establish ultimate scalability boundaries, integration with next-generation neuromorphic hardware platforms for even greater energy efficiency, and extension to heterogeneous multi-platform swarms combining diverse robotic capabilities. We can further enhance the learning algorithms by using meta-learning approaches that could accelerate their adaptation to new environments, while the communication protocols could be improved by combining them with the upcoming wireless technology which will be meant for autonomous systems coordination.

This work presents a neuromorphic edge computing framework that provides a new foundation for autonomous swarm robotics by overcoming fundamental limitations of prior work while also delivering the efficiency, adaptability and resilience needed for deployment in demanding real-world applications. The new forms of artificial systems made possible by the successful integration of brain-inspired processing with distributed coordination mechanisms would allow for the combination of the best features of both biological and computational intelligence in these systems. These newly designed systems would provide performance in complex multi-agent environments that is not available using existing approaches.

This study adds to our knowledge of how biology can help improve the design of better artificial systems. It offers theoretical insights and practical solutions that will assist in developing the next generation of autonomous robotics applications. The performance gains and practical applicability demonstrated pave the way for deploying massive autonomous swarm systems in constrained conditions, while still achieving a desirable level of technical performance quality required by the key applications of Industry 4.0 and beyond.

Frequently asked questions

What is neuromorphic edge computing?

Neuromorphic edge computing runs brain-inspired spiking neural networks directly on a device rather than in the cloud. Neurons only compute when input spikes cross an adaptive threshold, so processing is event-driven and sparse. In this framework each robot carries a hierarchical spiking network with sensory (256-neuron), intermediate (128-neuron), and decision (64-neuron) layers, giving it autonomous perception without a network round-trip.

How does the event-driven communication protocol reduce latency?

Instead of polling neighbors on a fixed schedule, each robot only transmits when a locally significant event exceeds an adaptive threshold set by local activity and network congestion. Measured message transmission time was 2.8 ms versus 10.4 ms for polling-based baselines, a 73% reduction, while still propagating critical information across the mesh with time complexity O(log n + h).

How well does the swarm tolerate agent failures?

Because coordination is fully decentralized, the swarm degrades gracefully. It retained above 80% of its operational efficiency with 25% of agents failed, compared with 45% for centralized baselines. Reported recovery time was 3.2 s for single-agent failures and 7.6 s for multiple-agent failures, and the protocol kept functioning even with 30% of communication links cut.

Does the framework depend on the cloud?

No. All perception, consensus, task allocation, and learning run on the robots themselves. Each agent processes its own local sensory input and shares information with nearby agents only when confident, which is what allows the swarm to operate in isolated or communication-degraded environments such as disaster sites.

References

1. Roy, K.; Jaiswal, A.; Panda, P. Towards spike-based machine intelligence with neuromorphic computing. Nature 2019, 575, 607–617.
2. Maass, W. Networks of spiking neurons: the third generation of neural network models. Neural Netw. 1997, 10, 1659–1671.
3. Rathi, N.; Chakraborty, I.; Kosta, A.; Sengupta, A.; Ankit, A.; Panda, P.; Roy, K. Exploring neuromorphic computing based on spiking neural networks: Algorithms to hardware. ACM Comput. Surv. 2023, 55, 1–49.
4. Bartolozzi, C.; Indiveri, G.; Donati, E. Embodied neuromorphic intelligence. Nat. Commun. 2022, 13, 1024.
5. Pham, M.D.; D'Angiulli, A.; Dehnavi, M.M.; Chhabra, R. From brain models to robotic embodied cognition: How does biological plausibility inform neuromorphic systems? Brain Sci. 2023, 13, 1316.
6. Wang, C.; Zhang, S.; Ma, T.; Xiao, Y.; Chen, M.Z.; Wang, L. Swarm intelligence: A survey of model classification and applications. Chin. J. Aeronaut. 2024, in press.
7. Ibrahim, R.; Alkilabi, M.; Khayeat, A.R.H.; Tuci, E. Review of collective decision making in swarm robotics. J. Al-Qadisiyah Comput. Sci. Math. 2024, 16, 72–80.
8. Dorigo, M.; Theraulaz, G.; Trianni, V. Swarm robotics: Past, present, and future [point of view]. Proc. IEEE 2021, 109, 1152–1165.
9. Horyna, J.; Baca, T.; Walter, V.; Albani, D.; Hert, D.; Ferrante, E.; Saska, M. Decentralized swarms of unmanned aerial vehicles for search and rescue operations without explicit communication. Auton. Robot. 2023, 47, 77–93.
10. Yang, Y.; Kneip, A.; Frenkel, C. EvGNN: An event-driven graph neural network accelerator for edge vision. IEEE Trans. Circuits Syst. Artif. Intell. 2025, 2, 37–50.
11. Zhu, R.J.; Zhao, Q.; Li, G.; Eshraghian, J. SpikeGPT: Generative pre-trained language model with spiking neural networks. Trans. Mach. Learn. Res. 2024. Available online: https://openreview.net/forum?id=gcf1anBL9e.
12. Ponghiran, W.; Roy, K. Spiking neural networks with improved inherent recurrence dynamics for sequential learning. In Proceedings of the AAAI Conference on Artificial Intelligence, Virtual Event, 22 February–1 March 2022; Volume 36, pp. 8001–8008.
13. Chowdhury, S.S.; Rathi, N.; Roy, K. Towards ultra low latency spiking neural networks for vision and sequential tasks using temporal pruning. In Proceedings of the European Conference on Computer Vision, Tel Aviv, Israel, 23–27 October 2022; Springer: Berlin/Heidelberg, Germany, 2022; pp. 709–726.
14. Suetake, K.; Ikegawa, S.I.; Saiin, R.; Sawada, Y. S3NN: Time step reduction of spiking surrogate gradients for training energy efficient single-step spiking neural networks. Neural Netw. 2023, 159, 208–219.
15. Kosta, A.K.; Roy, K. Adaptive-SpikeNet: event-based optical flow estimation using spiking neural networks with learnable neuronal dynamics. In Proceedings of the 2023 IEEE International Conference on Robotics and Automation (ICRA), London, UK, 29 May–2 June 2023; IEEE: Piscataway, NJ, USA, 2023; pp. 6021–6027.
16. Lee, C.; Kosta, A.K.; Roy, K. Fusion-FlowNet: Energy-efficient optical flow estimation using sensor fusion and deep fused spiking-analog network architectures. In Proceedings of the 2022 International Conference on Robotics and Automation (ICRA), Philadelphia, PA, USA, 23–27 May 2022; IEEE: Piscataway, NJ, USA, 2022; pp. 6504–6510.
17. Nagaraj, M.; Liyanagedera, C.M.; Roy, K. DOTIE — detecting objects through temporal isolation of events using a spiking architecture. In Proceedings of the 2023 IEEE International Conference on Robotics and Automation (ICRA), London, UK, 29 May–2 June 2023; IEEE: Piscataway, NJ, USA, 2023; pp. 4858–4864.
18. Aydin, A.; Gehrig, M.; Gehrig, D.; Scaramuzza, D. A hybrid ANN-SNN architecture for low-power and low-latency visual perception. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, Seattle, WA, USA, 16–22 June 2024; pp. 5701–5711.
19. Negi, S.; Sharma, D.; Kosta, A.K.; Roy, K. Best of both worlds: Hybrid SNN-ANN architecture for event-based optical flow estimation. In Proceedings of the 2024 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), Abu Dhabi, UAE, 14–18 October 2024; IEEE: Piscataway, NJ, USA, 2024; pp. 2696–2703.
20. Sanyal, S.; Manna, R.K.; Roy, K. EV-Planner: energy-efficient robot navigation via event-based physics-guided neuromorphic planner. IEEE Robot. Autom. Lett. 2024, 9, 2080–2087.
21. Joshi, A.; Ponghiran, W.; Kosta, A.; Nagaraj, M.; Roy, K. FEDORA: A flying event dataset for reactive behavior. In Proceedings of the 2024 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), Abu Dhabi, UAE, 14–18 October 2024; IEEE: Piscataway, NJ, USA, 2024; pp. 5859–5866.
22. Kosta, A.K.; Nagaraj, M.; Chowdhury, S.S.; Ponghiran, W.; Joshi, A.; Roy, K. TOFFE — temporally-binned object flow from events for high-speed and energy-efficient object detection and tracking. arXiv 2025, arXiv:2501.12482.
23. Zhao, F.; Zeng, Y.; Han, B.; Fang, H.; Zhao, Z. Nature-inspired self-organizing collision avoidance for drone swarm based on reward-modulated spiking neural network. Patterns 2022, 3, 100528.
24. Marwah, N.; Singh, V.K.; Kashyap, G.S.; Wazir, S. An analysis of the robustness of UAV agriculture field coverage using multi-agent reinforcement learning. Int. J. Inf. Technol. 2023, 15, 2317–2327.
25. Asri, E.G.; Zhu, Z.H. An introductory review of swarm technology for spacecraft on-orbit servicing. Int. J. Mech. Syst. Dyn. 2024, 4, 3–21.
26. Dalgaty, T.; Castellani, N.; Turck, C.; Harabi, K.E.; Zurhelle, D.; Sadique, N.; Pannier, Q.; Magis, A.; Barraud, S.; Miramond, B.; et al. Mosaic: in-memory computing and routing for small-world spike-based neuromorphic systems. Nat. Commun. 2024, 15, 142.
27. Frenkel, C.; Indiveri, G. ReckOn: A 28nm sub-mm² task-agnostic spiking recurrent neural network processor enabling on-chip learning over second-long timescales. In Proceedings of the 2022 IEEE International Solid-State Circuits Conference (ISSCC), San Francisco, CA, USA, 20–26 February 2022; IEEE: Piscataway, NJ, USA, 2022; Volume 65, pp. 1–3.
28. Huo, D.; Ma, K.; Li, Y.; Chen, Y.; Wang, Z. ANP-G: A 28nm 1.04 pJ/SOP sub-mm² spiking and back-propagation hybrid neural network asynchronous olfactory processor enabling few-shot class-incremental on-chip learning.