The problem the researchers set out to solve is growing steadily worse. Climate projections point to increasingly frequent and intense extreme precipitation, while urbanization keeps sealing the ground under impervious surfaces. Many existing drainage systems were designed for a rainfall regime that no longer applies, and a significant proportion of cities are expected to face rains exceeding the capacity of their grey infrastructure by mid-century. Physically enlarging pipes everywhere is prohibitively expensive, so engineers have increasingly turned to real-time control, or RTC, which uses actuators such as gates, valves, and pumps to dynamically shift hydraulic loads. By orchestrating coordinated draw-downs of stored water before a storm peak arrives, RTC turns a passive conveyance system into an active flood-mitigation asset, at a fraction of the cost of reconstruction.

The dominant RTC approach today is rule-based control, a library of if-then heuristics derived from expert experience and offline hydraulic simulations. Rule-based systems are cheap and auditable, but they are fundamentally reactive: actions begin only after water depths cross predefined thresholds, leaving little room to proactively create storage ahead of a peak. Model predictive control offers a smarter alternative by optimizing over a finite prediction horizon, but its performance hinges on the accuracy of rainfall nowcasts, and errors in those forecasts can cause constraint violations precisely during the extreme events that matter most. Online nonlinear optimization also becomes computationally unwieldy as network size grows, which limits real-time implementation at city scale.

Deep reinforcement learning has emerged as a promising data-driven middle path. Rather than hand-crafted rules or explicit predictive models, a reinforcement learning agent learns a control policy by interacting with a high-fidelity hydraulic simulator, observing the state of the network and selecting continuous valve-opening actions. Yet the authors identify three systematic weaknesses in existing DRL controllers. First, they are topology blind: the hydraulic state is flattened into an orderless feature vector, so the agent cannot distinguish a hydraulic constriction from a storage surplus upstream, and cannot learn anticipatory upstream-downstream coordination. Second, their rewards typically penalize overflow without any explicit measure of physical consistency, which encourages high-frequency oscillatory actuation known as chattering, accelerating mechanical wear. Third, topology-agnostic policies tend to be brittle when the rainfall distribution shifts, because they lack structural inductive biases that anchor learning to the physical system.

PIG-PPO addresses all three gaps at once. At its core sits a graph convolutional network, a neural architecture designed for spatially embedded, irregularly structured data. The drainage network is represented as a directed graph whose nodes are junctions and storage basins and whose edges are the connecting conduits. Each node carries features such as water depth and hydraulic head, together with rainfall intensity broadcast as an exogenous input. Through iterative message passing along the physical edges, each node aggregates hydraulic information from its neighbors, mirroring how hydraulic waves actually propagate downstream. This relational inductive bias is exactly what a controller needs to reason about, for example, how simultaneous inflows from two parallel branches will converge on a downstream junction, a dependency a flat multi-layer perceptron cannot capture without explicit feature engineering.

The second innovation lies in the reward function. Rather than imposing the Saint-Venant equations as hard constraints, the researchers embedded the full hydraulic physics inside the EPA-SWMM simulation engine and instead shaped the learning objective with three components: a penalty on hydraulic surcharge above a 0.9-meter critical depth, a smoothness term that discourages abrupt valve changes, and a soft mass-balance residual penalty that penalizes mismatches between inflow, outflow, and the change in stored volume at each control step. A systematic grid-search sensitivity analysis confirmed the chosen weights occupy a Pareto-optimal sweet spot: removing the smoothness penalty lowered overflow marginally but multiplied control effort by roughly 4.6 times, while overweighting smoothness made the agent overly timid and unwilling to draw down storage during peaks.

The experimental design was deliberately rigorous. The agent was trained on 20 moderate design storms with intensities between 30 and 60 millimeters per hour, then evaluated on 30 held-out extreme storms peaking at 70 to 100 millimeters per hour, plus 20 long-duration monsoon-like events with different temporal structure. Crucially, the comparison was run across 10 independent random seeds, with paired statistical tests and Holm corrections. Against a topology-agnostic MLP-PPO ablation that received identical features and reward, the graph-based agent reduced the control-effort metric by 78.3 percent, with Holm-adjusted p-values below 0.001 and large effect sizes, and also achieved lower flood risk volume and lower mean system depth. In a representative extreme storm, PIG-PPO maintained mean water depth around 0.64 meters by drawing down upstream storage before the peak, while rule-based control reached about 0.69 meters and passive operation climbed steadily higher.

