💻 computer science

Dynamic neural manifolds for flexible closed-loop control on neuromorphic hardware

This paper presents a real-time, closed-loop control system implemented on the SpiNNaker 2 neuromorphic hardware that utilizes dynamic neural manifolds to enable flexible, explainable robotic navigation by modulating circuit parameters to rapidly switch behaviors and fine-tune trajectories based on sensory feedback.

Original authors: Oskar von Seeler, Christian Tetzlaff, Andrew Lehr

Published 2026-07-09

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Oskar von Seeler, Christian Tetzlaff, Andrew Lehr

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine your brain isn't a static computer chip, but more like a busy, flowing river. In this river, groups of neurons don't just fire randomly; they move together in organized, rhythmic waves. Scientists call these organized waves "neural manifolds." Think of a manifold as a specific "dance path" that the neurons follow.

This paper is about teaching a special kind of computer chip (called SpiNNaker 2, which is designed to mimic the brain's efficiency) to control these dance paths in real-time. Here's how they did it, explained simply:

1. The "Ring" Dance Floor

The researchers built a digital model of a ring of neurons. Imagine a circular track with 500 runners (neurons).

The Bump: Instead of everyone running at once, a "bump" of activity (a group of active runners) moves around the ring.
The Sequence: As this bump travels, it creates a sequence of events. This is like a musical beat that keeps ticking over and over.
The Goal: They wanted to control how this bump moves: how fast it goes, how wide the group of runners is, and which part of the ring they are running on.

2. The "Control Knobs"

The team discovered they could use three simple "knobs" to change the dance without breaking the rhythm. They implemented these on the chip:

Speed Knob (Gain): Turn this up, and the bump of activity races around the ring faster. Turn it down, and it slows to a crawl.
Shape Knob (Current): Turn this, and the "bump" gets wider or narrower. It's like changing the size of the group of runners holding hands.
Direction Knob (Inhibition): This is the cleverest part. The researchers can "silence" (turn off) specific random groups of runners. When they do this, the bump has to shift to a different part of the ring to keep moving. This effectively rotates the dance path into a completely new direction.

3. The Robot in the Maze

To prove this works, they put this "ring network" in charge of a virtual two-wheeled robot trying to navigate a maze.

The Plan: An external computer (the "brain" of the operation) tells the robot the big picture: "Go forward until you hit a wall, then turn right."
The Execution: The ring network takes that instruction and translates it into the "knobs."
- To go straight, it sets the speed and shape knobs for a specific "forward" dance path.
- To turn, it rotates the dance path (using the inhibition knob) to a new angle.
- To jump over a hurdle, it switches to a completely different dance path.
The Feedback: If the robot gets too close to a wall, sensors tell the system to adjust the knobs instantly. The robot doesn't stop and re-calculate; it just smoothly shifts its "dance" to avoid the crash.

4. Why This Matters (According to the Paper)

The paper claims this is a breakthrough for two main reasons:

Explainability: Unlike many "black box" AI systems where we don't know why they make a decision, this system is transparent. We know exactly which "knob" was turned to make the robot turn left or speed up. The math behind the movement is clear.
Efficiency: They ran this on SpiNNaker 2, a chip built to be super energy-efficient (like a brain). They showed that you can do complex, real-time control on this hardware without it getting bogged down or needing massive amounts of power.

The Bottom Line

The researchers successfully built a system where a computer chip controls a robot by mimicking how biological brains organize movement. Instead of writing complex code for every turn and jump, they created a flexible "neural dance" that can be instantly reshaped by simple controls to navigate a maze, jump hurdles, and react to the environment in real-time.

Note: The paper focuses strictly on this robotic simulation and the hardware implementation. It does not claim this technology is currently being used in human medical treatments or that it can solve complex real-world problems outside of this specific maze-navigation test.

Technical Summary: Dynamic Neural Manifolds for Flexible Closed-Loop Control on Neuromorphic Hardware

Problem Statement
Biological neural circuits exhibit flexible behavior by evolving sequential activity along dynamic, low-dimensional manifolds. While spiking network models have linked these sequential activities to specific circuit mechanisms (making them parameterizable), translating this framework into energy-efficient, real-time, closed-loop control on neuromorphic hardware remains a challenge. Existing approaches often lack the ability to dynamically reconfigure neural geometry in response to sensory feedback, which is essential for explainable artificial intelligence and adaptive autonomous systems. The authors aim to bridge this gap by implementing a dynamic neural manifold framework on the SpiNNaker 2 neuromorphic chip to enable real-time, closed-loop control of a robotic agent.

Methodology
The authors implemented a circuit architecture based on a ring network with asymmetric recurrent connectivity, designed to generate stable "bumps" of neural activity that progress along the ring, creating oscillatory sequences.

Hardware Implementation (SpiNNaker 2):
- Spiking Conversion: The original rate-based model was adapted for SpiNNaker 2's spike-based communication. Neurons convert internal rates to spikes probabilistically (rate as spike probability). To optimize performance, a deterministic rule approximates spike frequency without expensive random number generation.
- Sparsity and Memory Optimization: To address limited on-chip SRAM, the authors introduced sparsity into the connectivity matrix (50% connection probability). They leveraged the circulant structure of the weight matrix, storing only a single row of weights and a bitmask for connectivity, rather than the full matrix.
- Closed-Loop Streaming: Due to memory constraints preventing long-term internal recording, the system streams spikes to a host computer via the HostIF interface. The host processes sensory feedback and streams control parameters back to the chip in real-time, creating a closed loop with low latency (approx. 3 time steps).
Control Mechanisms ("Control Knobs"):
The architecture utilizes three specific circuit mechanisms to manipulate the neural manifold:
- Additive Current ( $I$ ): Modulates the size (width) of the activity bump, controlling the radius of the neural trajectory.
- Multiplicative Gain ( $S$ ): Modulates the speed of bump propagation, controlling the velocity of the neural trajectory.
- Heterogeneous Inhibition ( $p_{inh}$ ): Selectively silences random subsets of neurons via inhibitory ensembles. This rotates the neural subspace, allowing the system to switch between distinct behavioral states (e.g., different movement types).
Application (Virtual Maze Navigation):
A two-wheeled robotic agent navigates a virtual maze. An external policy program generates a high-level plan (e.g., "move west") and local adaptations based on sensory inputs (distance to walls, ground type). These inputs are mapped to the ring network's control parameters ( $S, I, p$ ). A linear readout layer, trained via random exploration of the control parameter space, decodes the ring network's spike activity into motor commands (wheel speeds and jump triggers).

Key Results

Parameter Fidelity: The SpiNNaker 2 implementation successfully reproduced the dynamics of the original rate-based CPU model.
- Shape Control: Additive current $I$ linearly controlled bump size and trajectory radius.
- Speed Control: Multiplicative gain $S$ reliably controlled the rotation speed of the activity bump.
- Subspace Rotation: Selective inhibition successfully rotated the neural subspace. The principal angle between subspaces matched the analytical scaling behavior ( $\arccos(1 - p_{inh})$ ), confirming that distinct behavioral states are geometrically separable.
Efficiency: The implementation operated well within the 1 ms real-time time step threshold. Runtime scaled linearly with the number of processed spikes. Larger bumps (controlled by $I$ ) increased runtime, while higher inhibition (silencing more neurons) reduced it.
Closed-Loop Performance: The robotic agent successfully navigated a maze, dynamically switching between behaviors (forward movement, turning, jumping) and adjusting speed/trajectory based on real-time sensory feedback. The system demonstrated that sensory inputs could modulate inhibition, gain, and currents to reconfigure manifold geometry on the fly.

Significance and Claims
The paper claims to establish dynamic neural manifolds as a feasible approach for explainable neuromorphic architectures. By mapping low-level circuit mechanisms (gain, inhibition, currents) to high-level geometric features (trajectory speed, shape, subspace orientation), the authors provide a framework where the internal state of the system is mathematically interpretable.

The work serves as a proof-of-principle that:

Complex, dynamic neural manifolds can be implemented efficiently on neuromorphic hardware (SpiNNaker 2).
Such systems can support flexible, closed-loop control where sensory feedback directly shapes neural dynamics to drive behavior.
This framework offers a substrate for investigating biological neural dynamics and designing autonomous systems with predictable, explainable behaviors, potentially extending to more complex motor control tasks in the future.

The authors note that while the current work assumes a pre-learned world model for planning, the framework is designed to interface with higher-level learning architectures, and future work may explore learning world models directly on top of this motor control layer.