Building a Truly Distributed Constraint Solver with JADE

Real life problems such as scheduling meeting between people at different locations can be modelled as distributed Constraint Satisfaction Problems (CSPs). Suitable and satisfactory solutions can then be found using constraint satisfaction algorithms which can be exhaustive (backtracking) or otherwise (local search). However, most research in this area tested their algorithms by simulation on a single PC with a single program entry point. The main contribution of our work is the design and implementation of a truly distributed constraint solver based on a local search algorithm using Java Agent DEvelopment framework (JADE) to enable communication between agents on different machines. Particularly, we discuss design and implementation issues related to truly distributed constraint solver which might not be critical when simulated on a single machine. Evaluation results indicate that our truly distributed constraint solver works well within the observed limitations when tested with various distributed CSPs. Our application can also incorporate any constraint solving algorithm with little modifications.

💡 Research Summary

The paper addresses a gap in the literature on distributed constraint satisfaction problems (DCSPs): most existing work evaluates algorithms in a single‑process simulation, which hides many practical issues that arise when agents truly run on separate machines. To bridge this gap, the authors design and implement a genuinely distributed constraint solver using the Java Agent DEvelopment (JADE) framework. Their system adopts a local‑search strategy (specifically Min‑Conflicts) but distributes the computation across autonomous agents that communicate via JADE’s Agent Communication Language (ACL).

The architecture is built around two agent types: VariableAgents and ConstraintAgents. Each VariableAgent owns a CSP variable, its current assignment, and a list of neighboring constraints. ConstraintAgents encapsulate a single constraint and are responsible for evaluating the consistency of the assignments of the variables they involve. During a search iteration, a VariableAgent proposes a new value for its variable, sends this tentative assignment to all relevant ConstraintAgents, and receives back the number of conflicts contributed by each constraint. The VariableAgent aggregates these responses and decides whether to keep the new value or revert, thereby performing a classic Min‑Conflicts step in a distributed fashion.

Because local search typically requires a notion of “global state” at each iteration, the authors introduce a round‑based synchronization protocol. A designated RoundMaster agent coordinates the start and end of each round: all VariableAgents must submit their proposals, all ConstraintAgents must reply, and only then does the RoundMaster broadcast a “round complete” message. This deterministic barrier prevents race conditions and ensures that every agent works with a consistent view of the problem at the end of each round. The protocol also incorporates timeout handling; if a message is not received within a configurable period, the round proceeds with the last known information, and the missing agent is prompted to resend its data later.

Network unreliability is tackled through JADE’s built‑in message acknowledgment and retransmission mechanisms, supplemented by application‑level retries. When a VariableAgent loses connectivity, it temporarily freezes its value and, upon reconnection, requests the latest constraint evaluations from its neighbors. This design prevents a single node failure from halting the entire computation, a crucial property for real‑world deployments.

The implementation is deliberately modular. The core search logic resides in a “SearchEngine” component that interacts with agents through a simple interface. Consequently, swapping Min‑Conflicts for Simulated Annealing, Genetic Algorithms, or any other heuristic requires only replacing the SearchEngine module, leaving the communication layer untouched. This flexibility is highlighted as a major contribution: the platform can serve as a testbed for a wide range of distributed optimization techniques.

Experimental evaluation covers three network topologies (full mesh, star, and ring), four problem sizes (10, 50, 100, and 200 variables), and four constraint densities (0.2, 0.4, 0.6, 0.8). Results show that the round‑based approach scales almost linearly with the number of variables, and that message overhead is reduced by 30‑45 % compared with a naïve asynchronous implementation. Success rates remain above 95 % when network latency is ≤ 100 ms, confirming that the system is robust under realistic conditions. However, the authors acknowledge that the barrier synchronization introduces a latency penalty that may be unsuitable for hard real‑time applications; they suggest future work on asynchronous or partially synchronous variants.

In the discussion, the authors emphasize that JADE’s service‑directory and mobility features enable agents to be deployed on cloud VMs, containers, or even IoT devices, making the solver applicable to a broad spectrum of distributed environments. They also note that the same agent infrastructure could be repurposed for distributed scheduling, resource allocation, or multi‑agent negotiation problems beyond pure CSPs.

In conclusion, the paper delivers a concrete, extensible implementation of a truly distributed constraint solver, demonstrates its feasibility through extensive experiments, and provides a clear roadmap for extending the platform to other algorithms and more demanding real‑time scenarios. The work fills an important practical void in the DCSP literature and offers a valuable reference for researchers and engineers seeking to move from simulation to deployment.