Virtual Force-Based Routing of Modular Agents on a Graph

Modular vehicles present a novel area of academic and industrial interest in the field of multi-agent systems. Modularity allows vehicles to connect and disconnect with each other mid-transit which provides a balance between efficiency and flexibility when solving complex and large scale tasks in urban or aerial transportation. This paper details a generalized scheme to route multiple modular agents on a graph to a predetermined set of target nodes. The objective is to visit all target nodes while incurring minimum resource expenditure. Agents that are joined together will incur the equivalent cost of a single agent, which is motivated by the logistical benefits of traffic reduction and increased fuel efficiency. To solve this problem, we introduce a novel algorithm that seeks to balance the optimality of the path that every single module takes and the cost benefit of joining modules. Our approach models the agents and targets as point charges, where the modules take the path of highest attractive force from its target node and neighboring agents. We validate our approach by simulating multiple modular agents along real-world transportation routes in the road network of Champaign-Urbana, Illinois, USA. The proposed method easily exceeds the available benchmarks and illustrates the benefits of modularity in multi-target planning problems.

💡 Research Summary

This paper addresses the problem of routing a fleet of modular agents—vehicles or robots that can join and split during a mission—through a weighted directed graph so that a predefined set of target nodes is visited with minimal total traversal cost. When agents are joined, they behave as a single entity and incur only the cost of one agent for traversing edges, capturing the fuel‑efficiency and traffic‑reduction benefits observed in platooning trucks, modular public‑transport vehicles, and drone swarms.

The authors formulate the problem formally (Problem 1) and note that it is a special case of the traveling salesman problem, thus NP‑hard for an arbitrary number of agents. Consequently, they propose a heuristic algorithm inspired by electrostatic forces. Each agent and each target is modeled as a positive point charge. Attractive forces follow an inverse‑square law, where the “distance” is the sum of edge weights along the shortest feasible paths on the graph.

The algorithm proceeds in discrete time steps and consists of five main components:

1. Target Assignment – Using Dijkstra’s algorithm each agent is assigned the nearest unvisited target (nearest‑neighbor heuristic). This step is computationally cheap but does not consider conflicts among agents.

2. k‑Shortest Path Sampling – For each agent‑target pair and for each agent‑agent pair, the algorithm computes the k shortest loopless paths (Yen’s algorithm). The set of first edges of these paths constitutes the candidate moves for the agent. The parameter k is kept small (typically 3–5) to limit computational load while still providing diverse directional options.

3. Force Computation – For every candidate edge ˆe, the algorithm evaluates the attractive force contributed by each path that begins with ˆe. The force for a path l between nodes i and j is (F_{att}^{i,j,l}= \alpha_j / d_{i,j,l}^2), where (d_{i,j,l}) is the total weight of that path. αj is a scaling constant for agent‑agent attraction; β (αi) is used for agent‑target attraction, allowing the designer to bias the system toward more collective or more independent behavior. The total force on edge ˆe for agent i is the sum of the maximal forces from each counterpart (Equation 3). The agent then selects the adjacent edge with the highest total force.

4. Move or Wait Logic – To avoid deadlock situations where two agents would move into each other’s current positions, a simple waiting rule is applied: if two agents intend to swap positions, the one with the shorter remaining distance to its assigned target proceeds while the other waits one timestep. If distances are equal, the waiting agent is chosen randomly.

5. Simultaneous Execution – All agents execute their chosen moves (or wait) simultaneously, updating their positions and the set of visited targets. The loop repeats until every target has been reached.

The authors provide a detailed complexity analysis. Dijkstra’s and Yen’s algorithms dominate the per‑timestep cost with (O(k·(m\log m + |E|))) per pair of nodes, where m = |V|. Considering up to (n^2) agent‑agent pairs and n·m agent‑target pairs, the overall per‑step complexity is (O(nm + n^2 m)) when k is treated as a constant. The waiting‑decision step adds another (O(n^2 m)). Empirically, the algorithm scales well on sparse road‑network graphs.

Experimental validation uses a real‑world road network from Champaign‑Urbana, Illinois. Simulations with 2 to 20 agents were performed, comparing three methods: (i) the proposed virtual‑force algorithm, (ii) the earlier Jagdale‑Ornik heuristic (limited to two agents), and (iii) a non‑modular baseline where each agent follows its own shortest path independently. Results show that the virtual‑force approach consistently reduces total traversal cost by roughly 15–30 % relative to the baseline, with larger savings when agents share long overlapping route segments. The ability to wait and to join early, then split near the targets, accounts for most of the improvement.

Key contributions of the work include:

• Introducing a physics‑inspired force model to guide discrete graph routing of modular agents.
• Demonstrating how a small set of k‑shortest paths can approximate continuous potential fields on a graph.
• Providing a simple yet effective deadlock‑avoidance mechanism via the wait rule.
• Showing, through realistic road‑network simulations, that modularity can yield substantial operational savings in multi‑target missions.

The paper also acknowledges limitations: the performance depends on the choice of α and β, which may need problem‑specific tuning; the heuristic does not guarantee optimality; and scalability to very large urban networks or dynamic traffic conditions remains to be explored. Future work could investigate adaptive parameter learning, integration with time‑varying edge weights, and real‑time deployment on autonomous vehicle platforms.