Perhaps the most striking results concern generalization. Under a zero-shot transfer test on the unseen monsoon-like events, mean overflow was 229,400 cubic meters; after brief few-shot adaptation using only five events and 50 fine-tuning episodes, it fell to 94,500 cubic meters, a 58.8 percent reduction. The framework was also retrained on a second, distinct PyStorms benchmark topology, where it again beat rule-based control by 23.3 percent and the MLP ablation by 13.9 percent. A parameter-count analysis underscored the structural efficiency of graph encoding: because a graph convolutional network shares weights across nodes, its encoder size stays constant as the network grows, whereas a flat MLP’s parameters scale linearly with node count. At a hypothetical 1,000-node city-scale network, that translates to a 106.69-fold parameter advantage, though the authors are careful to note this reflects parameter efficiency rather than validated performance at city scale.

The limitations are stated with unusual candor, and they matter. All experiments assumed ideal sensing, with noise-free water depth measurements and instantaneous actuator response, so the reported metrics represent an upper bound under perfect information. Real deployments face sensor drift, communication latency through SCADA systems, valve hysteresis, and mechanical rate limits, none of which were modeled. The rainfall scenarios were synthetic hyetographs rather than observed records or downscaled climate projections, so the climate-resilience claim means robustness against engineered extreme scenarios, not validated adaptation to specific local climate futures. No model predictive control benchmark was implemented, which the authors flag as a primary limitation when interpreting their performance gains.

Even with those caveats, the study marks a meaningful shift in how machine learning might be applied to urban water infrastructure. By encoding topology in the state representation and physical consistency in the reward signal, PIG-PPO demonstrates that the intelligence of a flood controller can be grounded in the actual anatomy of the pipes it manages. The authors argue their gains are most pronounced near hydraulic capacity limits, precisely where conventional approaches begin to fail and where the value of anticipatory control is greatest. Future work, they write, should tackle noisy sensing, actuator dynamics, larger real-world digital twins, and explicit benchmarking against model predictive control. For cities bracing for a wetter, more volatile century, teaching stormwater networks to know their own shape may prove to be one of the cheapest resilience upgrades available.

Subject of Research: Topology-aware, constraint-guided deep reinforcement learning for climate-resilient real-time control of urban stormwater drainage systems

Article Title: Topology-aware and constraint-guided deep reinforcement learning for climate-resilient control of urban stormwater systems

Article References: Jing, K., Baljon, M., & Tejani, G. G. (2026). Topology-aware and constraint-guided deep reinforcement learning for climate-resilient control of urban stormwater systems. Frontiers in Environmental Science, 14, Article 1963502. https://doi.org/10.3389/fenvs.2026.1963502

Image Credits: AI Generated

DOI: 10.3389/fenvs.2026.1963502

Keywords: deep reinforcement learning, graph neural networks, stormwater control, urban flooding, real-time control, climate resilience, constraint-guided learning, proximal policy optimization, EPA-SWMM, hydraulic modeling, urban drainage, flood mitigation

Developed by Scott Shen, Noah Rubin, and Thomas C. Bulea at the National Institutes of Health Clinical Center and described in the journal SoftwareX, BRACE is a pure-Python software framework for real-time robotic control in clinical research settings. It is released under the GNU GPL-3.0 license, available through the Python Package Index and GitHub, and built entirely from widely used Python libraries including NumPy, PySide6, PyQtGraph, pandas, and h5py. The design goal is deceptively simple: let researchers focus on the science-specific control logic of their device while the framework handles everything else, from streaming data over Wi-Fi to enforcing safety limits on actuator commands.

The architecture rests on a hierarchical control strategy that is already the standard structure in rehabilitation robotics. Control flow is segmented into three layers. The supervisory layer manages high-level goals such as recognizing a user’s intent or determining which phase of a cyclic task like walking the patient is in. The action layer transforms state information into actuator commands that accomplish specific objectives, such as imposing a desired torque profile on a knee joint. The execution layer carries out those commands while maintaining precision and safety. In BRACE, these layers are implemented through a set of abstract base classes and interfaces, including RobotAssemblyABC, RobotABC, IInputCom, IOutputCom, IMeasurementLists, IControlLogic, and ISafetyCheck, which researchers subclass to describe their particular hardware and controllers.

