Asynchronous Decentralized Bayesian Optimization

• ADBO is a decentralized and asynchronous Bayesian optimization framework that allows independent workers to run local BO loops without a centralized scheduler.
• It effectively handles heterogeneous and unpredictable evaluation times by coordinating via shared storage or peer communication, minimizing idle worker time.
• ADBO systems enhance scalability in applications like hyperparameter optimization and swarm robotics by integrating diverse surrogate models and dynamic acquisition strategies.

Searching arXiv for the cited works on asynchronous and decentralized Bayesian optimization. Asynchronous Decentralized Bayesian Optimization (ADBO) denotes a family of Bayesian optimization (BO) architectures designed for expensive black-box objectives in which evaluations complete at different times and coordination is not mediated by a single optimization manager. In its strictest form, each worker executes its own BO loop, exchanges observations through shared storage or peer communication, and launches new evaluations immediately upon becoming available. In broader usage, the term also covers “ADBO-like” systems that are asynchronous and distributed but not fully decentralized in the multi-agent or consensus-theoretic sense. The literature therefore spans worker-driven shared-state hyperparameter optimization, asynchronous parallel Thompson sampling, trajectory-based swarm search, and distributed BO software frameworks for HPC environments (Egele et al., 2022).

1. Definition and problem setting

ADBO arises from a practical mismatch between standard BO and modern distributed compute regimes. Classical parallel BO commonly uses a single manager with multiple workers: the manager maintains the archive, refits the surrogate, solves the batch acquisition problem, dispatches configurations, and collects results. Several papers identify two failure modes of that design at scale: evaluation times are heterogeneous and unpredictable, so synchronous batching leaves workers idle; and the “ask” side of BO itself becomes a bottleneck when many workers return results asynchronously (Nomura, 2020, Egele et al., 2022).

The strict ADBO formulation in large-scale hyperparameter optimization is explicit: each worker runs a sequential BO locally, writes completed $(x,y)$ pairs to shared storage, reads observations produced by other workers, updates its local surrogate, and proposes the next point without waiting for a central controller (Egele et al., 2022). In the shared-state R implementation of rush, this same idea is described operationally as decentralized optimization through a common archive of running and finished tasks rather than controller-worker dispatch (Becker et al., 19 Jun 2026).

The term nevertheless has looser uses. The TPE-based method of “Simple and Scalable Parallelized Bayesian Optimization” is asynchronous and worker-driven, but the paper does not present a fully decentralized multi-agent coordination protocol; it is therefore better characterized as asynchronous parallel BO rather than strict decentralized BO (Nomura, 2020). Likewise, ARCO-BO is decentralized in local modeling and asynchronous in sampling frequency, yet it remains organized around a scheduled consensus procedure rather than a fully event-driven distributed system (Wang et al., 18 Oct 2025). This boundary between asynchronous parallel BO and strict ADBO is a recurring terminological issue in the literature.

2. Coordination architectures and execution models

The defining architectural question in ADBO is how workers coordinate without global synchronization. In shared-state systems, the common pattern is that every worker repeatedly fetches the current archive, computes a new proposal, registers it as running, evaluates it, and then marks it finished. In rush, Redis serves as the source of truth, with task keys, states, inputs, and outputs stored through hashes, sets, and lists; workers independently execute their own loops and coordinate through shared state rather than through a controller (Becker et al., 19 Jun 2026). The large-scale ADBO system for the Polaris supercomputer uses the same principle, but abstracts the storage and compute backends so that threads, processes, MPI, Ray, local memory, Redis, Ray actors, or databases can be used (Egele et al., 2022).

A different decentralized pattern appears in Bayes-Swarm. There is no central planner selecting the full batch of robotic actions. Each robot collects observations along its path, updates its local GP model, receives peers’ reported data and planned waypoints, chooses its next waypoint by maximizing an acquisition function, and then moves. Planning occurs when a robot reaches a waypoint rather than at globally synchronized times, so decision epochs differ across robots and peer plans may be stale or partially known (Ghassemi et al., 2019).

Remote asynchronous BO frameworks can also be ADBO-adjacent without being fully decentralized. PARyOpt is organized around an asynchronous evaluator that classifies evaluations as completed, pending, or failed, supports local or remote execution, and never waits for previously pending jobs before moving forward. The paper frames this as asynchronous data assimilation for remote and HPC environments, with explicit job-state handling rather than central batch synchronization (Pokuri et al., 2018).

These execution models share a common objective: eliminate synchronization barriers and reduce idle time. Their differences lie in whether coordination is mediated by shared storage, peer broadcasts, pending-job lists, or a remaining controller process. A plausible implication is that “decentralized” in BO is best treated as an architectural spectrum rather than a binary label.

3. Surrogate models, acquisition rules, and diversification mechanisms

