A RGONAUT: Interactive Visual Exploration for Distributed Optimization Srijoni Majumdar∗ , Chuhao Qin∗ , Evangelos Pournaras∗† ∗ School of Computer Science, University of Leeds, Leeds LS2 9JT, UK. E-mail: S.Majumdar,C.Qin,[email protected]
arXiv:2607.27946v1 [cs.MA] 30 Jul 2026
† School of Energy Systems, LUT University, 53850 Lappeenranta, Finland
Abstract—Distributed discrete-choice optimization in decentralized settings is often hard to explore and navigate: disentangling what other agents choose, how their choices are interdependent, and how they collectively reach a global objective quickly becomes intractable as the system scales. The major limitation is observability of the search process. Existing methods are largely centralized and offer limited support, visualizing only the final solution or providing algorithm backends over a fixed dataset, so how a solution is reached stays a black box. We present A RGONAUT, a lightweight, containerized optimization dashboard that enables interactive, visual exploration of the entire search process for multi-agent discrete-choice optimization in decentralized settings. Users upload datasets, construct agents and options, modify the decision space and its parameters on the fly, and run multiple algorithm backends to inspect how each configuration shapes local agent decisions and the resulting global objective. By uniting system construction, optimization, and analysis in one interactive loop, the first of its kind, A RGONAUT makes distributed discrete-choice optimization a human-in-theloop process rather than a one-shot, black-box computation. We evaluate A RGONAUT on real-world household-electricity, shared-mobility, and sensor-data-exchange datasets scaling to 5600 agents and up to 1M solutions under brute force. Built on a Node.js interface with extensible Java and Python optimization backends, it maintains a typical runtime of 200 agents over 100 decision attributes in under 30 seconds. Index Terms—Multi-agent Discrete Choice Optimization; Visually Guided Combinatorial Search; Decision Space Pruning; Heuristic search, Human-in-the-loop optimization; Collective Learning.
I. I NTRODUCTION Distributed discrete-choice optimization underpins several real-world problems, including scheduling, routing, and resource allocation. Each agent selects a preferred option from a finite set while collectively aiming to optimize a global objective. As agents and options scale, the decision space grows exponentially, making it increasingly difficult to work out how individual choices shape collective behavior. Decentralized settings make this harder still, as agents lack a complete view of one another’s preferences and so of the decision space as a whole. The missing piece is the observability of the entire optimization process: how each agent chooses a plan, when that choice can change, how their choices are interdependent, and how they shape the global objective. This observability makes optimization practical and scalable for the real-time shared-resource decisions in energy, transport, mobility, logistics, and urban infrastructure [1], [2].
It leverages human oversight to steer the process through interventions, e.g., tuning parameters, restricting the decision space, or adjusting the global objective [3]–[5], helping agents align on power use, routes, or parking at critical moments, and preventing the disruption that would otherwise follow.
Fig. 1. A RGONAUT: Black-Box optimization to visual interactive human in the loop exploration
Existing methods offer only a limited view of the process. Some tag whether a solution is a global optimum, letting users re-run the optimization with different parameters to escape a local one, but only for centralized algorithms over a small decision space [6], [7]. Others specifically visualize only the final solution or provide flexible execution through multiple algorithm backends, but only over a fixed set of datasets [8]– [10]. The available support thus remains fragmented, lacking an end-to-end observability of the individual and collective agent behavior across the optimization process. We introduce A RGONAUT1 to bridge this gap, bringing multiple discrete-choice optimization paradigms for decentralized settings into a single, lightweight, containerized dashboard. It supports brute-force search over the full decision space; tree-structured decentralized iterative methods that coordinate agents to converge to a solution; and a combination of the two, which ranks that solution against the global optimum found by brute-force search. A RGONAUT enables human-inthe-loop optimization by uniting construction, optimization, and analysis in one loop, thereby transforming the optimization process from a black box into an observable, interactive, and visual one (Figure 1). Users upload datasets, construct agents 1 A RGONAUT —Cloud-hosted service at https://argonautsim-382548405389. us-central1.run.app/ with video [https://youtu.be/NMoVSavMvd8] to run. Running on localhost: code and instructions at https://github.com/TDI-Lab/ Argonaut for MacOS, Linux, and Windows.
and options, prune or edit the decision space on the fly, and run alternative algorithms over the same configuration, intervening to improve the optimality of the solution. We perform a cross-domain evaluation of A RGONAUT, running bruteforce and decentralized search over real-world householdelectricity, shared-mobility, and data-sharing datasets, alongside synthetic ones, ranging from 70 to 5600 agents with 64 to 144 decision scenarios and up to 1M solutions under brute force. Over multiple runs, we test correctness, scalability, and effectiveness: the cloud-hosted service maintains a typical runtime (on localhost) of under 30 seconds for 200 agents over 100 decision attributes on minimal computing resources, guided exploration improves solution optimality on average by 24.87%, and non-experts reach near-optimal solutions on par with domain experts. This paper makes three contributions: (i) The first platform of its kind to make the entire optimization process observable and steerable in decentralized settings. (ii) A lightweight, portable, and customizable design, a containerized runtime with algorithm-agnostic APIs to configure multiple backends, deployable in the cloud or on standalone systems. (iii) A fast and computationally efficient engine, well suited for integration into standard transaction frameworks for operational decisions such as load balancing and scheduling in city infrastructure. The remainder of this paper is organized as follows. Section II reviews related work on optimization visualization. Section III describes the design of A RGONAUT, including decision-space construction, optimization, and analysis. Section IV details the implementation and deployment. Section V reports the evaluation, and Section VI concludes. II. R ELATED W ORK Prior work on observability in discrete-choice optimization falls into four lines of work, each covering only part of the problem. First, proposed methods tag each achieved solution only by whether it is a global optimum, without any ranking, letting users re-run the search to escape a local optimum; this supports human-guided search, but with only limited interactive control [6], [7]. Second, algorithm-specific tools such as SwarmViz [11] visually monitor particle swarm optimization methods [12], [13] and map high-dimensional Pareto fronts to lower dimensions for trade-off comparison, but remain bound to a particular algorithm, objective structure, or offline setting. Third, some methods use visual steering to configure machine-learning algorithms through hyperparameter tuning and design-space exploration [14]–[16]. A fourth line of work covers general optimization software and solvers, including OR-Tools [9], HeuristicLab [17], IOHanalyzer [8], Gurobi [10], and branch-and-bound visualizers [18], as well as decentralized solvers such as COHDA [19] and DCOP methods [20]. These bring multiple algorithm backends into one tool but mostly over fixed datasets, and return only final solutions without interactive inspection of the optimization process. Discrete-choice modeling tools [21], [22] mostly help with choice modeling and estimating model
TABLE I C OMPARISON OF EXISTING OPTIMIZATION VISUALIZERS AND SOFTWARE INDICATES SUPPORT, ✗ INDICATES NO AGAINST A RGONAUT . SUPPORT, AND NA MEANS NOT APPLICABLE .
✓
Capability Parameter modeling Global-optimum detection Visualization of final solution Multiple algorithm backends Local & global analysis Decentralized multi-agent support Construct–optimize–analyze loop
Human-guided search
Algorithm/datasetspecific
Machine-learning specific
Standard solvers/ benchmarks
[6], [7]
[11]–[13]
[14], [15]
[8]–[10]
A RGONAUT
✓ ✓ ✓ ✓
✗ ✗
✓ ✓ ✓
✓
✓ ✓ ✓ ✓ ✓ ✓ ✓
✗ ✗ ✗
✓ ✗
✓ ✗ ✗
✗ ✗ NA ✗
✗ ✗
✓ ✗ ✗ ✗
parameters from data rather than navigating the combinatorial decision space of coordinated agents. Across these tools, support is mostly applicable for centralized settings and lacks an end-to-end view, offering no account of how discrete choices are formed, pruned, traversed, and balanced across local and global objectives, which is critical for decentralized systems. A RGONAUT addresses this gap as lightweight, software that supports the full construct– optimize–analyze loop for discrete-choice optimization. Table I summarizes this comparison across seven capabilities spanning centralized and decentralized settings. III. D ESIGN OF A RGONAUT A. Optimization Problem We model a typical socio-technical system as a set of agents A = {a1 , . . . , an }, where each agent ai ∈ A is an autonomous decision-making unit, such as a household, vehicle, shipment, station, or user [23]. Each agent ai holds a finite set of plans Pi = {pi1 , . . . , pik }, its feasible options, i.e., those satisfying the agent’s local constraints, such as capacity or availability. Every plan describes what an agent would do across a set of decision attributes, such as how much power to draw at each time step, how to allocate a resource, or what demand to place. Formally, a plan pij ∈ Pi is a d-dimensional vector, with one value per attribute. A collective solution s = (p1 , . . . , pn ) is then one choice of plan per agent, and the set of all such combinations forms Qn the decision space S = P1 ×P2 ×· · ·×Pn , of size |S| = i=1 |Pi |. Three objectives evaluate a collective solution. The global objective measures system-level inefficiency through nonlinear measures such as residual sum of squares and root mean square error, which quantify how closely the collective outcome matches a target global objective bound, or variance, which captures imbalance across agents, resources, or time [24]. These are nonlinear because cost grows disproportionately with imbalance: e.g., in an energy grid, a few households drawing power at the same peak minute strains the network far more than the same demand spread out, and in transport, vehicles converging on one road cause congestion that rises steeply with load. The local objective measures per-agent discomfort, how far an agent’s selected plan sits from its preferred one, e.g., a household shifting its laundry to an off-peak hour, or a driver taking a longer route to ease congestion. The unfairness objective measures how unevenly this discomfort is spread across agents, so that no single household or driver
bears all the inconvenience [25]. A RGONAUT combines these into a single total cost C, weighted by agent-controlled tradeoff parameters α, β, γ ≥ 0 with α + β + γ = 1, which set their priority. The goal is to find a feasible collective solution that minimizes C. A RGONAUT explores this decision space in two modes. (i) Brute force search. It constructs the full decision space S as the Cartesian product of every agent’s plan set, evaluates the total cost C of each collective solution s ∈ S, and returns the one with the lowest cost, which is the global optimum. (ii) Iterative decentralized search. The agents coordinate over successive iterations to refine their choices. In each iteration, every agent ai selects the plan from its set Pi that minimizes the total cost C, given the current plans of the other agents. This repeats until the objectives stabilize, converging to a nearoptimal, or the optimal solution. When complete search is tractable, its global optimum serves as the reference against which any optimality gap of the iterative solution is measured.
(a) Construct component of A RGONAUT, Pre-configured dataset: (A, {Pi }, d), Number of agents: n = |A|, Agent selection mode: subset A′ ⊆ A, Plans per agent: |Pi | = p with d Decision attributes, Algorithm type: optimizer over S, Search configuration: brute force / iterative / both, Iteration count: T iterations, Children per node: tree branching factor c, Simulation count: R runs, Objective weights: trade-off parameters (α, β, γ) and the local and global objectives and cost functions. Fig. 2. Schematic architectural view of A RGONAUT, showing the construct– optimize–analyze loop from decision-space construction, through algorithmic optimization, to interactive visual analytics.
B. A RGONAUT Figure 2 shows the architecture of A RGONAUT. Construct (Figure 3a). Users can define, remove, and edit on the fly the number of agents A = a1 , . . . , an , their plans Pi , the decision attributes d, and the objectives and trade-off parameters that form the decision space S. Optimize (Figure 2). A RGONAUT supports multiple algorithmic backends, such as brute-force search, brute-force search with pruning or centralized or decentralized iterative search with multiple algorithms available within each paradigm. A configurable input space is designed to support these multiple backends, combine and compare algorithms and also ranking iterative solutions against the global optimum from brute-force search. Analyze (Figure 3b). A RGONAUT brings multiple interactive views of the optimization process into one place, covering cost, convergence, optimality, and solution comparison. These views show how global, local, and unfairness costs evolve, how plan selections change across iterations, and how local– global trade-offs are balanced, making the search process more transparent and interpretable. This separation keeps A RGONAUT algorithm-agnostic and extensible while preserving a continuous construct–optimize– analyze loop (full workflow illustrated in Figure 4).
(b) Analyzer component of A RGONAUT, interface for interactive, iterationby-iteration analysis of costs, convergence, plan changes, and comparative optimization outcomes. Fig. 3. Construct and analyzer components of A RGONAUT.
IV. I MPLEMENTATION OF A RGONAUT A RGONAUT is engineered around three goals: it should be lightweight, highly portable, and customizable. Construction Layer (Frontend & Translation). This layer is a React frontend on a Node.js stack [26]–[28]: React manages the interactive controls (topology, agents, plans, objective weights, cost and iteration views), Node.js serves assets with non-blocking I/O to stay responsive during optimization, and Vite [28] compiles the frontend into static assets, keeping it lightweight. A translation API, a Python module behind a lightweight REST endpoint, then serializes the frontend state into a normalized JSON [26] schema (agents, plans, constraints, objectives, trade-off weights, topology and algorithm)
Fig. 4. Decision space exploration sequence in A RGONAUT, showing how users configure parameters, translate them into optimizer ready inputs, execute algorithms, inspect offline visual analytics, and iteratively refine the balance between global performance, fairness, and local cost.
and converts it into the input format each algorithm requires, decoupling encoding so one decision space can drive different solvers, the key to customizable design. Optimization Layer (Solver Backend). In our design, algorithmic backends may be implemented in heterogeneous languages, each encapsulated by a language-specific solver wrapper exposing a uniform REST [29] endpoint. Each wrapper derives from a common base via minimal customization, yielding a language-agnostic, portable, and extensible system. Visualization API (Rendering Engine). The execution traces and topologies are converted into interactive analytics using Python NetworkX [30]. NumPy computes layouts [31], Matplotlib renders reproducible figures [32], and pandas processes .csv logs and tabular summaries [33]. Analysis Layer (Interactive Views): The analysis layer is supported by a lightweight Node.js interface that serves interactive views using dynamic tagged pointers for easy iterationlevel analysis [26]–[28]. Deployment (Containerized Runtime). A RGONAUT is containerized, packaging its runtime and dependencies into a single portable unit [34] that is highly portable and thus can be deployed both in the cloud and in standalone systems. A multistage Docker build separates the Node.js build environment from the production server, so the final container holds only the compiled front end and static resources [35], keeping it lightweight. NGINX [35] serves the interface and visualization output as static content through a thin production server [36]. V. E VALUATION For the proof-of-concept evaluation, we use synthetic and domain-specific discrete-choice datasets to assess the correctness, scalability, and effectiveness of A RGONAUT. The synthetic benchmark contains 1000 agents, each with 16 plans and 100 decision attributes. Attribute values are drawn from a Gaussian distribution [37] and shaped as ya,p,d = xa,p,d cos(2πfp d + ϕa ), giving each agent a distinct cosinewave structure. This dataset is used to test both brute-force search, up to 1M solutions, and decentralized iterative search.
Fig. 5. Computation load run in A RGONAUT, matching that reported for I-EPOS [23]. Scaling of total computations (a p2 ), critical path (p2 ⌈log2 a⌉, the longest dependent chain of operations), and communication (p⌈log2 a⌉) with the number of agents, for plans p ∈ {10, 20, 40}, run for 10 simulations and 40 iterations. Logarithmic tree depth keeps critical path and communication modest despite steep growth in total computation.
The real-world domain-specific datasets [38] cover energy management (5600 agents, 10 plans, 144 intervals), sensor data-sharing (72 agents, 3 privacy-aware plans, 64 attributes), and shared mobility (2300 agents, 2–50 plans, 98 bike stations).
Fig. 6. A RGONAUT keeps decentralized optimization within practical runtime limits (shown here for localhost), ranging from 26 seconds to 28 minutes across up to 5000 agents and 40 plans per agent, while brute force already takes 110 minutes for only 7 agents and 6 plans. Agents: a ∈ 200, 500, 1000, 2000, 5000, plans per agent: p ∈ 10, 20, 40, with 100 decision attributes.
We instantiate A RGONAUT with (i) a brute-force search that enumerates all feasible collective solutions to return the global optimum [39] (ii) I-EPOS, a collective learning algorithm [23] for iterative decentralized optimization, as a representative backend. I-EPOS is chosen for its fully decentralized design and low computational and communication overhead, making it suitable for interactive visual exploration. Correctness and Scalability: A RGONAUT passes correctness tests across both the centralized brute-force and decentralized tree-based optimization modes. Component-level checks for data loading, plan parsing, objective computation, tree construction all pass successfully [40], [41]. Across 24 independent runs, the solutions exported by A RGONAUT match independently executed reference algorithms exactly, verified with a similarity-checker script [42]. This holds for the bruteforce mode over decision spaces up to 60K solutions in cloud and 1M solutions in localhost machines, and for the decentralized tree-based mode over 1000 to 5600 agents, 2 to 50 plans, and 64 to 144 decision attributes, while varying
Fig. 7. Optimality-gap improvement is highest when changing the target global objective bounds. Optimality-gap improvement (%) per configuration change across 4 runs for 4 runs experts and 4 non-expert users on 4 datasets (64 runs per group). Cost-function and decision-attribute changes yield the largest improvement, while the number of plans and trade-off parameters have little effect, and the pattern holds across expertise. The optimality gap is g = (C − C ∗ )/C ∗ , where C is the achieved total cost and C ∗ the optimal solution from decentralized iterative search; improvement is the reduction in g after the change.
the number of iterations, objectives, topology structures, and trade-off parameters. Having established correctness, we next examine how A RG ONAUT scales, using the computation load it reports when running the I-EPOS tree-based decentralized optimizer [23]. Figure 5 decomposes it into total computation, the critical path (the longest dependent chain of operations), and communication cost. At a = 5000 agents and p = 40 plans, total computation reaches 8 × 106 operations, while the critical path stays at 2.08 × 104 and communication at 520. Total work scales with agents and plans, but coordination depth and communication stay orders of magnitude smaller, matching the figures reported for I-EPOS. Figure 6 reports the measured runtime across configurations. The tree-based optimization ranges from 28 s at (a, p) = (200, 10) with 100 decision attributes to roughly 28 min at (5000, 40), increasing significantly with the number of plans (pairwise p = 0.034 for 10 vs. 20, p = 0.0056 for 10 vs. 40, and p = 0.024 for 20 vs. 40). The algorithm stage dominates, on average 7.6× longer than the visualization API and 7.4× longer than rendering, with the latter two within a few percent of each other. We conduct scalability testing for brute-force search across decision spaces of increasing size: 5 × 104 collective solutions take approximately 110 minutes, while 106 solutions take up to 44 hours. Its algorithm stage accounts for ≈ 99% of runtime, running 111× longer than the visualization API and 934× longer than rendering; these differences are significant (p = 0.0027 algorithm vs. visualization, p = 0.00045 visualization vs. rendering). On average, across comparable configurations, brute force is roughly ⟨85⟩× slower than the decentralized tree-based method, confirming its scalability advantage. Localhost vs Cloud: A RGONAUT is also cross-software compatible and the reported runtimes (Figure 6) are measured on localhost across MacOS, Linux, and Windows (e.g. 4core/8-thread CPU and 16 / 32 GB RAM). A RGONAUT is also available as a cloud-hosted service on Google Cloud Run using free credits; its runtime is on average approximately 40% slower, as the minimal free-tier instance (512 MiB mem-
ory, 0.08 vCPU) shares resources with co-located workloads. Hosting it there tests the portability of the containerized design to the cloud, and adds flexibility for evaluation. Within Cloud Run, paid usage scales up to 8 vCPU and 32 GiB memory; in limited experiments this yields a 34% reduction in visualization time and 45% in rendering time, and the containerized design ports directly to larger instances on Compute Engine, GKE, or clouds such as AWS to recover localhost-level performance. We will explore this in future for a production release on integration with transactional systems. Effectiveness: To test the effectiveness of A RGONAUT, we evaluate it with four expert and four non-expert participants across four datasets: household electricity, sensor data sharing, shared mobility, and a synthetic Gaussian dataset. Each group performs 64 runs (4 × 4 × 4) in total using decentralized iterative search, covering four datasets and four runs per dataset. In each run, a participant observes and interactively explores the optimization process in A RGONAUT, changes one control variable, either the trade-off parameters, the number of plans, or the target global objective bounds, and evaluates whether the edited decision space improves the solution rank by moving it closer to the global optimum, i.e., by reaching a lower-cost solution than the previous one. On average, across these 64 runs for each group (Figure 7), A RGONAUT reduces the optimality gap by up to 35.3%, with an average reduction of 24.87%, reaching the global optimum exactly in 12.56% of cases. Changing the target global objective bounds yields a statistically significant improvement over changing the number of plans (p = 0.0045) and the tradeoff parameters (p = 0.0003), while the improvement from changing the number of plans over the trade-off parameters is not statistically significant (p = 0.073). The mean difference between expert and non-expert users is also not statistically significant (p = 0.0894), confirming that A RGONAUT makes effective optimization accessible to newcomers as well as experts. These results are based on 64 runs per group; a largerscale user study is a direct and important extension we plan for future work. VI. C ONCLUSIONS We presented A RGONAUT, a lightweight, containerized, and highly customizable platform for interactive and visual exploration of distributed discrete-choice optimization. By supporting multiple algorithmic backends and uniting construction, optimization, and analysis in one interactive loop, A RGONAUT enables users to observe and navigate optimization runs within seconds to a few minutes, making it practical for prompt shared-resource management decisions in smartcity infrastructure. Guided by these views, users could improve solution optimality on average by 24.87% across domains such as energy, mobility, transport, and logistics. Ongoing work extends A RGONAUT to additional backends, including decentralized iterative search under varying network topologies and brute-force search with pruning via Gurobi [39]. Building on this, our next step is to develop an explainability layer that surfaces why the search behaves as it does,
particularly by detecting and explaining when and why an agent changes its selected plan during convergence. This will move A RGONAUT from observable optimization toward fully explainable, human-in-the-loop decision-making, while also enabling the analysis of how such behaviours change in the presence of adversarial agents and how they can impact the overall optimization process. ACKNOWLEDGMENT This work is funded by UKRI Future Leaders Fellowship (MR/W009560/1): Digitally Assisted Collective Governance of Smart City Commons–ARTIO’ and UKRI Impact Acceleration Account grant (IAA4148): Collective Learning Optimization Algorithm. The google cloud credits are funded by UKRI AI Super Connector Fellowship from Imperial College London. R EFERENCES [1] B. Turan, V. Hemmelmayr, A. Larsen, and J. Puchinger, “Transition towards sustainable mobility: the role of transport optimization,” Central European Journal of Operations Research, vol. 32, no. 2, pp. 435–456, 2024. [2] E. Pournaras and J. Espejo-Uribe, “Self-repairable smart grids via online coordination of smart transformers,” IEEE Transactions on Industrial Informatics, vol. 13, no. 4, pp. 1783–1793, 2016. [3] R. Xin, S. Pu, A. Nedić, and U. A. Khan, “A general framework for decentralized optimization with first-order methods,” Proceedings of the IEEE, vol. 108, no. 11, pp. 1869–1889, 2020. [4] C. Blum and A. Roli, “Metaheuristics in combinatorial optimization: Overview and conceptual comparison,” ACM computing surveys (CSUR), vol. 35, no. 3, pp. 268–308, 2003. [5] L. Kotthoff, “Algorithm selection for combinatorial search problems: A survey,” in Data mining and constraint programming: Foundations of a cross-disciplinary approach. Springer, 2016, pp. 149–190. [6] F. Colella, P. Daee, J. Jokinen, A. Oulasvirta, and S. Kaski, “Human strategic steering improves performance of interactive optimization,” in Proceedings of the 28th ACM conference on user modeling, adaptation and personalization, 2020, pp. 293–297. [7] G. W. Klau, N. Lesh, J. Marks, and M. Mitzenmacher, “Human-guided search,” Journal of Heuristics, vol. 16, no. 3, pp. 289–310, 2010. [8] H. Wang, D. Vermetten, F. Ye, C. Doerr, and T. Bäck, “IOHanalyzer: Detailed Performance Analyses for Iterative Optimization Heuristics,” https://arxiv.org/abs/2007.03953, 2020, accessed: 2026-06-18. [9] Google, “OR-Tools: Operations Research Tools,” https://developers. google.com/optimization, accessed: 2026-06-18. [10] Gurobi Optimization, LLC, “Gurobi Optimizer,” https://www.gurobi. com/, accessed: 2026-06-18. [11] G. Jornod, E. Di Mario, I. Navarro, and A. Martinoli, “Swarmviz: An open-source visualization tool for particle swarm optimization,” in 2015 IEEE congress on evolutionary computation (CEC). IEEE, 2015, pp. 179–186. [12] Z. He and G. G. Yen, “An improved visualization approach in manyobjective optimization,” in 2016 IEEE congress on evolutionary computation (CEC). IEEE, 2016, pp. 1618–1625. [13] H.-C. Lee and Y.-H. Kim, “Visualizing swarm behavior with a particle density map,” in Proceedings of the Genetic and Evolutionary Computation Conference Companion, 2019, pp. 415–416. [14] S. P. Thole and P. Ramu, “Design space exploration and optimization using self-organizing maps,” Structural and Multidisciplinary Optimization, vol. 62, no. 3, pp. 1071–1088, 2020. [15] P. Ramu, P. Thananjayan, E. Acar, G. Bayrak, J. W. Park, and I. Lee, “A survey of machine learning techniques in structural and multidisciplinary optimization,” Structural and Multidisciplinary Optimization, vol. 65, no. 9, p. 266, 2022. [16] D. Yadav, P. Ramu, and K. Deb, “Handling objective preference and variable uncertainty in evolutionary multi-objective optimization,” Swarm and Evolutionary Computation, vol. 94, p. 101860, 2025. [17] Heuristic and Evolutionary Algorithms Laboratory, “HeuristicLab: An Environment for Heuristic and Evolutionary Optimization,” https:// github.com/heal-research/HeuristicLab, accessed: 2026-06-18.
[18] O. Y. Ozaltın, B. Hunsaker, and T. K. Ralphs, “Visualizing Branchand-Bound Algorithms,” https://optimization-online.org/2007/09/1785/, 2007, accessed: 2026-06-18. [19] C. Hinrichs, S. Lehnhoff, and M. Sonnenschein, “COHDA: A combinatorial optimization heuristic for distributed agents,” in International Conference on Agents and Artificial Intelligence. Springer, 2013, pp. 23–39. [20] W. Yeoh, A. Felner, and S. Koenig, “BnB-ADOPT: An asynchronous branch-and-bound dcop algorithm,” Journal of Artificial Intelligence Research, vol. 38, pp. 85–133, 2010. [21] Apollo Choice Modelling, “Apollo: An R Package for the Estimation and Application of Choice Models,” https://www.apollochoicemodelling. com/, accessed: 2026-06-18. [22] P. Mariel, D. Hoyos, J. Meyerhoff, M. Czajkowski, T. Dekker, K. Glenk, J. B. Jacobsen, U. Liebe, S. B. Olsen, J. Sagebiel, and M. Thiene, “Software,” in Environmental Valuation with Discrete Choice Experiments, ser. SpringerBriefs in Economics. Cham: Springer, 2021, pp. 125–129. [23] E. Pournaras, P. Pilgerstorfer, and T. Asikis, “Decentralized collective learning for self-managed sharing economies,” ACM Transactions on Autonomous and Adaptive Systems (TAAS), vol. 13, no. 2, pp. 1–33, 2018. [24] D. S. K. Karunasingha, “Root mean square error or mean absolute error? use their ratio as well,” Information Sciences, vol. 585, pp. 609–629, 2022. [25] B. Western and D. Bloome, “9. variance function regressions for studying inequality,” Sociological Methodology, vol. 39, no. 1, pp. 293– 326, 2009. [26] OpenJS Foundation, “About Node.js,” https://nodejs.org/en/about, accessed: 2026-06-24. [27] Meta Open Source, “React: Components and Props,” https://www. w3schools.com/react/react components.asp, accessed: 2026-06-24. [28] Vite, “Building for Production,” https://vite.dev/guide/build, accessed: 2026-06-24. [29] R. T. Fielding, Architectural styles and the design of network-based software architectures. University of California, Irvine, 2000. [30] NetworkX Developers, “NetworkX Documentation,” https://networkx. org/documentation/stable/, accessed: 2026-06-24. [31] NumPy Developers, “NumPy Documentation,” https://numpy.org/doc/ stable/, accessed: 2026-06-24. [32] Matplotlib Developers, “matplotlib.pyplot.savefig,” https://matplotlib. org/stable/api/ as gen/matplotlib.pyplot.savefig.html, accessed: 202606-24. [33] pandas Developers, “IO Tools,” https://pandas.pydata.org/docs/user guide/io.html, accessed: 2026-06-24. [34] O. Bentaleb, A. S. Belloum, A. Sebaa, and A. El-Maouhab, “Containerization technologies: Taxonomies, applications and challenges,” The Journal of Supercomputing, vol. 78, no. 1, pp. 1144–1181, 2022. [35] Docker, “Multi-stage Builds,” https://docs.docker.com/build/building/ multi-stage/, accessed: 2026-06-24. [36] NGINX, “Serving Static Content,” https://docs.nginx.com/nginx/ admin-guide/web-server/serving-static-content/, accessed: 2026-06-24. [37] L. Wang, L. Xu, D. Zhao, Y. Yao, and D. Song, “FPGA-based design and implementation of arterial pulse wave generator using piecewise gaussian–cosine fitting,” Computers in Biology and Medicine, vol. 59, pp. 142–151, 2015. [38] E. Pournaras, “Agent-based Planning Portfolio,” 4 2019. [Online]. Available: https://figshare.com/articles/dataset/Agent-based Planning Portfolio/7806548 [39] J. Nievergelt, “Exhaustive search, combinatorial optimization and enumeration: Exploring the potential of raw computing power,” in International Conference on Current Trends in Theory and Practice of Computer Science. Springer, 2000, pp. 18–35. [40] E. T. Barr, M. Harman, P. McMinn, M. Shahbaz, and S. Yoo, “The oracle problem in software testing: A survey,” IEEE transactions on software engineering, vol. 41, no. 5, pp. 507–525, 2014. [41] N. Rachatasumrit and M. Kim, “An empirical investigation into the impact of refactoring on regression testing,” in 2012 28th IEEE international conference on software maintenance (icsm). IEEE, 2012, pp. 357–366. [42] A. S. M. Noor, F. Yunus, H. J. Liang, and N. F. M. Zin, “Programming similarity checking system,” Journal of Telecommunication, Electronic and Computer Engineering (JTEC), vol. 9, no. 3-5, pp. 89–94, 2017.