This compartmentalization follows the well-known Strategy design pattern from software engineering, and its practical payoff is modularity. A standardized hardware configuration can share a common set of inputs, outputs, and safety mechanisms while accommodating interchangeable control logic modules that execute distinct behaviors. Custom remote procedure call functions can be defined and invoked at runtime, dynamically modifying attributes across any subsystem without interrupting execution. In other words, an experimenter can change how a robot behaves mid-experiment without stopping the program, recompiling code, or reflashing a device, a capability that matters enormously when trial time with patients or animal subjects is scarce.

The framework’s client-server design links a laptop graphical interface to an embedded controller, typically a Raspberry Pi 4B, through an MQTT message broker using the Mosquitto implementation. The GUI, built with PySide6, abstracts remote procedure calls into intuitive controls for parameter configuration and command execution. A key feature is supervised soft real-time control law switching: the experimenter can transition interactively between control modes within a single experimental session. Safety is built into the switching procedure, which disables actuator torque before the change, swaps in the new controller, and then re-enables torque. During streaming, the interface deliberately locks down most configuration options to prevent unintended changes mid-trial.

Data handling is equally considered. Streaming data travels over Wi-Fi through the AnimatedGraphManager class, which subscribes to MQTT topics, classifies incoming messages using registered picklable NamedTuple datatypes as a portable schema, and buffers them in memory for live soft real-time visualization. Saved datasets are written to client-side storage in the Apache Parquet format, with NamedTuple field names serving as column headers so that controller-specific data subclasses can coexist within one unified streaming session. Controller transitions are encoded with NaN values that register as time-series discontinuities, and all remote procedure calls made during a session are captured, enabling post-hoc analysis of event ordering and deterministic replay.

Perhaps the most clinically motivated feature is the integrated offline simulator. Because clinical participants often cannot complete a high volume of trials, iterative tuning under time pressure is a chronic bottleneck. The simulator replays previously collected data as a simulated stream, allowing researchers to apply updated controller parameters and evaluate alternative configurations without the participant present. In the team’s exoskeleton example, the simulator achieved a replay accuracy of 98.1 percent, with the residual error traced to the unknown initial state of a finite-state-machine walking controller, a problem the authors address by recommending a nominal streaming blanking period before online actions begin.

Two independent clinical use cases demonstrate the framework’s range. The first is a lower-limb exoskeleton designed to treat crouch gait, the excessive knee flexion seen in children with cerebral palsy and other neuromotor disorders. The system runs on a Raspberry Pi 4B with a two-channel CAN bus expansion board, interfaced with bilaterally mounted Agilik knee actuators on a knee-ankle-foot orthosis, powered by a 36-volt battery stepped down to 5 volts. In testing, the control loop achieved 199.97 hertz against a 200 hertz target with only 0.66 percent jitter per 5-millisecond cycle and mean CPU usage of 43 percent per core, and controller switching took just 1.88 milliseconds, below the threshold of human perception. Streaming reliability was verified for at least six minutes, the duration required for standard 6-Minute Walk tests, and the software supported soft real-time switching between a gait-phase finite state machine and a proportional knee-angle-to-torque controller for squatting.

The second example is strikingly different: a closed-loop mechanoreceptive device for basic science. Mechanosensation, the ability to sense mechanical force, underlies touch perception and proprioception through molecular channels such as PIEZO2. Traditional rodent studies rely on Von Frey monofilaments, which buckle at defined forces but suffer from discrete force scaling and the variability of manual stimulus application. The BRACE-based device pairs a Zaber linear actuator with a load cell, an Arduino for signal digitization, and a Raspberry Pi running the framework’s control loop, enabling programmable, closed-loop delivery of mechanical stimuli across a continuous force range. The result is faster, more precise, and less variable measurement of stimulus thresholds and tissue stiffness, with less unnecessary exposure for animal subjects. That two such disparate systems, a wearable pediatric exoskeleton and a benchtop neurobiology instrument, could share the same software foundation illustrates the framework’s central claim of modularity.

The authors are candid about limitations. Hard real-time performance depends on hardware, and the framework has so far been validated only on the Raspberry Pi 4B with a CAN HAT across two sensor and actuator configurations. Meaningful customization requires proficiency in Python and object-oriented programming, deployment requires installing an MQTT broker, and the pickle-based serialization used for data collection poses a security risk that the team says makes the software suitable only for controlled research environments with trusted parties, with JSON or Protobuf suggested as safer future alternatives. Unlike commercial microcontroller firmware, it lacks encryption and verification schemes against unauthorized installation, limiting commercial applicability. Still, by lowering the technological barrier for novice programmers, supporting rapid prototyping of novel controllers, and potentially reducing participant fatigue through offline tuning, BRACE fills a genuine complexity gap. For a field where software infrastructure too often dictates the pace of clinical translation, an accessible, portable, and extensible foundation may prove to be the accelerant clinical robotics has been waiting for.