ADBO does not prescribe a single surrogate or acquisition family. The large-scale hyperparameter optimization formulation in (Egele et al., 2022) uses a random forest regressor (RFR) rather than a Gaussian process, motivated by scalability and support for mixed parameter types $x=(x_I,x_R,x_C)$. Point selection uses

$UCB(x) = \mu(x) + \kappa \cdot \sigma(x),$

with worker-specific exploration coefficients drawn from

$$\kappa_0 \sim \mathrm{Exp}\!\left(\frac{1}{\kappa}\right),$$

and periodically decayed according to

$$\kappa_{\lambda,T}(t;\kappa_0) = \kappa_0 \cdot \exp(-\lambda \cdot (t \bmod T)).$$

This creates a population of local BO processes with heterogeneous exploration–exploitation behavior (Egele et al., 2022).

The rush implementation demonstrates a closely related design, but with a lower confidence bound objective

$\hat\mu(x) - \lambda \hat\sigma(x),$

where each worker draws its own $\lambda \sim \mathrm{Exp}(1)$ once at startup. Running tasks are imputed with the mean of completed observations, a random forest surrogate is fitted with ranger, and the next candidate is selected by minimizing the lower confidence bound over 1,000 uniformly sampled candidate points (Becker et al., 19 Jun 2026).

The TPE-inspired asynchronous parallel method of (Nomura, 2020) replaces deterministic acquisition maximization with probabilistic sampling. Rather than maximize $l(x)/g(x)$ as in standard TPE, it samples from

$$p(y<y^*\mid \mathbf{x})= \frac{\gamma l(\mathbf{x})}{\gamma l(\mathbf{x})+(1-\gamma)g(\mathbf{x})},$$

using rejection sampling and hierarchical one-dimensional kernel density estimation. The stated rationale is that deterministic maximization can cause multiple workers to pursue very similar locations, whereas probabilistic sampling spreads workers across promising regions (Nomura, 2020).

In GP-based asynchronous BO, Thompson sampling remains a canonical baseline. Asynchronous parallel TS samples a function from the current posterior whenever a worker finishes and dispatches the maximizer of that sample to the freed worker, without hallucinating outcomes for points still under evaluation (Kandasamy et al., 2017). In Bayes-Swarm, the acquisition is instead adapted to motion-constrained search:

$$\mathbf{x}^{k_r+1}_r = \arg\max_{\mathbf{x}\in\mathcal X} \Big(\alpha \,\Omega_r + (1-\alpha)\beta \,\Sigma_r\Big)\Gamma_r,$$

where $x=(x_I,x_R,x_C)$0 is exploitation toward the current estimated source maximum, $x=(x_I,x_R,x_C)$1 integrates posterior uncertainty along the trajectory, and $x=(x_I,x_R,x_C)$2 is a local penalization factor for peer waypoints (Ghassemi et al., 2019).

4. Pending evaluations, asynchrony semantics, and the role of diversity penalties

Handling pending evaluations is one of the central technical differentiators among ADBO variants. In asynchronous TS, points that are still being evaluated are simply ignored when choosing the next point; the method updates the posterior only from completed observations and then samples a new function for the freed worker (Kandasamy et al., 2017). The TPE-style asynchronous method in (Nomura, 2020) follows a similarly simple philosophy: no batch waiting, no explicit pending-point correction, no worker synchronization beyond the event “when a worker becomes free,” and no fantasizing or hallucinated outcomes.

Other systems do account for running evaluations. In the shared-state ADBO implementation over rush, workers fetch the archive of both running and finished tasks, impute fake objective values for running points, fit a local surrogate, and then propose a new candidate (Becker et al., 19 Jun 2026). Bayes-Swarm handles future interactions through local penalization rather than through centralized joint batch optimization: each robot penalizes regions near peers’ planned waypoints via a multiplicative factor

$x=(x_I,x_R,x_C)$3

which acts as a soft exclusion zone (Ghassemi et al., 2019).

A recent controversy concerns whether asynchronous BO requires explicit diversity enforcement at all. “Standard Acquisition Is Sufficient for Asynchronous Bayesian Optimization” argues that the usual premise behind local penalization, Kriging Believer, expected EI, and related methods is misguided because it neglects intermediate posterior updates. In the asynchronous loop, once a worker finishes at $x=(x_I,x_R,x_C)$4, the dataset becomes $x=(x_I,x_R,x_C)$5, the GP is updated, and the next point is chosen under the new posterior. The paper argues that the local change in posterior mean, variance, and sometimes kernel hyperparameters is generally sufficient to avoid redundant queries, and that penalization of busy locations can force over-exploration (Riegler et al., 13 Mar 2026). This claim does not imply that busy-point handling is never useful; rather, it narrows the circumstances under which explicit repulsion appears necessary.

The semantics of “asynchronous” also vary. In strict event-driven ADBO, workers act whenever they become free. In ARCO-BO, by contrast, asynchrony is budget-driven and frequency-based:

$x=(x_I,x_R,x_C)$6

so agents sample only when $x=(x_I,x_R,x_C)$7. The paper explicitly notes that this is not asynchronous in the strongest distributed-systems sense of delayed message handling, lock-free updates, or event-triggered communication with arbitrary lag (Wang et al., 18 Oct 2025).

5. Theoretical guarantees, complexity, and scalability regimes

Theoretical analyses of asynchronous BO focus on the trade-off between missing feedback and wall-clock efficiency. For asynchronous and synchronous Thompson sampling, the Bayes simple regret after $x=(x_I,x_R,x_C)$8 evaluations is of the same order as sequential TS up to a missing-feedback factor $x=(x_I,x_R,x_C)$9:

$UCB(x) = \mu(x) + \kappa \cdot \sigma(x),$0

where $UCB(x) = \mu(x) + \kappa \cdot \sigma(x),$1 is the maximum information gain. The core interpretation given in (Kandasamy et al., 2017) is that distributing $UCB(x) = \mu(x) + \kappa \cdot \sigma(x),$2 evaluations among $UCB(x) = \mu(x) + \kappa \cdot \sigma(x),$3 workers is essentially equivalent to performing $UCB(x) = \mu(x) + \kappa \cdot \sigma(x),$4 sequential evaluations, up to multiplicative constants. When elapsed time is the resource, asynchronous TS becomes asymptotically preferable because it completes more evaluations than synchronous TS under random evaluation times such as uniform, half-normal, and exponential models (Kandasamy et al., 2017).

A related theoretical result appears in (Riegler et al., 13 Mar 2026) for standard asynchronous UCB. The paper derives a Bayes simple regret bound

$UCB(x) = \mu(x) + \kappa \cdot \sigma(x),$5

and emphasizes that its asymptotic form is essentially the same as that of asynchronous TS. A further proposition shows that the expectation of UCB over unknown busy outputs equals the Kriging Believer heuristic for UCB. The significance of these results is methodological: randomness or busy-location penalties are not required to obtain strong asymptotic guarantees in asynchronous BO (Riegler et al., 13 Mar 2026).

On the computational side, complexity arguments are decisive for large-scale ADBO. The TPE-style asynchronous method of (Nomura, 2020) emphasizes linear time complexity inherited from TPE and contrasts it with the cubic complexity of many GP-based asynchronous BO methods. The RFR-based ADBO formulation of (Egele et al., 2022) likewise contrasts GP fitting at $UCB(x) = \mu(x) + \kappa \cdot \sigma(x),$6 with random-forest fitting at

$UCB(x) = \mu(x) + \kappa \cdot \sigma(x),$7

These choices are not only surrogate substitutions; they are scalability mechanisms that permit each worker to refit a local model without overwhelming the system.

The systems literature adds a separate notion of scalability: coordination overhead. rush reports sub-millisecond per-task overhead, efficient caching of finished tasks, automatic detection of lost workers, and explicit failure handling, all of which are necessary when the archive and worker count become large (Becker et al., 19 Jun 2026). A plausible implication is that ADBO performance is determined jointly by surrogate complexity and coordination-layer latency.

6. Empirical behavior and application domains

ADBO has been evaluated in hyperparameter optimization, synthetic black-box benchmarks, remote HPC optimization, and decentralized swarm robotics. The dominant empirical pattern is that centralized BO can remain sample-efficient at modest worker counts, while asynchronous decentralized designs improve utilization and wall-clock effectiveness as scale increases (Egele et al., 2022, Becker et al., 19 Jun 2026).

System	Coordination model	Reported finding
ADBO for CANDLE/Polaris (Egele et al., 2022)	Shared-storage, worker-local sequential BO	above 95% worker utilization at 1,920 workers
rush ADBO on LightGBM (Becker et al., 19 Jun 2026)	Redis shared state, no central scheduler	94–100% CPU utilization on 448 workers
TPE-style async BO (Nomura, 2020)	Worker-driven asynchronous parallel BO	competitive with Parallel-TS by evaluations, better in computation time
Bayes-Swarm (Ghassemi et al., 2019)	Decentralized asynchronous swarm BO	about 17× and 76× efficiency over exhaustive search baseline
PARyOpt (Pokuri et al., 2018)	Remote asynchronous evaluator	up to about 50% reduction in total optimization time on average