Subject of Research: An open-source Python software framework for real-time control of robotic devices in clinical research

Article Title: Biomedical robotics architecture for clinical experimentation (BRACE): A software framework for clinical robotics research

Article References: Shen, S., Rubin, N., & Bulea, T. C. (2026). Biomedical robotics architecture for clinical experimentation (BRACE): A software framework for clinical robotics research. SoftwareX, 36, Article 103096. https://doi.org/10.1016/j.softx.2026.103096

Image Credits: AI Generated

DOI: 10.1016/j.softx.2026.103096

Keywords: BRACE, clinical robotics, open-source software, Python, exoskeleton, rehabilitation robotics, hierarchical control, MQTT, Raspberry Pi, cerebral palsy, mechanosensation, real-time control

The core insight behind the work is that most existing fusion strategies are little more than a one-way handoff. A global planner produces a route, passes it to a local controller, and the two never speak again. The weights that govern how the local controller balances goal-seeking against obstacle avoidance are typically fixed at calibration time, which means a robot tuned for open corridors will oscillate at the mouth of a narrow doorway, and one tuned for tight spaces will waste energy making needless detours across empty floors. Cui’s framework closes that loop. A dynamic sub-goal tracking mechanism continuously feeds the geometric constraints of the global path into the local speed controller, while the local controller’s progress in turn influences how fast the robot advances along the global reference.

At the global layer, the traditional A* algorithm receives its most significant upgrade in the form of an obstacle potential field factor woven into the heuristic function. Classic A* relies on Euclidean or Manhattan distance to guide its search, which is efficient but geometrically blind: it happily hugs the edges of obstacles because those routes are nominally shortest. The improved heuristic multiplies the distance term by a factor of one plus a potential field penalty that grows as the inverse square of the distance to the nearest obstacle, but only within a preset safety threshold. The result is that the cost of a node rises sharply as it approaches an obstacle, pushing the planned path into open space. The author is candid about the theoretical trade-off: because the potential field term can inflate the heuristic value near obstacles, the modified A* no longer guarantees the globally shortest path, though completeness is preserved, meaning the algorithm will always find a collision-free route if one exists.

The raw output of any grid-based search is a jagged polyline of grid centers, riddled with collinear redundant nodes and tiny turns that would force a real robot into constant acceleration and deceleration. The framework addresses this in two stages. First, a bidirectional line-of-sight strategy, implemented with Bresenham collision checking, strips the path down to only its essential turning points. Second, those key points serve as control vertices for a cubic B-spline curve, which produces a trajectory with continuous second derivatives, known as C2 continuity. Unlike Bézier curves, B-splines have local support, so adjusting one control point only reshapes the curve locally. Because the spline approximates within the convex hull of its control polygon rather than passing exactly through the control points, the smoothed curve can occasionally bulge toward an obstacle. A posterior safety verification step samples the smoothed trajectory every 0.1 meters and, if any point comes within the robot’s 0.4-meter radius of an obstacle, contracts the local control points inward and regenerates the curve, falling back to the original polyline after five failed iterations. This rollback eliminated all collision risks in testing while retaining roughly 95 percent of the smoothing benefit.

The local layer is where the framework departs most clearly from convention. The dynamic window approach samples velocity pairs within the intersection of the robot’s hardware limits, its acceleration-constrained reachable speeds, and a safety region guaranteeing braking distance exceeds the distance to the nearest obstacle. Traditionally, candidate trajectories are scored by a fixed weighted sum of heading, clearance, and speed terms. Cui replaces those static coefficients with a two-input, two-output fuzzy inference system built on Gaussian membership functions. Obstacle distance and current velocity are fuzzified against a three-by-three rule base following a monotonic safety principle: the closer the obstacle and the higher the speed, the greater the avoidance weight. Centroid defuzzification then yields crisp weights each control cycle. In one documented scenario, as an obstacle closed from 5.0 meters to the 0.6-meter high-risk threshold, the avoidance weight surged from 0.2 to 0.95, allowing the robot to suppress its target-seeking instinct and pass through a narrow U-shaped passage where a fixed-weight controller oscillated helplessly.