In the large-scale hyperparameter optimization study on Polaris, worker counts were increased from 40 to 160, 640, and 1,920. The abstract reports above $UCB(x) = \mu(x) + \kappa \cdot \sigma(x),$8 worker utilization at 1,920 workers, and the paper states that at that scale the decentralized method completed 29,222 evaluations versus 6,055 for centralized BO, while decentralized SHA completed 18,431 and centralized SHA 5,832. The same study reports that centralized BO is best in AURC at 40 workers, but from 160 to 1,920 workers ADBO consistently outperforms centralized BO in both AURC and minimum regret (Egele et al., 2022).

The rush benchmark on nine LightGBM hyperparameters across credit-g, KDDCup09_appetency, adult, and airlines used 448 workers on four nodes. Reported effective CPU utilization was $UCB(x) = \mu(x) + \kappa \cdot \sigma(x),$9 on credit-g, $$\kappa_0 \sim \mathrm{Exp}\!\left(\frac{1}{\kappa}\right),$$0 on KDDCup09_appetency, $$\kappa_0 \sim \mathrm{Exp}\!\left(\frac{1}{\kappa}\right),$$1 on adult, and $$\kappa_0 \sim \mathrm{Exp}\!\left(\frac{1}{\kappa}\right),$$2 on airlines, compared with single-digit or low-double-digit utilization for synchronous batch BO and asynchronous centralized BO. On credit-g, ADBO completed 15,451 evaluations within the 10-minute budget while centralized baselines remained below $$\kappa_0 \sim \mathrm{Exp}\!\left(\frac{1}{\kappa}\right),$$3 utilization (Becker et al., 19 Jun 2026).

At smaller scales, the TPE-style asynchronous parallel method was evaluated on the 18-dimensional Hartmann18 benchmark and on hyperparameter optimization of a two-layer MLP on Fashion-MNIST. With a 500-second budget, 4 workers, and 10 trials, the method showed comparable performance to Parallel-TS in number of evaluations and better performance in wall-clock computation time on both tasks (Nomura, 2020). In PARyOpt, decreasing the blocking fraction in remote asynchronous evaluation reduced total optimization time by up to about $$\kappa_0 \sim \mathrm{Exp}\!\left(\frac{1}{\kappa}\right),$$4 on average, while preserving worst-case times similar to more synchronous settings (Pokuri et al., 2018).

In robotics, Bayes-Swarm was tested on a smaller arena with a bimodal signal field and a larger arena with a highly multimodal field. The paper reports reaching the source in 36 s with 180 downsampled measurements in Case 1, efficiency gains of about $$\kappa_0 \sim \mathrm{Exp}\!\left(\frac{1}{\kappa}\right),$$5 and $$\kappa_0 \sim \mathrm{Exp}\!\left(\frac{1}{\kappa}\right),$$6 relative to exhaustive search in the two cases, and better performance of the asynchronous variant in the more complex environment (Ghassemi et al., 2019).

7. Terminological boundaries, misconceptions, and related directions

Several misconceptions recur in discussions of ADBO. One is that asynchronous BO is inherently decentralized. The literature does not support that equivalence. Asynchronous parallel BO can be worker-driven yet still depend on a central archive or manager; (Nomura, 2020) explicitly does not present a fully decentralized multi-agent coordination protocol. Conversely, decentralization can be realized through shared storage rather than purely peer-to-peer messaging, as in (Egele et al., 2022) and (Becker et al., 19 Jun 2026). The decisive property is the absence of a central optimization scheduler, not the absence of any shared infrastructure.

A second misconception is that asynchronous BO must explicitly repel workers from busy locations. That premise motivates local penalization, hallucination, and expected-acquisition methods, but (Riegler et al., 13 Mar 2026) argues that intermediate posterior updates are often enough to avoid redundant queries and that penalization can over-explore. This position should be read as a correction to a common design assumption rather than a universal prohibition on diversity mechanisms.

A third boundary concerns the meaning of “decentralized” in multi-agent BO. Bayes-Swarm is decentralized because there is no central planner and each robot chooses its own next waypoint from locally available information and peer broadcasts (Ghassemi et al., 2019). ARCO-BO is ADBO-like, but only in a qualified sense: agents maintain local GPs and use budget-aware asynchronous sampling, yet the method still relies on a global iteration loop, scheduled consensus updates, and does not provide delayed/stale message handling, lock-free updates, or formal convergence theorems for asynchronous operation (Wang et al., 18 Oct 2025). The paper therefore fits better under heterogeneous collaborative BO than under textbook event-driven ADBO.

The broader significance of ADBO is that it changes the design criterion for BO under extreme parallelism. At small worker counts, centralized batch BO may retain a sample-efficiency advantage. At hundreds or thousands of workers, the literature repeatedly reports that utilization, coordination overhead, and proposal-generation cost dominate, making asynchronous decentralized designs preferable in practice (Egele et al., 2022, Becker et al., 19 Jun 2026). This suggests that ADBO is less a single algorithm than a systems-level reorganization of BO around distributed decision-making, asynchronous completion times, and scalable coordination.