The ablation experiments quantify each module’s contribution with unusual granularity. Adding the potential field factor increased path length by about 3.4 percent, the price of safety, but cut expanded search nodes by 30.3 percent. B-spline smoothing then reduced cumulative turning cost from 15.7 radians to 4.2 radians, a 73.2 percent reduction, while suppressing peak curvature from values as high as 10.0 per meter to below 0.45 per meter. The dynamic sub-goal mechanism, tested across 50 Monte Carlo trials, cut navigation time by 13.4 percent, reduced lateral tracking error by 65.4 percent, and lowered emergency stops by 75 percent compared with aiming directly at the final destination.

Head-to-head comparisons in a 100-by-100 grid scenario filled with irregular static obstacles and randomly moving dynamic disturbances pitted the framework against traditional A* plus fixed-weight DWA, artificial potential field fused with DWA, and RRT* fused with DWA, all tuned through grid searches over more than 200 parameter combinations each. The proposed method achieved a 96.0 percent obstacle avoidance success rate, 14 percentage points above the traditional baseline, and an average navigation time of 36.2 seconds, a 34.4 percent reduction. Path smoothness cost fell from 24.5 to 8.4. Statistical testing backed the margins: Cohen’s d reached 2.37 against the traditional method, and one-way ANOVA across navigation time, path length, and smoothness yielded F statistics between 18.7 and 35.2 with p below 0.001. Notably, the framework also outperformed reinforcement learning planners including TD3, SAC, and a hybrid SAC plus RRT configuration, beating the best of them by roughly 21 percent in navigation time without any of the 2-million-step training those methods require.

Real-time performance is a quiet triumph of the design. Local planning averages 11.6 milliseconds per step on an Intel i7-10750H, comfortably within the 20-millisecond budget for 50 Hz control, with memory demands under 10 megabytes, making deployment feasible on ARM-class embedded boards such as a Raspberry Pi 4 or Jetson Nano without GPU acceleration. Global replanning triggers only when obstacle displacement exceeds grid resolution, an average of 0.7 times per 100 control cycles, and costs about 162 milliseconds when it does. Every decision is traceable through an explicit fuzzy rule library, no pre-training or labeled data is needed, and the system can be dropped into a new environment directly, a combination of interpretability and deployability that black-box learners struggle to match.

Robustness testing under more realistic conditions used ROS Melodic and Gazebo 9.0 with simulated lidar noise, odometry drift, and tire slip. Success rate dipped from 96.0 to 90.0 percent and navigation time rose to 41.8 seconds, a decline the author characterizes as within acceptable engineering limits. A sensitivity analysis across four uncertainty sources showed positioning error most affected navigation time, lidar noise most affected success rate, and high measurement delay pushed success down to 80 percent, suggesting that filtering or prediction modules would be needed in high-noise settings.

The author is forthright about limitations. The framework is built for two-dimensional grid maps and differential-drive kinematics; extending it to Ackermann steering, omnidirectional platforms, aerial robots, or three-dimensional terrain would require recalibrated speed spaces and trajectory models. The fuzzy rules were handcrafted for a 0.4-meter-radius robot with a 1.5-meter-per-second top speed and may need retuning at other scales, and performance against fully adversarial moving obstacles remains untested. Future work targets physical prototype experiments, three-dimensional navigation with elevation data, and distributed multi-robot coordination. Even so, the study’s real contribution may be methodological: it demonstrates that the leap from loosely connected modules to deeply coupled integration, in which geometry, control, and perception feed one another in a closed loop, is what finally turns decades-old algorithms into a navigation system ready for the messy, unpredictable world outside the laboratory.

Subject of Research: Hierarchical mobile robot path planning integrating an improved A* algorithm with a fuzzy-adaptive dynamic window approach

Article Title: Robot movement path planning integrating A* algorithm and dynamic window

Article References: Cui, X. (2026). Robot movement path planning integrating A* algorithm and dynamic window. Discover Artificial Intelligence, 6(1), Article 1320. https://doi.org/10.1007/s44163-026-02379-6

Image Credits: AI Generated

DOI: 10.1007/s44163-026-02379-6

Keywords: mobile robots, path planning, A* algorithm, dynamic window approach, fuzzy logic, B-spline, obstacle avoidance, autonomous navigation, trajectory smoothing, robotics, path smoothing, real-time control