diff --git a/.Rbuildignore b/.Rbuildignore
index 63463781..f23c768d 100644
--- a/.Rbuildignore
+++ b/.Rbuildignore
@@ -1,3 +1,4 @@
+^benchmark$
 ^CRAN-RELEASE$
 ^.*\.Rproj$
 ^\.Rproj\.user$
diff --git a/.gitignore b/.gitignore
index 9c69942e..37d0b018 100644
--- a/.gitignore
+++ b/.gitignore
@@ -16,6 +16,7 @@ loo.Rproj
 # produced vignettes
 vignettes/loo2-lfo_cache/*
 vignettes/loo2-non-factorizable_cache/*
+vignettes/articles-online-only/*.html
 vignettes/*.html
 vignettes/*.pdf
 inst/doc
@@ -26,3 +27,7 @@ tests/testthat/Rplots.pdf
 cran-comments.md
 CRAN-RELEASE
 release-prep.R
+
+agent/*
+data/*
+scratch-files/*
\ No newline at end of file
diff --git a/DESCRIPTION b/DESCRIPTION
index 4b15bd82..3b8c3234 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -37,6 +37,8 @@ Depends:
 Imports:
     checkmate,
     matrixStats (>= 0.52),
+    mirai,
+    mori,
     parallel,
     posterior (>= 1.7.0),
     stats
@@ -62,3 +64,4 @@ LazyData: TRUE
 Roxygen: list(markdown = TRUE)
 SystemRequirements: pandoc (>= 1.12.3), pandoc-citeproc
 Config/roxygen2/version: 8.0.0
+RoxygenNote: 7.3.3
diff --git a/NAMESPACE b/NAMESPACE
index 3405d737..562c6a24 100644
--- a/NAMESPACE
+++ b/NAMESPACE
@@ -130,6 +130,7 @@ export(loo_approximate_posterior.matrix)
 export(loo_compare)
 export(loo_crps)
 export(loo_i)
+export(loo_mirai)
 export(loo_model_weights)
 export(loo_model_weights.default)
 export(loo_moment_match)
diff --git a/NEWS.md b/NEWS.md
index d998539c..c8137a14 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -1,5 +1,17 @@
 # loo (development version)
 
+* Parallelization with **mirai**: user-managed `mirai::daemons()` pools,
+  new `loo_mirai()` convenience wrapper for map-style workflows, and deprecated
+  per-call `cores` / `options(mc.cores)` bridges.
+* The `cores` argument and `options(mc.cores)` on loo functions are deprecated
+  and will be removed in a future release; they still start a per-call local
+  daemon pool when the resolved value is `> 1` and no pool is connected. A
+  once-per-session warning is emitted when `cores` is passed explicitly (even
+  `cores = 1`), when `options(mc.cores)` is set, or when the resolved value is
+  `> 1`.
+* Removed support for `options(loo.cores)`, which had been deprecated since
+  loo 2.x in favor of `options(mc.cores)`.
+
 # loo 2.10.0
 
 * Updates to `loo_compare` output by @jgabry, @avehtari, @florence-bockting in #300: 
diff --git a/R/effective_sample_sizes.R b/R/effective_sample_sizes.R
index 360a3098..6ee4f2a2 100644
--- a/R/effective_sample_sizes.R
+++ b/R/effective_sample_sizes.R
@@ -50,6 +50,7 @@ relative_eff.default <- function(x, chain_id, ...) {
 #' @template matrix
 #'
 relative_eff.matrix <- function(x, chain_id, ..., cores = getOption("mc.cores", 1)) {
+  cores <- loo_cores(cores, call = match.call())
   x <- llmatrix_to_array(x, chain_id)
   relative_eff.array(x, cores = cores)
 }
@@ -59,35 +60,33 @@ relative_eff.matrix <- function(x, chain_id, ..., cores = getOption("mc.cores",
 #' @template array
 #'
 relative_eff.array <- function(x, ..., cores = getOption("mc.cores", 1)) {
+  cores <- loo_cores(cores, call = match.call())
   stopifnot(length(dim(x)) == 3)
   S <- prod(dim(x)[1:2]) # posterior sample size = iter * chains
 
-  if (cores == 1) {
-    n_eff_vec <- apply(x, 3, posterior::ess_mean)
-  } else {
-    if (!os_is_windows()) {
-      n_eff_list <-
-        parallel::mclapply(
-          mc.cores = cores,
-          X = seq_len(dim(x)[3]),
-          FUN = function(i) posterior::ess_mean(x[, , i, drop = TRUE])
-        )
-    } else {
-      cl <- parallel::makePSOCKcluster(cores)
-      on.exit(parallel::stopCluster(cl))
-      n_eff_list <-
-        parallel::parLapply(
-          cl = cl,
-          X = seq_len(dim(x)[3]),
-          fun = function(i) posterior::ess_mean(x[, , i, drop = TRUE])
-        )
-    }
-    n_eff_vec <- unlist(n_eff_list, use.names = FALSE)
-  }
+  # The full draws array is reused across observations, so it is broadcast via
+  # shared memory on a local pool. Each worker reads only its slice `x[, , i]`.
+  n_eff_list <- with_loo_daemons(
+    cores,
+    loo_map(
+      seq_len(dim(x)[3]),
+      relative_eff_i_array,
+      cores = cores,
+      broadcast = list(x = x)
+    )
+  )
+  n_eff_vec <- unlist(n_eff_list, use.names = FALSE)
 
   return(n_eff_vec / S)
 }
 
+#' Worker computing `ess_mean()` for a single slice of a draws array
+#' @noRd
+#' @keywords internal
+relative_eff_i_array <- function(i, x) {
+  posterior::ess_mean(x[, , i, drop = TRUE])
+}
+
 #' @export
 #' @templateVar fn relative_eff
 #' @template function
@@ -100,50 +99,41 @@ relative_eff.function <-
            cores = getOption("mc.cores", 1),
            data = NULL,
            draws = NULL) {
+    cores <- loo_cores(cores, call = match.call())
 
     f_i <- validate_llfun(x) # not really an llfun, should return exp(ll) or exp(-ll)
     N <- dim(data)[1]
 
-    if (cores == 1) {
-      n_eff_list <-
-        lapply(
-          X = seq_len(N),
-          FUN = function(i) {
-            val_i <- f_i(data_i = data[i, , drop = FALSE], draws = draws, ...)
-            relative_eff.default(as.vector(val_i), chain_id = chain_id, cores = 1)
-          }
-        )
-    } else {
-      if (!os_is_windows()) {
-        n_eff_list <-
-          parallel::mclapply(
-            X = seq_len(N),
-            FUN = function(i) {
-              val_i <- f_i(data_i = data[i, , drop = FALSE], draws = draws, ...)
-              relative_eff.default(as.vector(val_i), chain_id = chain_id, cores = 1)
-            },
-            mc.cores = cores
-          )
-      } else {
-        cl <- parallel::makePSOCKcluster(cores)
-        parallel::clusterExport(cl=cl, varlist=c("draws", "chain_id", "data"), envir=environment())
-        on.exit(parallel::stopCluster(cl))
-        n_eff_list <-
-          parallel::parLapply(
-            cl = cl,
-            X = seq_len(N),
-            fun = function(i) {
-              val_i <- f_i(data_i = data[i, , drop = FALSE], draws = draws, ...)
-              relative_eff.default(as.vector(val_i), chain_id = chain_id, cores = 1)
-            }
-          )
-      }
-    }
+    # `data` and `draws` are reused for every observation, so they are broadcast
+    # via shared memory on a local pool and serialized on a remote pool.
+    n_eff_list <- with_loo_daemons(
+      cores,
+      loo_map(
+        seq_len(N),
+        relative_eff_i_function,
+        f_i = f_i,
+        chain_id = chain_id,
+        re_dots = list(...),
+        cores = cores,
+        broadcast = list(data = data, draws = draws)
+      )
+    )
 
     n_eff_vec <- unlist(n_eff_list, use.names = FALSE)
     return(n_eff_vec)
   }
 
+#' Worker computing the relative effective sample size for observation `i`
+#' @noRd
+#' @keywords internal
+relative_eff_i_function <- function(i, f_i, data, draws, chain_id, re_dots) {
+  val_i <- do.call(
+    f_i,
+    c(list(data_i = data[i, , drop = FALSE], draws = draws), re_dots)
+  )
+  relative_eff.default(as.vector(val_i), chain_id = chain_id, cores = 1)
+}
+
 #' @export
 #' @describeIn relative_eff
 #'   If `x` is an object of class `"psis"`, `relative_eff()` simply returns
diff --git a/R/helpers.R b/R/helpers.R
index 38b401dd..8d2fb382 100644
--- a/R/helpers.R
+++ b/R/helpers.R
@@ -171,14 +171,17 @@ nlist <- function(...) {
 }
 
 
-# Check how many cores to use and throw deprecation warning if loo.cores is used
-loo_cores <- function(cores) {
-  loo_cores_op <- getOption("loo.cores", NA)
-  if (!is.na(loo_cores_op) && (loo_cores_op != cores)) {
-    cores <- loo_cores_op
-    warning("'loo.cores' is deprecated, please use 'mc.cores' or pass 'cores' explicitly.",
-            call. = FALSE)
-  }
+# Check how many cores to use and throw deprecation warnings for legacy options
+loo_cores <- function(cores, call = NULL) {
+  explicit <- !is.null(call) && "cores" %in% names(call)
+  mc_cores_op <- getOption("mc.cores")
+  mc_cores_set <- !explicit && !is.null(mc_cores_op)
+
+  loo_deprecate_cores(
+    cores = cores,
+    explicit = explicit,
+    mc_cores_set = mc_cores_set
+  )
   return(cores)
 }
 
diff --git a/R/importance_sampling.R b/R/importance_sampling.R
index f8dfd4d3..0028a4d1 100644
--- a/R/importance_sampling.R
+++ b/R/importance_sampling.R
@@ -21,7 +21,7 @@ importance_sampling.array <-
            ...,
            r_eff = 1,
            cores = getOption("mc.cores", 1)) {
-    cores <- loo_cores(cores)
+    cores <- loo_cores(cores, call = match.call())
     stopifnot(length(dim(log_ratios)) == 3)
     assert_importance_sampling_method_is_implemented(method)
     log_ratios <- validate_ll(log_ratios)
@@ -38,7 +38,7 @@ importance_sampling.matrix <-
            ...,
            r_eff = 1,
            cores = getOption("mc.cores", 1)) {
-    cores <- loo_cores(cores)
+    cores <- loo_cores(cores, call = match.call())
     assert_importance_sampling_method_is_implemented(method)
     log_ratios <- validate_ll(log_ratios)
     r_eff <- prepare_psis_r_eff(r_eff, len = ncol(log_ratios))
@@ -198,29 +198,23 @@ do_importance_sampling <- function(log_ratios, r_eff, cores, method) {
     stop("Incorrect IS method.")
   }
 
-  if (cores == 1) {
-    lw_list <- lapply(seq_len(N), function(i)
-      is_fun(log_ratios_i = log_ratios[, i], tail_len_i = tail_len[i]))
-  } else {
-    if (!os_is_windows()) {
-      lw_list <- parallel::mclapply(
-        X = seq_len(N),
-        mc.cores = cores,
-        FUN = function(i)
-          is_fun(log_ratios_i = log_ratios[, i], tail_len_i = tail_len[i])
-      )
-    } else {
-      cl <- parallel::makePSOCKcluster(cores)
-      on.exit(parallel::stopCluster(cl))
-      lw_list <-
-        parallel::parLapply(
-          cl = cl,
-          X = seq_len(N),
-          fun = function(i)
-            is_fun(log_ratios_i = log_ratios[, i], tail_len_i = tail_len[i])
-        )
-    }
-  }
+  # Each observation needs a different column of `log_ratios`, but the whole
+  # matrix is reused across the map, so it is a broadcast object: `loo_map()`
+  # shares it via shared memory on a local pool (zero-copy column access) and
+  # falls back to serialization on a remote pool. Serial work runs as a plain
+  # lapply(). `with_loo_daemons()` provides a pool when this is the top-level
+  # call (e.g. psis()) and reuses an outer pool when called from loo().
+  lw_list <- with_loo_daemons(
+    cores,
+    loo_map(
+      seq_len(N),
+      do_is_i,
+      is_fun = is_fun,
+      tail_len = tail_len,
+      cores = cores,
+      broadcast = list(log_ratios = log_ratios)
+    )
+  )
 
   log_weights <- psis_apply(lw_list, "log_weights", fun_val = numeric(S))
   pareto_k <- psis_apply(lw_list, "pareto_k")
@@ -234,3 +228,24 @@ do_importance_sampling <- function(log_ratios, r_eff, cores, method) {
     method = rep(method, length(pareto_k)) # Conform to other attr that exist per obs.
   )
 }
+
+#' Apply an importance sampling method to a single observation
+#'
+#' @noRd
+#' @keywords internal
+#' @description
+#' Worker function mapped over observations (matrix columns) by
+#' `do_importance_sampling()`, either serially via [lapply()] or in parallel
+#' via [mirai::mirai_map()]. 
+#' @param i Integer column index of the observation to process.
+#' @param is_fun The per-observation importance sampling function to apply, one
+#'   of `do_psis_i()`, `do_tis_i()`, or `do_sis_i()`.
+#' @param log_ratios Matrix of log ratios (`-loglik`). May be a shared-memory
+#'   object created by [mori::share()] to avoid copying to each worker.
+#' @param tail_len Vector of tail lengths used to fit the GPD, one per
+#'   observation.
+#' @return The result of `is_fun` for observation `i` (a list with elements
+#'   such as `log_weights` and `pareto_k`).
+do_is_i <- function(i, is_fun, log_ratios, tail_len) {
+  is_fun(log_ratios_i = log_ratios[, i], tail_len_i = tail_len[i])
+}
\ No newline at end of file
diff --git a/R/loo.R b/R/loo.R
index 10b1bdc7..2d1a4ed0 100644
--- a/R/loo.R
+++ b/R/loo.R
@@ -257,7 +257,7 @@ loo.function <-
            cores = getOption("mc.cores", 1),
            is_method = c("psis", "tis", "sis")) {
     is_method <- match.arg(is_method)
-    cores <- loo_cores(cores)
+    cores <- loo_cores(cores, call = match.call())
     stopifnot(is.data.frame(data) || is.matrix(data), !is.null(draws))
     assert_importance_sampling_method_is_implemented(is_method)
     .llfun <- validate_llfun(x)
@@ -665,52 +665,23 @@ parallel_importance_sampling_list <- function(N, .loo_i, .llfun,
                                               data, draws, r_eff,
                                               save_psis, cores,
                                               method, ...){
-  if (cores == 1) {
-    psis_list <-
-      lapply(
-        X = seq_len(N),
-        FUN = .loo_i,
-        llfun = .llfun,
-        data = data,
-        draws = draws,
-        r_eff = r_eff,
-        save_psis = save_psis,
-        is_method = method,
-        ...
-      )
-  } else {
-    if (!os_is_windows()) {
-      # On Mac or Linux use mclapply() for multiple cores
-      psis_list <-
-        parallel::mclapply(
-          mc.cores = cores,
-          X = seq_len(N),
-          FUN = .loo_i,
-          llfun = .llfun,
-          data = data,
-          draws = draws,
-          r_eff = r_eff,
-          save_psis = save_psis,
-          is_method = method,
-          ...
-        )
-    } else {
-      # On Windows use makePSOCKcluster() and parLapply() for multiple cores
-      cl <- parallel::makePSOCKcluster(cores)
-      on.exit(parallel::stopCluster(cl))
-      psis_list <-
-        parallel::parLapply(
-          cl = cl,
-          X = seq_len(N),
-          fun = .loo_i,
-          llfun = .llfun,
-          data = data,
-          draws = draws,
-          r_eff = r_eff,
-          save_psis = save_psis,
-          is_method = method,
-          ...
-        )
-    }
-  }
+  # `draws` (and `data`) are reused identically for every observation, so they
+  # are broadcast objects: shared once via shared memory on a local pool
+  # (recovering the copy-on-write benefit fork gave the old mclapply() path)
+  # and serialized on a remote pool. A single cross-platform code path replaces
+  # the previous mclapply()/parLapply() branching.
+  with_loo_daemons(
+    cores,
+    loo_map(
+      seq_len(N),
+      .loo_i,
+      llfun = .llfun,
+      r_eff = r_eff,
+      save_psis = save_psis,
+      is_method = method,
+      ...,
+      cores = cores,
+      broadcast = list(data = data, draws = draws)
+    )
+  )
 }
diff --git a/R/loo_approximate_posterior.R b/R/loo_approximate_posterior.R
index 3a3bce09..6d24e8fb 100644
--- a/R/loo_approximate_posterior.R
+++ b/R/loo_approximate_posterior.R
@@ -47,6 +47,7 @@ loo_approximate_posterior.array <-
            ...,
            save_psis = FALSE,
            cores = getOption("mc.cores", 1)) {
+    cores <- loo_cores(cores, call = match.call())
     checkmate::assert_flag(save_psis)
     checkmate::assert_int(cores)
     checkmate::assert_matrix(log_p, mode = "numeric", nrows = dim(x)[1], ncols = dim(x)[2])
@@ -75,6 +76,7 @@ loo_approximate_posterior.matrix <-
            ...,
            save_psis = FALSE,
            cores = getOption("mc.cores", 1)) {
+    cores <- loo_cores(cores, call = match.call())
     checkmate::assert_flag(save_psis)
     checkmate::assert_int(cores)
     checkmate::assert_numeric(log_p, len = nrow(x))
@@ -117,7 +119,7 @@ loo_approximate_posterior.function <-
 
     checkmate::assert_numeric(log_p, len = length(log_g))
     checkmate::assert_numeric(log_g, len = length(log_p))
-    cores <- loo_cores(cores)
+    cores <- loo_cores(cores, call = match.call())
     stopifnot(is.data.frame(data) || is.matrix(data), !is.null(draws))
     .llfun <- validate_llfun(x)
     N <- dim(data)[1]
diff --git a/R/loo_model_weights.R b/R/loo_model_weights.R
index 946dc7c3..4abc26c0 100644
--- a/R/loo_model_weights.R
+++ b/R/loo_model_weights.R
@@ -180,7 +180,7 @@ loo_model_weights.default <-
            r_eff_list = NULL,
            cores = getOption("mc.cores", 1)) {
 
-    cores <- loo_cores(cores)
+    cores <- loo_cores(cores, call = match.call())
     method <- match.arg(method)
     K <- length(x) # number of models
 
@@ -188,15 +188,24 @@ loo_model_weights.default <-
       N <- ncol(x[[1]]) # number of data points
       validate_log_lik_list(x)
       validate_r_eff_list(r_eff_list, K, N)
-      lpd_point <- matrix(NA, N, K)
-      elpd_loo <- rep(NA, K)
-      for (k in 1:K) {
-        r_eff_k <- r_eff_list[[k]] # possibly NULL
-        log_likelihood <- x[[k]]
-        loo_object <- loo(log_likelihood, r_eff = r_eff_k, cores = cores)
-        lpd_point[, k] <- loo_object$pointwise[, "elpd_loo"]    #calculate log(p_k (y_i | y_-i))
-        elpd_loo[k] <- loo_object$estimates["elpd_loo", "Estimate"]
-      }
+      # Establish a single daemon pool for all K models so each inner loo()
+      # reuses it instead of spinning a pool up and down K times.
+      loo_objects <- with_loo_daemons(
+        cores,
+        lapply(seq_len(K), function(k) {
+          loo(x[[k]], r_eff = r_eff_list[[k]], cores = cores)
+        })
+      )
+      lpd_point <- vapply(
+        loo_objects,
+        function(o) o$pointwise[, "elpd_loo"], #calculate log(p_k (y_i | y_-i))
+        FUN.VALUE = numeric(N)
+      )
+      elpd_loo <- vapply(
+        loo_objects,
+        function(o) o$estimates["elpd_loo", "Estimate"],
+        FUN.VALUE = numeric(1)
+      )
     } else if (is.psis_loo(x[[1]])) {
       validate_psis_loo_list(x)
       lpd_point <- do.call(cbind, lapply(x, function(obj) obj$pointwise[, "elpd_loo"]))
diff --git a/R/loo_moment_matching.R b/R/loo_moment_matching.R
index 110eff93..67b9625d 100644
--- a/R/loo_moment_matching.R
+++ b/R/loo_moment_matching.R
@@ -81,6 +81,7 @@ loo_moment_match.default <- function(x, loo, post_draws, log_lik_i,
   checkmate::assertNumber(k_threshold, null.ok=TRUE)
   checkmate::assertLogical(split)
   checkmate::assertLogical(cov)
+  cores <- loo_cores(cores, call = match.call())
   checkmate::assertNumber(cores)
 
 
@@ -111,32 +112,27 @@ loo_moment_match.default <- function(x, loo, post_draws, log_lik_i,
   kfs <- rep(0,N)
   I <- which(ks > k_threshold)
 
-  loo_moment_match_i_fun <- function(i) {
-    loo_moment_match_i(i = i, x = x, log_lik_i = log_lik_i,
-                       unconstrain_pars = unconstrain_pars,
-                       log_prob_upars = log_prob_upars,
-                       log_lik_i_upars = log_lik_i_upars,
-                       max_iters = max_iters, k_threshold = k_threshold,
-                       split = split, cov = cov, N = N, S = S, upars = upars,
-                       orig_log_prob = orig_log_prob, k = ks[i],
-                       is_method = is_method, npars = npars, ...)
-  }
-
-  if (cores == 1) {
-    mm_list <- lapply(X = I, FUN = function(i) loo_moment_match_i_fun(i))
-  }
-  else {
-    if (!os_is_windows()) {
-      mm_list <- parallel::mclapply(X = I, mc.cores = cores,
-                                    FUN = function(i) loo_moment_match_i_fun(i))
-    }
-    else {
-      cl <- parallel::makePSOCKcluster(cores)
-      on.exit(parallel::stopCluster(cl))
-      mm_list <- parallel::parLapply(cl = cl, X = I,
-                                    fun = function(i) loo_moment_match_i_fun(i))
-    }
-  }
+  # The large unconstrained-draws matrix `upars` and the `orig_log_prob` vector
+  # are reused for every high-Pareto-k observation, so they are broadcast via
+  # shared memory on a local pool. The worker is the namespace-level
+  # `loo_moment_match_i_worker()` (rather than a closure over this frame) so the
+  # broadcast objects are not also dragged along inside a captured environment.
+  mm_list <- with_loo_daemons(
+    cores,
+    loo_map(
+      I,
+      loo_moment_match_i_worker,
+      x = x, ks = ks, log_lik_i = log_lik_i,
+      unconstrain_pars = unconstrain_pars,
+      log_prob_upars = log_prob_upars,
+      log_lik_i_upars = log_lik_i_upars,
+      max_iters = max_iters, k_threshold = k_threshold,
+      split = split, cov = cov, N = N, S = S,
+      is_method = is_method, npars = npars, mm_dots = list(...),
+      cores = cores,
+      broadcast = list(upars = upars, orig_log_prob = orig_log_prob)
+    )
+  )
 
   # update results
   for (ii in seq_along(I)) {
@@ -230,6 +226,46 @@ loo_moment_match.default <- function(x, loo, post_draws, log_lik_i,
 #' @param ... Further arguments passed to the custom functions documented above.
 #' @return List with the updated elpd values and diagnostics
 #'
+#' Worker wrapper around `loo_moment_match_i()`` for parallel mapping
+#'
+#' @noRd
+#' @keywords internal
+#' @description
+#' A namespace-level (non-closure) adapter mapped over high-Pareto-k
+#' observation indices by `loo_map()`. Keeping it at namespace scope means it
+#' does not capture the calling frame, so large objects shared via
+#' [mori::share()] (`upars`, `orig_log_prob`) are not duplicated inside a
+#' serialized closure environment. The per-observation Pareto k is selected
+#' here from the full `ks` vector, and any extra arguments are forwarded
+#' through `mm_dots`.
+#' @param i Integer observation index.
+#' @param ks Full vector of Pareto k estimates; `ks[i]` is used for this fold.
+#' @param mm_dots A list of additional arguments forwarded to
+#'   `loo_moment_match_i()` (the `...` from [loo_moment_match()]).
+#' @return The result of `loo_moment_match_i()` for observation `i`.
+loo_moment_match_i_worker <- function(i, x, ks, log_lik_i, unconstrain_pars,
+                                      log_prob_upars, log_lik_i_upars,
+                                      max_iters, k_threshold, split, cov,
+                                      N, S, upars, orig_log_prob, is_method,
+                                      npars, mm_dots) {
+  do.call(
+    loo_moment_match_i,
+    c(
+      list(
+        i = i, x = x, log_lik_i = log_lik_i,
+        unconstrain_pars = unconstrain_pars,
+        log_prob_upars = log_prob_upars,
+        log_lik_i_upars = log_lik_i_upars,
+        max_iters = max_iters, k_threshold = k_threshold,
+        split = split, cov = cov, N = N, S = S, upars = upars,
+        orig_log_prob = orig_log_prob, k = ks[i],
+        is_method = is_method, npars = npars
+      ),
+      mm_dots
+    )
+  )
+}
+
 loo_moment_match_i <- function(i,
                                x,
                                log_lik_i,
diff --git a/R/loo_subsample.R b/R/loo_subsample.R
index bcac4b17..d5c17e70 100644
--- a/R/loo_subsample.R
+++ b/R/loo_subsample.R
@@ -117,7 +117,7 @@ loo_subsample.function <-
            estimator = "diff_srs",
            llgrad = NULL,
            llhess = NULL) {
-    cores <- loo_cores(cores)
+    cores <- loo_cores(cores, call = match.call())
     # Asserting inputs
     .llfun <- validate_llfun(x)
     stopifnot(is.data.frame(data) || is.matrix(data), !is.null(draws))
@@ -133,7 +133,6 @@ loo_subsample.function <-
         r_eff <- prepare_psis_r_eff(r_eff, len = dim(data)[1])
     }
     checkmate::assert_flag(save_psis)
-    cores <- loo_cores(cores)
 
     checkmate::assert_choice(loo_approximation, choices = loo_approximation_choices(), null.ok = FALSE)
     checkmate::assert_int(loo_approximation_draws, lower = 1, upper = .ndraws(draws), null.ok = TRUE)
@@ -276,7 +275,7 @@ update.psis_loo_ss <- function(object, ...,
   if (!is.null(draws)) {
     # No current checks
   }
-  cores <- loo_cores(cores)
+  cores <- loo_cores(cores, call = match.call())
 
   # Update elpd approximations
   if (!is.null(loo_approximation) | !is.null(loo_approximation_draws)) {
@@ -494,17 +493,18 @@ lpd_i <- function(i, llfun, data, draws) {
 #' @noRd
 #' @return a vector of computed log probability densities
 compute_lpds <- function(N, data, draws, llfun, cores) {
-  if (cores == 1) {
-    lpds <- lapply(X = seq_len(N), FUN = lpd_i, llfun, data, draws)
-  } else {
-    if (.Platform$OS.type != "windows") {
-      lpds <- mclapply(X = seq_len(N), mc.cores = cores, FUN = lpd_i, llfun, data, draws)
-    } else {
-      cl <- makePSOCKcluster(cores)
-      on.exit(stopCluster(cl))
-      lpds <- parLapply(cl, X = seq_len(N), fun = lpd_i, llfun, data, draws)
-    }
-  }
+  # `draws` (and `data`) are reused for every observation, so they are shared
+  # once via shared memory on a local pool and serialized on a remote pool.
+  lpds <- with_loo_daemons(
+    cores,
+    loo_map(
+      seq_len(N),
+      lpd_i,
+      llfun = llfun,
+      cores = cores,
+      broadcast = list(data = data, draws = draws)
+    )
+  )
 
   unlist(lpds)
 }
diff --git a/R/parallel.R b/R/parallel.R
new file mode 100644
index 00000000..93bb4b6b
--- /dev/null
+++ b/R/parallel.R
@@ -0,0 +1,382 @@
+#' Package-internal state for the parallel backend
+#'
+#' @noRd
+#' @keywords internal
+#' @description
+#' Holds small bits of session-scoped state used by the parallel helpers:
+#'
+#' * `informed_cores_ignored`: guards the "a pool is connected so `cores` is
+#'   ignored" message in `with_loo_daemons()` so it is only emitted once per
+#'   session.
+#' * `warned_cores_deprecated`: guards the `cores` argument deprecation warning
+#'   in `loo_deprecate_cores()` so it is only emitted once per session.
+#' * `warned_cores_in_mirai`: guards the `cores`-in-`args_list` warning in
+#'   `loo_mirai()` so it is only emitted once per session.
+#'
+#' It also serves as the object attached to session-scoped parallel state.
+.loo_internal <- new.env(parent = emptyenv())
+
+#' Inform (once per session) that `cores` is ignored while a pool is connected
+#'
+#' @noRd
+#' @keywords internal
+#' @description
+#' Emitted by `with_loo_daemons()` when a mirai daemon pool is connected (e.g.
+#' the user called [mirai::daemons()] themselves) and the current call passed
+#' `cores <= 1`. When a pool is connected loo always uses it, so the `cores`
+#' argument is ignored and the work runs in parallel regardless of its value.
+#' This message makes that behaviour visible the
+#' first time a call looks like it asked for serial execution; the usual cause
+#' is relying on the default `cores = getOption("mc.cores", 1)` after setting
+#' up daemons.
+loo_inform_cores_ignored <- function() {
+  if (isTRUE(.loo_internal$informed_cores_ignored)) {
+    return(invisible(NULL))
+  }
+  .loo_internal$informed_cores_ignored <- TRUE
+  message(
+    "A mirai daemon pool is connected, so 'cores' is ignored and this call ",
+    "runs in parallel on the existing pool. Call mirai::daemons(0) to stop ",
+    "the pool if you want serial execution."
+  )
+  invisible(NULL)
+}
+
+#' Warn (once per session) that the `cores` argument is deprecated
+#'
+#' @noRd
+#' @keywords internal
+#' @description
+#' Emitted from `loo_cores()` when the user passes `cores` explicitly (even
+#' `cores = 1`), when `options(mc.cores)` is set, or when the resolved value
+#' is `cores > 1`. The argument/option still works for now by starting a scoped
+#' local [mirai::daemons()] pool when `cores > 1`, but users should migrate to
+#' [mirai::daemons()] or [loo_mirai()].
+#' @param cores Integer number of cores requested by the user.
+#' @param explicit Whether `cores` was passed explicitly by the user.
+#' @param mc_cores_set Whether `options(mc.cores)` is set and `cores` was not
+#'   passed explicitly.
+loo_deprecate_cores <- function(cores, explicit = FALSE, mc_cores_set = FALSE) {
+  if (!explicit && !mc_cores_set && cores <= 1L) {
+    return(invisible(NULL))
+  }
+  if (isTRUE(.loo_internal$warned_cores_deprecated)) {
+    return(invisible(NULL))
+  }
+  .loo_internal$warned_cores_deprecated <- TRUE
+  warning(
+    "The 'cores' argument and options('mc.cores') are deprecated and will be ",
+    "removed in a future release. For one-off parallel calls, 'cores' / ",
+    "'mc.cores' currently start a per-call local daemon pool when > 1; use ",
+    "mirai::daemons() before calling loo functions, or loo_mirai(..., ",
+    "n_daemons = k) for map-style workflows over many models.",
+    call. = FALSE
+  )
+  invisible(NULL)
+}
+
+#' Warn (once per session) about `cores` in `loo_mirai()` `args_list`
+#'
+#' @noRd
+#' @keywords internal
+loo_deprecate_cores_in_mirai <- function() {
+  if (isTRUE(.loo_internal$warned_cores_in_mirai)) {
+    return(invisible(NULL))
+  }
+  .loo_internal$warned_cores_in_mirai <- TRUE
+  warning(
+    "Passing 'cores' in args_list to loo_mirai() is deprecated and ignored. ",
+    "Parallelism is controlled by loo_mirai() via n_daemons or an existing ",
+    "mirai::daemons() pool.",
+    call. = FALSE
+  )
+  invisible(NULL)
+}
+
+#' Prepare argument lists for [loo_mirai()] map jobs
+#'
+#' @noRd
+#' @keywords internal
+#' @description
+#' Strips any user-supplied `cores` element (with a deprecation warning) and
+#' forces `cores = 1` so each mapped job runs serially on its worker. Outer
+#' parallelism comes only from `loo_mirai()` itself.
+loo_mirai_prepare_args <- function(args) {
+  if ("cores" %in% names(args)) {
+    loo_deprecate_cores_in_mirai()
+    args$cores <- NULL
+  }
+  args$cores <- 1L
+  args
+}
+
+#' Evaluate parallel work with an appropriate mirai daemon pool
+#'
+#' @noRd
+#' @keywords internal
+#' @description
+#' Central entry point used by loo's parallel code paths to ensure a
+#' [mirai::daemons()] pool exists for the duration of a computation. It is
+#' deliberately a good citizen of the user's session:
+#'
+#' * A daemon pool is already connected (e.g. the user called
+#'   [mirai::daemons()] themselves, possibly with remote/HPC daemons): `code`
+#'   runs on the existing pool, which is left untouched. **A connected pool
+#'   always wins**, so the `cores` argument is ignored entirely in this case.
+#'   If `cores <= 1` here -- i.e. the call looked like it requested serial
+#'   execution -- a one-time-per-session message notes that `cores` is being
+#'   ignored (via `loo_inform_cores_ignored()`).
+#' * `cores <= 1` with no pool connected: runs `code` serially without touching
+#'   daemons.
+#' * Otherwise: a pool of `cores` local daemons is created for the duration of
+#'   `code` and automatically reset afterwards (via the scoped
+#'   `with(mirai::daemons(), ...)` method), so no daemon processes are left
+#'   running once the call returns.
+#'
+#' This keeps a single pool alive across the whole top-level computation
+#' (rather than spinning daemons up and down for each unit of work) while
+#' respecting any pool the user has already declared. Because it reuses an
+#' existing pool, it is safe to nest: an inner call made while an outer call
+#' already established a pool simply reuses it instead of creating another.
+#'
+#' @param cores Integer number of cores requested by the user. When no pool is
+#'   connected this is the per-call "enable parallel" switch (and the size of
+#'   the ephemeral pool). When a pool is already connected it is ignored --
+#'   loo always uses the connected pool.
+#' @param code Expression to evaluate. Lazily evaluated in the calling
+#'   environment, after any daemon pool has been set up.
+#' @return The value of `code`.
+with_loo_daemons <- function(cores, code) {
+  if (loo_has_pool()) {
+    if (cores <= 1) {
+      loo_inform_cores_ignored()
+    }
+    return(code)
+  }
+  if (cores <= 1) {
+    return(code)
+  }
+  with(mirai::daemons(cores), code)
+}
+
+#' Run a \pkg{loo} function over argument lists in parallel with mirai
+#'
+#' Intended for map-style workflows such as computing [loo()], [psis()], or
+#' other \pkg{loo} functions for many models in one session.
+#'
+#' @param fun A \pkg{loo} function (e.g. [loo()], [psis()]) to apply to each
+#'   element of `args_list`.
+#' @param args_list A list of lists. Each element is passed to `fun` via
+#'   `do.call(fun, element)`.
+#' @param n_daemons Number of local daemons to start for this call. When
+#'   `NULL` (the default), an existing [mirai::daemons()] pool is reused if
+#'   connected; otherwise the work runs serially. When an integer `>= 2`, a
+#'   local pool of that size is created for the duration of the call and
+#'   torn down automatically when it returns (unless a pool was already
+#'   connected, in which case it is reused and left untouched).
+#' @return A list of results in the same order as `args_list`.
+#' @details Parallelism is controlled by `loo_mirai()` (via `n_daemons` or an
+#'   existing daemon pool), not by a `cores` argument on the mapped calls.
+#'   Any `cores` element in `args_list` is deprecated, ignored, and replaced
+#'   with `cores = 1` so each job runs serially on its worker.
+#' @export
+#' @examples
+#' r_eff <- relative_eff(exp(example_loglik_array()))
+#' ll_list <- list(example_loglik_matrix(), example_loglik_matrix())
+#' args_list <- lapply(ll_list, function(LL) {
+#'   list(log_ratios = -LL, r_eff = r_eff)
+#' })
+#'
+#' # Serial when no pool is connected and n_daemons is NULL
+#' loo_mirai(psis, args_list)
+#'
+#' \dontrun{
+#' # Convenience wrapper: start workers, map, tear down
+#' loo_mirai(psis, args_list, n_daemons = 2)
+#'
+#' # Or manage the pool yourself and call loo functions directly
+#' mirai::daemons(4)
+#' loo_mirai(loo, lapply(ll_list, function(LL) {
+#'   list(x = LL, r_eff = r_eff)
+#' }))
+#' mirai::daemons(0)
+#' }
+loo_mirai <- function(fun, args_list, n_daemons = NULL) {
+  if (!is.function(fun)) {
+    stop("'fun' must be a function.", call. = FALSE)
+  }
+  if (!identical(environment(fun), asNamespace("loo"))) {
+    stop(
+      "'fun' must be a loo function (e.g. loo(), psis()).",
+      call. = FALSE
+    )
+  }
+  if (!is.list(args_list)) {
+    stop("'args_list' must be a list.", call. = FALSE)
+  }
+
+  run_map <- function() {
+    prepared <- lapply(args_list, loo_mirai_prepare_args)
+    if (!loo_has_pool()) {
+      return(lapply(prepared, function(a) do.call(fun, a)))
+    }
+    mirai::mirai_map(
+      prepared,
+      function(.args, .fun) do.call(.fun, .args),
+      .args = list(.fun = fun)
+    )[mirai::.stop]
+  }
+
+  if (!is.null(n_daemons)) {
+    n_daemons <- as.integer(n_daemons)
+    if (length(n_daemons) != 1L || is.na(n_daemons) || n_daemons < 1L) {
+      stop(
+        "'n_daemons' must be a single positive integer or NULL.",
+        call. = FALSE
+      )
+    }
+    if (n_daemons == 1L || loo_has_pool()) {
+      return(run_map())
+    }
+    return(with(mirai::daemons(n_daemons), run_map()))
+  }
+
+  run_map()
+}
+
+#' Is a mirai daemon pool currently connected?
+#'
+#' @noRd
+#' @keywords internal
+#' @return `TRUE` if at least one daemon connection exists for the active
+#'   compute profile, otherwise `FALSE`.
+loo_has_pool <- function() {
+  conns <- tryCatch(mirai::status()$connections, error = function(e) 0L)
+  isTRUE(as.integer(conns) > 0L)
+}
+
+#' Number of workers available for chunking decisions
+#'
+#' @noRd
+#' @keywords internal
+#' @description
+#' Returns the number of connected daemons when a pool exists (so chunking
+#' matches the actual worker count, including user-supplied or remote pools),
+#' otherwise falls back to the requested `cores`.
+#' @param cores Integer number of cores requested by the user.
+loo_n_workers <- function(cores) {
+  conns <- tryCatch(mirai::status()$connections, error = function(e) 0L)
+  conns <- as.integer(conns)
+  if (length(conns) != 1L || is.na(conns) || conns < 1L) {
+    return(as.integer(cores))
+  }
+  conns
+}
+
+#' Is the active daemon pool on the local machine?
+#'
+#' @noRd
+#' @keywords internal
+#' @description
+#' Determines whether shared memory ([mori::share()]) can be used safely with
+#' the active pool. Shared memory only works when workers run on the same
+#' physical machine, so we only treat same-host transports as local:
+#'
+#' * `abstract://` and `ipc://` are same-machine inter-process transports used
+#'   by local [mirai::daemons()] pools, so these are treated as local.
+#' * `tcp://` (and anything else) may be a remote pool, or the host URL that
+#'   remote SSH/HPC daemons dial back to, so it is treated as **not** local.
+#'   loo then falls back to ordinary serialization instead of shared memory.
+#'
+#' This is intentionally conservative: an incorrect "local" classification
+#' would produce wrong results on a remote pool, whereas an incorrect "remote"
+#' classification merely forgoes the zero-copy optimisation.
+#' @return `TRUE` if the pool is confirmed local, otherwise `FALSE`.
+loo_pool_is_local <- function() {
+  urls <- tryCatch(mirai::status()$daemons, error = function(e) NULL)
+  if (!is.character(urls) || length(urls) == 0L) {
+    return(FALSE)
+  }
+  all(grepl("^(abstract|ipc)://", urls))
+}
+
+#' Map a worker over elements, serially or across a mirai daemon pool
+#'
+#' @noRd
+#' @keywords internal
+#' @description
+#' Single cross-platform entry point for loo's per-observation parallelism.
+#' Replaces the previous platform-branching
+#' [parallel::mclapply()] / [parallel::parLapply()] code paths with a single
+#' [mirai::mirai_map()] path, while preserving the serial [lapply()] behaviour
+#' when no daemon pool is connected.
+#'
+#' Object transport is chosen automatically:
+#'
+#' * `broadcast` objects are reused identically by every element (e.g. the
+#'   posterior `draws` matrix). On a local pool they are written once into
+#'   shared memory with [mori::share()] so each daemon maps the same physical
+#'   pages (zero-copy). On a remote pool, where shared memory is unavailable,
+#'   they are serialized instead; chunking bounds the number of copies sent to
+#'   roughly one per worker.
+#' * Small per-call arguments are passed through `...`.
+#'
+#' @param X A vector or list to iterate over. Each element is passed as the
+#'   first argument to `FUN`.
+#' @param FUN Worker function. Called as `FUN(x, <broadcast>, <...>)`; the
+#'   names in `broadcast` and `...` must match `FUN`'s formals.
+#' @param ... Small constant arguments forwarded to `FUN` for every element.
+#' @param cores Integer number of cores requested by the user. Used only as a
+#'   fallback worker count for chunking when (unexpectedly) no pool is
+#'   connected; it does not gate execution. Parallelism is used whenever a
+#'   daemon pool is connected (the connected pool always wins over `cores`).
+#' @param broadcast Named list of large objects reused by every element. See
+#'   Description for how these are transported.
+#' @param chunk Chunking strategy. `"auto"` (default) splits `X` into roughly
+#'   one chunk per worker to amortise per-task overhead -- best for cheap
+#'   per-element work over many elements. `"never"` dispatches one task per
+#'   element for finer load balancing -- best for expensive, uneven per-element
+#'   work. `"never"` is automatically promoted to `"auto"` on a remote pool
+#'   that carries `broadcast` objects, to avoid re-sending them per task.
+#' @return A list of `FUN` results in the same order as `X`.
+loo_map <- function(X, FUN, ..., cores = 1L, broadcast = list(),
+                    chunk = c("auto", "never")) {
+  chunk <- match.arg(chunk)
+  dots <- list(...)
+
+  if (!loo_has_pool()) {
+    return(do.call(lapply, c(list(X, FUN), broadcast, dots)))
+  }
+
+  local_pool <- loo_pool_is_local()
+  if (length(broadcast) > 0L) {
+    if (local_pool) {
+      broadcast <- lapply(broadcast, mori::share)
+    } else if (chunk == "never") {
+      chunk <- "auto"
+    }
+  }
+  const_args <- c(broadcast, dots)
+
+  if (chunk == "never") {
+    return(
+      mirai::mirai_map(
+        X,
+        function(.x, .FUN, .const) do.call(.FUN, c(list(.x), .const)),
+        .args = list(.FUN = FUN, .const = const_args)
+      )[mirai::.stop]
+    )
+  }
+
+  n_chunks <- min(loo_n_workers(cores), length(X))
+  positions <- parallel::splitIndices(length(X), n_chunks)
+  chunks <- lapply(positions, function(p) X[p])
+  chunk_results <- mirai::mirai_map(
+    chunks,
+    function(.chunk, .FUN, .const) {
+      lapply(.chunk, function(.x) do.call(.FUN, c(list(.x), .const)))
+    },
+    .args = list(.FUN = FUN, .const = const_args)
+  )[mirai::.stop]
+  do.call(c, chunk_results)
+}
diff --git a/R/psis_approximate_posterior.R b/R/psis_approximate_posterior.R
index ebd9b4a4..7c372f1a 100644
--- a/R/psis_approximate_posterior.R
+++ b/R/psis_approximate_posterior.R
@@ -92,7 +92,7 @@ ap_psis <- function(log_ratios, log_p, log_g, ...) {
 ap_psis.array <-
   function(log_ratios, log_p, log_g, ...,
            cores = getOption("mc.cores", 1)) {
-    cores <- loo_cores(cores)
+    cores <- loo_cores(cores, call = match.call())
     stopifnot(length(dim(log_ratios)) == 3)
     log_ratios <- validate_ll(log_ratios)
     log_ratios <- llarray_to_matrix(log_ratios)
@@ -113,7 +113,7 @@ ap_psis.matrix <- function(log_ratios, log_p, log_g,
            cores = getOption("mc.cores", 1)) {
     checkmate::assert_numeric(log_p, len = nrow(log_ratios))
     checkmate::assert_numeric(log_g, len = nrow(log_ratios))
-    cores <- loo_cores(cores)
+    cores <- loo_cores(cores, call = match.call())
     log_ratios <- validate_ll(log_ratios)
 
     log_ratios <- correct_log_ratios(log_ratios, log_p = log_p, log_g = log_g)
diff --git a/R/psislw.R b/R/psislw.R
index 808e657f..6463c50e 100644
--- a/R/psislw.R
+++ b/R/psislw.R
@@ -14,12 +14,10 @@
 #' @param wtrunc For truncating very large weights to \eqn{S}^`wtrunc`. Set
 #'   to zero for no truncation.
 #' @param cores The number of cores to use for parallelization. This defaults to
-#'   the option `mc.cores` which can be set for an entire R session by
-#'   `options(mc.cores = NUMBER)`, the old option `loo.cores` is now
-#'   deprecated but will be given precedence over `mc.cores` until it is
-#'   removed. **As of version 2.0.0, the default is now 1 core if
-#'   `mc.cores` is not set, but we recommend using as many (or close to as
-#'   many) cores as possible.**
+#'   the option `mc.cores`, which can be set for an entire R session by
+#'   `options(mc.cores = NUMBER)`. **As of version 2.0.0, the default is now 1
+#'   core if `mc.cores` is not set, but we recommend using as many (or close to
+#'   as many) cores as possible.**
 #' @param llfun,llargs See [loo.function()].
 #' @param ... Ignored when `psislw()` is called directly. The `...` is
 #'   only used internally when `psislw()` is called by the [loo()]
@@ -40,7 +38,7 @@ psislw <- function(lw, wcp = 0.2, wtrunc = 3/4,
                    ...) {
   .Deprecated("psis")
 
-  cores <- loo_cores(cores)
+  cores <- loo_cores(cores, call = match.call())
 
   .psis <- function(lw_i) {
     x <- lw_i - max(lw_i)
diff --git a/R/zzz.R b/R/zzz.R
index 87dc9e20..41549ca5 100644
--- a/R/zzz.R
+++ b/R/zzz.R
@@ -5,10 +5,9 @@
     "- Online documentation and vignettes at mc-stan.org/loo"
   )
   packageStartupMessage(
-    "- As of v2.0.0 loo defaults to 1 core ",
-    "but we recommend using as many as possible. ",
-    "Use the 'cores' argument or set options(mc.cores = NUM_CORES) ",
-    "for an entire session. "
+    "- Parallelization uses mirai. The 'cores' argument and options('mc.cores') ",
+    "are deprecated; see vignette('loo2-parallel') for mirai::daemons() and ",
+    "loo_mirai()."
   )
   if (os_is_windows()) {
     packageStartupMessage(
diff --git a/_pkgdown.yml b/_pkgdown.yml
index 0a216a02..43739552 100644
--- a/_pkgdown.yml
+++ b/_pkgdown.yml
@@ -52,6 +52,7 @@ articles:
       - loo2-non-factorized
       - loo2-lfo
       - loo2-large-data
+      - loo2-parallel
       - loo2-moment-matching
       - loo2-mixis
   - title: Frequently asked questions
@@ -104,6 +105,7 @@ reference:
       - elpd
   - title: Other functions
     contents:
+      - loo_mirai
       - loo_predictive_metric
       - crps
       - elpd
diff --git a/benchmark/README.md b/benchmark/README.md
new file mode 100644
index 00000000..195f383e
--- /dev/null
+++ b/benchmark/README.md
@@ -0,0 +1,154 @@
+# loo parallel benchmarks
+
+These scripts measure the performance of loo's parallel code paths and compare
+two installed versions of the package side by side:
+
+- **`baseline`** — a pre-`mirai` version (the old `mclapply`/`parLapply`
+  backend), e.g. the released version from CRAN.
+- **`new`** — the current working tree (the `mirai` + `mori` backend, including
+  user-managed `mirai::daemons()` session pools).
+
+The same user-facing calls (`psis()`, `loo()`) are timed for every version; only
+the internal parallel backend differs. For the `new` version we additionally
+time a **persist** mode that starts `mirai::daemons()` once and reuses the
+pool across timed iterations, so we can separate per-call daemon
+spawn/teardown overhead from the steady-state cost.
+
+## Files
+
+| File | Purpose |
+|---|---|
+| `benchmark-parallel.R` | Times `psis()`/`loo()` across cores for one installed version; writes `/tmp/bench-<label>.rds`. |
+| `compare.R` | Reads the two `.rds` files and prints a wall-clock + memory comparison table. |
+| `peak-mem-run.R` | A single large-`draws` `loo()` run used for peak-memory measurement. |
+| `peak-mem.sh` | Linux-only driver that samples the RSS of the whole process tree during `peak-mem-run.R`. |
+
+## Prerequisites
+
+The benchmark scripts need the `bench` package (in addition to whatever loo
+needs):
+
+```bash
+Rscript -e 'install.packages("bench")'
+```
+
+## Step 1 — Install each version into its own library
+
+Each run reads the library path from the `LOO_LIB` environment variable, so put
+each version in its own directory:
+
+```bash
+mkdir -p /tmp/loo-base-lib /tmp/loo-new-lib
+
+# "new" = this working tree
+R CMD INSTALL --library=/tmp/loo-new-lib .
+
+# "baseline" = a pre-mirai version to compare against (CRAN release shown here;
+# alternatively check out an older git ref elsewhere and install that)
+Rscript -e 'install.packages("loo", lib = "/tmp/loo-base-lib")'
+```
+
+## Step 2 — Run the timing benchmark once per version
+
+Run from the package root. `BENCH_LABEL` tags the output file
+(`/tmp/bench-<label>.rds`):
+
+```bash
+LOO_LIB=/tmp/loo-base-lib BENCH_LABEL=baseline Rscript benchmark/benchmark-parallel.R
+LOO_LIB=/tmp/loo-new-lib  BENCH_LABEL=new      Rscript benchmark/benchmark-parallel.R
+```
+
+The `persist` mode is only measured for `BENCH_LABEL=new`, because the
+baseline version does not use mirai.
+
+## Step 3 — Aggregate and compare
+
+```bash
+Rscript benchmark/compare.R
+```
+
+This prints two tables (median wall-clock time with speedups, and main-process
+memory) with these columns:
+
+- `base` — baseline version.
+- `new/call` — new version, default per-call pool (created and torn down each
+  call).
+- `new/per` — new version, user-managed session pool (`mirai::daemons(k)`),
+  reused across calls.
+
+A speedup `> 1` means the new version is faster than the baseline. The report
+also states how many iterations each median is based on (recorded from
+`benchmark-parallel.R`'s `iters` setting).
+
+In addition to the console output, `compare.R` writes a Markdown report with the
+same tables (handy for pasting into issues/PRs). By default it is written next to
+the script as `benchmark/bench-comparison.md`; override the path with the
+`BENCH_MD` environment variable:
+
+```bash
+BENCH_MD=/tmp/benchmark-results.md Rscript benchmark/compare.R
+```
+
+## Optional — Peak memory (Linux only)
+
+`peak-mem.sh` samples the total RSS of the R process and all of its workers
+during one large-`draws` `loo()` run. It takes positional arguments
+`LOO_LIB BENCH_LABEL MODE CORES`, where `MODE` is `per-call` or `persist`:
+
+```bash
+benchmark/peak-mem.sh /tmp/loo-base-lib baseline per-call 8
+benchmark/peak-mem.sh /tmp/loo-new-lib  new      per-call 8
+benchmark/peak-mem.sh /tmp/loo-new-lib  new      persist  8
+```
+
+For the `new` version it also prints the `mori` transport size of the broadcast
+`draws` object (raw serialized MB vs the shared-memory reference in bytes),
+which shows the zero-copy benefit on a local pool.
+
+Each run also appends its peak-RSS result to a tab-separated file (default
+`/tmp/bench-peakmem.tsv`, override with `PEAK_OUT`). If that file is present when
+you run `compare.R`, the peak-RSS numbers are folded into the report as an extra
+"Peak RSS of the whole process tree" table. Delete the file between fresh runs so
+stale rows aren't mixed in (only the most recent row per label/mode/cores is
+kept).
+
+The Markdown report also ends with a **"How to read these numbers"** section
+explaining the difference between median time/speedup, main-process heap
+allocation (churn, not peak, workers excluded), and peak RSS (the whole process
+tree's real footprint).
+
+## Tuning
+
+Edit the top of `benchmark-parallel.R` to match your machine / problem sizes:
+
+- `cores_grid` (default `c(1, 4, 6)`) — the core counts to sweep.
+- `iters` (default `10`) — iterations per `bench::mark()` measurement for the
+  small/cheap scenarios.
+- `big_iters` (default `5`) — iterations for the large, slow scenarios that are
+  actually worth parallelizing (fewer iterations keeps total runtime sane).
+- `psis_sizes` and `loo_sizes` — the problem sizes. Each entry carries its own
+  `iters`.
+
+Which scenarios are actually worth parallelizing:
+
+- **`loo.function` (`loo_sizes`)** is the path that parallelizes well. `draws`
+  is shared zero-copy across local workers via `mori`, so only tiny
+  per-observation data/results move. The two larger configs (~9s and ~18s
+  serial) reach roughly 2.3x at 4 cores and 3x at 8 cores in local testing —
+  even with the per-call pool, so a single one-off call already benefits.
+- **Matrix `psis` (`psis_sizes`)** is *not* worth parallelizing, even when
+  large: it must ship a big log-ratio matrix out to the workers and return an
+  equally large weighted matrix, so it is communication-bound and stays near 1x
+  regardless of size. The large `S=6000 N=20000` entry (~960 MB) is included
+  deliberately to show this — make sure the machine has enough RAM before adding
+  bigger ones.
+
+For `peak-mem-run.R`, adjust `S`, `P`, and `Nf` to change the size of the
+broadcast `draws` matrix.
+
+## Notes
+
+- All output is written to `/tmp`. Remove `/tmp/bench-*.rds` between experiments
+  if you change the scenarios, so stale rows aren't mixed in.
+- Results are platform-dependent; run baseline and new back to back on an idle
+  machine for a fair comparison.
diff --git a/benchmark/bench-comparison.md b/benchmark/bench-comparison.md
new file mode 100644
index 00000000..c302c8ec
--- /dev/null
+++ b/benchmark/bench-comparison.md
@@ -0,0 +1,60 @@
+# loo parallel benchmark comparison
+
+_Generated 2026-07-01 11:23:20._
+
+**Columns / modes.** `base` is the baseline version. `new/call` is the new version's default per-call pool (created and torn down each call). `new/persist` is the new version with a user-managed `mirai::daemons()` session pool, reused across calls. `cores = 1` rows are fully serial (the parallel backend is never used).
+
+## Median wall-clock time (s) and speedup vs baseline
+
+Median over 5-10 iterations of one `psis()`/`loo()` call (a warm-up run is excluded). `speedup = base / new`, so a value `> 1` means the new version is faster. Expect `new/persist` to win when many calls reuse the pool, and `new/call` to look slower than `base` for cheap problems because it pays pool start-up/teardown on every call. The `cores = 1` `base` and `new/call` numbers should be roughly equal (both serial); sizeable gaps there are run-to-run noise, not real differences.
+
+| scenario | cores | base | new/call | new/persist | speedup (call) | speedup (persist) |
+|:---|---:|---:|---:|---:|---:|---:|
+| loo.function S=8000 P=150 N=400 (draws=9.6MB) | 1 | 0.677 | 0.678 | — | 1.00x | — |
+| loo.function S=8000 P=150 N=400 (draws=9.6MB) | 4 | 0.468 | 1.161 | 0.231 | 0.40x | 2.02x |
+| loo.function S=8000 P=150 N=400 (draws=9.6MB) | 6 | 0.379 | 1.200 | 0.147 | 0.32x | 2.58x |
+| loo.function S=8000 P=200 N=10000 (draws=12.8MB) | 1 | 15.150 | 17.807 | — | 0.85x | — |
+| loo.function S=8000 P=200 N=10000 (draws=12.8MB) | 4 | 4.716 | 5.691 | 5.013 | 0.83x | 0.94x |
+| loo.function S=8000 P=200 N=10000 (draws=12.8MB) | 6 | 2.598 | 4.036 | 3.258 | 0.64x | 0.80x |
+| loo.function S=8000 P=200 N=8000 (draws=12.8MB) | 1 | 13.527 | 13.847 | — | 0.98x | — |
+| loo.function S=8000 P=200 N=8000 (draws=12.8MB) | 4 | 4.325 | 4.944 | 4.086 | 0.87x | 1.06x |
+| loo.function S=8000 P=200 N=8000 (draws=12.8MB) | 6 | 2.597 | 3.437 | 2.650 | 0.76x | 0.98x |
+| psis S=2000 N=1000 | 1 | 0.388 | 0.371 | — | 1.05x | — |
+| psis S=2000 N=1000 | 4 | 0.242 | 1.153 | 0.214 | 0.21x | 1.13x |
+| psis S=2000 N=1000 | 6 | 0.252 | 1.190 | 0.176 | 0.21x | 1.43x |
+| psis S=4000 N=4000 | 1 | 2.892 | 2.764 | — | 1.05x | — |
+| psis S=4000 N=4000 | 4 | 1.704 | 2.331 | 1.465 | 0.73x | 1.16x |
+| psis S=4000 N=4000 | 6 | 1.367 | 2.547 | 1.786 | 0.54x | 0.77x |
+| psis S=6000 N=10000 | 1 | 9.641 | 9.195 | — | 1.05x | — |
+| psis S=6000 N=10000 | 4 | 6.203 | 7.735 | 7.242 | 0.80x | 0.86x |
+| psis S=6000 N=10000 | 6 | 5.384 | 7.408 | 6.801 | 0.73x | 0.79x |
+
+## Main-process memory allocation (MB)
+
+Total bytes allocated on the R heap by the *coordinator* process during the call (cumulative churn, **not** peak and **not** net), as measured by `bench`'s allocation profiler. It does **not** include memory used by worker processes, nor off-heap memory such as the `mori` shared-memory segment for the broadcast `draws`. That is why parallel rows are tiny: the heavy allocation happens in the workers, out of the profiler's view. Use it to gauge allocation pressure on the main process, not total footprint.
+
+| scenario | cores | base | new/call | new/persist |
+|:---|---:|---:|---:|---:|
+| loo.function S=8000 P=150 N=400 (draws=9.6MB) | 1 | 803.292 | 803.292 | — |
+| loo.function S=8000 P=150 N=400 (draws=9.6MB) | 4 | — | 1.112 | 1.092 |
+| loo.function S=8000 P=150 N=400 (draws=9.6MB) | 6 | — | 1.596 | 1.576 |
+| loo.function S=8000 P=200 N=10000 (draws=12.8MB) | 1 | 20082.281 | 20082.281 | — |
+| loo.function S=8000 P=200 N=10000 (draws=12.8MB) | 4 | — | 2.917 | 2.897 |
+| loo.function S=8000 P=200 N=10000 (draws=12.8MB) | 6 | — | 3.401 | 3.381 |
+| loo.function S=8000 P=200 N=8000 (draws=12.8MB) | 1 | 16065.825 | 16065.825 | — |
+| loo.function S=8000 P=200 N=8000 (draws=12.8MB) | 4 | — | 2.541 | 2.521 |
+| loo.function S=8000 P=200 N=8000 (draws=12.8MB) | 6 | — | 3.025 | 3.005 |
+| psis S=2000 N=1000 | 1 | 304.130 | 304.130 | — |
+| psis S=2000 N=1000 | 4 | — | 120.986 | 120.966 |
+| psis S=2000 N=1000 | 6 | — | 121.335 | 121.315 |
+| psis S=4000 N=4000 | 1 | 2306.371 | 2306.371 | — |
+| psis S=4000 N=4000 | 4 | — | 961.700 | 961.679 |
+| psis S=4000 N=4000 | 6 | — | 962.048 | 962.028 |
+| psis S=6000 N=10000 | 1 | 8458.151 | 8458.151 | — |
+| psis S=6000 N=10000 | 4 | — | 3603.208 | 3603.188 |
+| psis S=6000 N=10000 | 6 | — | 3603.557 | 3603.537 |
+
+## Caveats
+
+Results are platform-dependent and sensitive to machine load; run the baseline and new versions back to back on an idle machine, and ignore differences smaller than the run-to-run noise.
+
diff --git a/benchmark/benchmark-parallel.R b/benchmark/benchmark-parallel.R
new file mode 100644
index 00000000..dea0d4b6
--- /dev/null
+++ b/benchmark/benchmark-parallel.R
@@ -0,0 +1,149 @@
+# Benchmark loo's parallel code paths for a single installed version.
+#
+# Run once per version, pointing at an isolated library and tagging the output:
+#   LOO_LIB=/tmp/loo-base-lib BENCH_LABEL=baseline Rscript benchmark/benchmark-parallel.R
+#   LOO_LIB=/tmp/loo-new-lib  BENCH_LABEL=new      Rscript benchmark/benchmark-parallel.R
+#
+# Results are written to /tmp/bench-<label>.rds; compare.R aggregates them.
+#
+# The same user-facing calls (psis(), loo()) are timed for every version; the
+# parallel backend (mclapply/parLapply vs mirai+mori) differs internally. For
+# the new version we additionally time a "persist" mode where mirai::daemons()
+# is started once before the timed iterations and reused (user-managed session
+# pool), so the timed iterations measure steady-state cost with no per-call
+# daemon spawn/teardown overhead.
+
+lib <- Sys.getenv("LOO_LIB")
+label <- Sys.getenv("BENCH_LABEL", unset = "unknown")
+stopifnot(nzchar(lib))
+
+suppressMessages({
+  library(loo, lib.loc = lib)
+  library(bench)
+})
+
+is_new <- identical(label, "new")
+cores_grid <- c(1L, 4L, 6L)
+iters <- 10L     # iterations for the small/cheap scenarios
+big_iters <- 5L  # fewer iterations for the large, slow "worth parallelizing" scenarios
+
+rows <- list()
+record <- function(scenario, mode, cores, expr, n_iter = iters) {
+  expr <- substitute(expr)
+  pf <- parent.frame()
+  eval(expr, pf) # warm up (process spawn / pool / JIT)
+  b <- tryCatch(
+    bench::mark(
+      eval(expr, pf),
+      iterations = n_iter, check = FALSE, memory = TRUE, filter_gc = FALSE
+    ),
+    error = function(e) {
+      bench::mark(
+        eval(expr, pf),
+        iterations = n_iter, check = FALSE, memory = FALSE, filter_gc = FALSE
+      )
+    }
+  )
+  rows[[length(rows) + 1L]] <<- data.frame(
+    label = label, scenario = scenario, mode = mode, cores = cores,
+    iters = n_iter,
+    median_s = as.numeric(b$median),
+    mem_mb = if ("mem_alloc" %in% names(b) && !is.na(b$mem_alloc[1])) {
+      as.numeric(b$mem_alloc) / 1e6
+    } else {
+      NA_real_
+    },
+    stringsAsFactors = FALSE
+  )
+  cat(sprintf(
+    "  [%s] %-22s %-10s cores=%d  median=%.3fs\n",
+    label, scenario, mode, cores, as.numeric(b$median)
+  ))
+}
+
+# ---------------------------------------------------------------------------
+# Scenario 1: standalone PSIS over a log-ratio matrix (partitioned columns).
+#
+# Counter-intuitively, the matrix `psis()` path is NOT worth parallelizing even
+# when it is large: it has to ship a big log-ratio matrix out to the workers and
+# return an equally large weighted matrix, so it is communication-bound. The
+# parallel speedup stays ~1x no matter how big the problem is. The first two
+# sizes are cheap exercisers; the last is large (~11s serial) and is included
+# precisely to *demonstrate* that size alone does not make this path worth
+# parallelizing -- compare its ~1x speedup with the loo.function scenarios below.
+# ---------------------------------------------------------------------------
+psis_sizes <- list(
+  list(S = 2000, N = 1000, iters = iters),       # cheap exerciser
+  list(S = 4000, N = 4000, iters = iters),       # cheap exerciser
+  list(S = 6000, N = 10000, iters = big_iters)   # large but communication-bound (~1x)
+)
+for (sz in psis_sizes) {
+  set.seed(2024) # identical inputs across versions
+  S <- sz[["S"]]
+  N <- sz[["N"]]
+  n_iter <- sz[["iters"]]
+  LL <- matrix(rnorm(S * N), nrow = S)
+  re <- rep(1, N)
+  scen <- sprintf("psis S=%d N=%d", S, N)
+  for (k in cores_grid) {
+    mode <- if (k == 1L) "serial" else "per-call"
+    record(scen, mode, k, suppressWarnings(psis(-LL, r_eff = re, cores = k)), n_iter = n_iter)
+    if (is_new && k > 1L) {
+      mirai::daemons(k)
+      record(scen, "persist", k, suppressWarnings(psis(-LL, r_eff = re, cores = k)), n_iter = n_iter)
+      mirai::daemons(0)
+    }
+  }
+  rm(LL)
+  gc()
+}
+
+# ---------------------------------------------------------------------------
+# Scenario 2: loo.function with a large broadcast `draws` matrix (the case
+# where fork shares memory for free and mori must recover that benefit).
+#
+# This is the path that is genuinely worth parallelizing: `draws` is shared
+# zero-copy across local workers via mori, and only tiny per-observation data
+# and results move, so the per-observation work parallelizes cleanly. The first
+# config is cheap (N=400, sub-second serial) and not worth parallelizing, but
+# the two larger ones (~9s and ~18s serial) scale well even with the per-call
+# pool -- ~2.3x at 4 cores and ~3x at 8 cores in local testing -- so a single
+# one-off call already benefits.
+# ---------------------------------------------------------------------------
+llfun_b <- function(data_i, draws, ...) {
+  dnorm(data_i$y, mean = draws[, "p1"], sd = abs(draws[, "p2"]) + 0.5, log = TRUE)
+}
+loo_sizes <- list(
+  list(S = 8000, P = 150, N = 400, iters = iters),        # cheap: not worth parallelizing
+  list(S = 8000, P = 200, N = 8000, iters = big_iters),   # ~9s serial: worth parallelizing
+  list(S = 8000, P = 200, N = 10000, iters = big_iters)   # ~18s serial: worth parallelizing
+)
+for (sz in loo_sizes) {
+  set.seed(7) # identical inputs across versions
+  S2 <- sz[["S"]]
+  P <- sz[["P"]]
+  Nf <- sz[["N"]]
+  n_iter <- sz[["iters"]]
+  draws_big <- matrix(rnorm(S2 * P), nrow = S2, dimnames = list(NULL, paste0("p", seq_len(P))))
+  data_f <- data.frame(y = rnorm(Nf))
+  scen <- sprintf("loo.function S=%d P=%d N=%d (draws=%.1fMB)", S2, P, Nf, S2 * P * 8 / 1e6)
+  for (k in cores_grid) {
+    mode <- if (k == 1L) "serial" else "per-call"
+    record(scen, mode, k, suppressWarnings(
+      loo(llfun_b, data = data_f, draws = draws_big, cores = k)
+    ), n_iter = n_iter)
+    if (is_new && k > 1L) {
+      mirai::daemons(k)
+      record(scen, "persist", k, suppressWarnings(
+        loo(llfun_b, data = data_f, draws = draws_big, cores = k)
+      ), n_iter = n_iter)
+      mirai::daemons(0)
+    }
+  }
+  rm(draws_big)
+  gc()
+}
+
+out <- do.call(rbind, rows)
+saveRDS(out, sprintf("/tmp/bench-%s.rds", label))
+cat(sprintf("\nSaved %d rows to /tmp/bench-%s.rds\n", nrow(out), label))
diff --git a/benchmark/compare.R b/benchmark/compare.R
new file mode 100644
index 00000000..f9792e90
--- /dev/null
+++ b/benchmark/compare.R
@@ -0,0 +1,218 @@
+# Aggregate and compare benchmark results from benchmark-parallel.R.
+#   Rscript benchmark/compare.R
+#
+# Prints the comparison to the console and also writes a Markdown report
+# (default /tmp/bench-comparison.md, override with the BENCH_MD env var) with
+# the same two tables, for easy sharing.
+
+# Directory containing this script, so the report lands next to it regardless
+# of the working directory the script is launched from.
+.this_file <- sub("^--file=", "", grep("^--file=", commandArgs(FALSE), value = TRUE))
+script_dir <- if (length(.this_file) == 1L) {
+  dirname(normalizePath(.this_file))
+} else {
+  "benchmark"
+}
+
+md_out <- Sys.getenv("BENCH_MD", unset = file.path(script_dir, "bench-comparison.md"))
+peak_out <- Sys.getenv("PEAK_OUT", unset = "/tmp/bench-peakmem.tsv")
+
+base <- readRDS("/tmp/bench-baseline.rds")
+new <- readRDS("/tmp/bench-new.rds")
+all <- rbind(base, new)
+
+key <- function(d) paste(d$scenario, d$cores)
+
+# Median seconds, keyed by version/mode.
+med <- function(df, lab, mode) {
+  sel <- df[df$label == lab & df$mode == mode, ]
+  setNames(sel$median_s, key(sel))
+}
+mem <- function(df, lab, mode) {
+  sel <- df[df$label == lab & df$mode == mode, ]
+  setNames(sel$mem_mb, key(sel))
+}
+
+scen_cores <- unique(all[, c("scenario", "cores")])
+scen_cores <- scen_cores[order(scen_cores$scenario, scen_cores$cores), ]
+
+# Iterations per measurement (recorded by benchmark-parallel.R). Older result
+# files may predate this column.
+iters_used <- if ("iters" %in% names(all)) {
+  iv <- sort(unique(all$iters[!is.na(all$iters)]))
+  if (length(iv) == 1L) as.character(iv) else paste(range(iv), collapse = "-")
+} else {
+  NA_character_
+}
+iters_label <- if (is.na(iters_used)) "a few" else iters_used
+
+b_serial <- med(base, "baseline", "serial")
+b_par <- med(base, "baseline", "per-call")
+n_serial <- med(new, "new", "serial")
+n_call <- med(new, "new", "per-call")
+n_persist <- med(new, "new", "persist")
+
+base_med <- c(b_serial, b_par)
+new_call_med <- c(n_serial, n_call)
+
+get1 <- function(vec, k) {
+  if (!is.null(vec) && k %in% names(vec)) vec[[k]] else NA_real_
+}
+fmt <- function(x) ifelse(is.na(x), "      -", sprintf("%7.3f", x))
+spd <- function(num, den) ifelse(is.na(num) | is.na(den), "    -", sprintf("%4.2fx", num / den))
+
+cat(sprintf("\n=== Median wall-clock time (s) and speedup vs baseline (%s iterations) ===\n", iters_label))
+cat(sprintf(
+  "%-42s %5s | %8s %8s %8s | %7s %7s\n",
+  "scenario", "cores", "base", "new/call", "new/per",
+  "call", "persist"
+))
+cat(strrep("-", 96), "\n")
+for (i in seq_len(nrow(scen_cores))) {
+  k <- paste(scen_cores$scenario[i], scen_cores$cores[i])
+  bm <- get1(base_med, k)
+  nc <- get1(new_call_med, k)
+  np <- get1(n_persist, k)
+  cat(sprintf(
+    "%-42s %5d | %8s %8s %8s | %7s %7s\n",
+    scen_cores$scenario[i], scen_cores$cores[i],
+    fmt(bm), fmt(nc), fmt(np),
+    spd(bm, nc), spd(bm, np)
+  ))
+}
+
+cat("\n=== Main-process memory allocation (MB) ===\n")
+b_mem <- c(mem(base, "baseline", "serial"), mem(base, "baseline", "per-call"))
+n_mem <- c(mem(new, "new", "serial"), mem(new, "new", "per-call"))
+p_mem <- mem(new, "new", "persist")
+cat(sprintf("%-42s %5s | %8s %8s %8s\n", "scenario", "cores", "base", "new/call", "new/per"))
+cat(strrep("-", 80), "\n")
+for (i in seq_len(nrow(scen_cores))) {
+  k <- paste(scen_cores$scenario[i], scen_cores$cores[i])
+  cat(sprintf(
+    "%-42s %5d | %8s %8s %8s\n",
+    scen_cores$scenario[i], scen_cores$cores[i],
+    fmt(get1(b_mem, k)), fmt(get1(n_mem, k)), fmt(get1(p_mem, k))
+  ))
+}
+cat("\nspeedup > 1 means new is faster than baseline.\n")
+
+
+# Peak-memory results (optional) ---------------------------------------------
+# peak-mem.sh appends "<label>\t<mode>\t<cores>\t<peak_mb>" rows to peak_out.
+
+peak <- NULL
+if (file.exists(peak_out) && file.info(peak_out)$size > 0) {
+  peak <- utils::read.delim(
+    peak_out, header = FALSE, stringsAsFactors = FALSE,
+    col.names = c("label", "mode", "cores", "peak_mb")
+  )
+  # Keep only the most recent record for each label/mode/cores combination.
+  peak$.k <- paste(peak$label, peak$mode, peak$cores)
+  peak <- peak[!duplicated(peak$.k, fromLast = TRUE), ]
+  peak <- peak[order(peak$cores, peak$label, peak$mode), ]
+
+  cat("\n=== Peak RSS of whole process tree (MB) ===\n")
+  cat(sprintf("%-10s %-10s %5s | %10s\n", "label", "mode", "cores", "peak_mb"))
+  cat(strrep("-", 44), "\n")
+  for (i in seq_len(nrow(peak))) {
+    cat(sprintf(
+      "%-10s %-10s %5s | %10.0f\n",
+      peak$label[i], peak$mode[i], peak$cores[i], peak$peak_mb[i]
+    ))
+  }
+} else {
+  cat(sprintf(
+    "\n(no peak-memory results found at %s; run benchmark/peak-mem.sh to add them)\n",
+    peak_out
+  ))
+}
+
+
+# Markdown report ------------------------------------------------------------
+# Same numbers as above, formatted as Markdown tables for easy sharing.
+
+md_num <- function(x) ifelse(is.na(x), "—", sprintf("%.3f", x))
+md_int <- function(x) ifelse(is.na(x), "—", sprintf("%.0f", x))
+md_spd <- function(num, den) {
+  ifelse(is.na(num) | is.na(den), "—", sprintf("%.2fx", num / den))
+}
+
+md <- c(
+  "# loo parallel benchmark comparison",
+  "",
+  sprintf("_Generated %s._", format(Sys.time(), "%Y-%m-%d %H:%M:%S")),
+  "",
+  "**Columns / modes.** `base` is the baseline version. `new/call` is the new version's default per-call pool (created and torn down each call). `new/persist` is the new version with a user-managed `mirai::daemons()` session pool, reused across calls. `cores = 1` rows are fully serial (the parallel backend is never used).",
+  "",
+  "## Median wall-clock time (s) and speedup vs baseline",
+  "",
+  sprintf("Median over %s iterations of one `psis()`/`loo()` call (a warm-up run is excluded). `speedup = base / new`, so a value `> 1` means the new version is faster. Expect `new/persist` to win when many calls reuse the pool, and `new/call` to look slower than `base` for cheap problems because it pays pool start-up/teardown on every call. The `cores = 1` `base` and `new/call` numbers should be roughly equal (both serial); sizeable gaps there are run-to-run noise, not real differences.", iters_label),
+  "",
+  "| scenario | cores | base | new/call | new/persist | speedup (call) | speedup (persist) |",
+  "|:---|---:|---:|---:|---:|---:|---:|"
+)
+for (i in seq_len(nrow(scen_cores))) {
+  k <- paste(scen_cores$scenario[i], scen_cores$cores[i])
+  bm <- get1(base_med, k)
+  nc <- get1(new_call_med, k)
+  np <- get1(n_persist, k)
+  md <- c(md, sprintf(
+    "| %s | %d | %s | %s | %s | %s | %s |",
+    scen_cores$scenario[i], scen_cores$cores[i],
+    md_num(bm), md_num(nc), md_num(np),
+    md_spd(bm, nc), md_spd(bm, np)
+  ))
+}
+
+md <- c(
+  md,
+  "",
+  "## Main-process memory allocation (MB)",
+  "",
+  "Total bytes allocated on the R heap by the *coordinator* process during the call (cumulative churn, **not** peak and **not** net), as measured by `bench`'s allocation profiler. It does **not** include memory used by worker processes, nor off-heap memory such as the `mori` shared-memory segment for the broadcast `draws`. That is why parallel rows are tiny: the heavy allocation happens in the workers, out of the profiler's view. Use it to gauge allocation pressure on the main process, not total footprint.",
+  "",
+  "| scenario | cores | base | new/call | new/persist |",
+  "|:---|---:|---:|---:|---:|"
+)
+for (i in seq_len(nrow(scen_cores))) {
+  k <- paste(scen_cores$scenario[i], scen_cores$cores[i])
+  md <- c(md, sprintf(
+    "| %s | %d | %s | %s | %s |",
+    scen_cores$scenario[i], scen_cores$cores[i],
+    md_num(get1(b_mem, k)), md_num(get1(n_mem, k)), md_num(get1(p_mem, k))
+  ))
+}
+
+# Peak-RSS table (only when peak-mem.sh results are available).
+if (!is.null(peak)) {
+  md <- c(
+    md,
+    "",
+    "## Peak RSS of the whole process tree (MB)",
+    "",
+    "From `peak-mem.sh` (single large-`draws` `loo()` run; Linux only). Maximum summed resident memory of the *entire* process tree (main process plus all workers), sampled during the run. This is the metric for the job's real memory footprint. On a local pool, `mori` shares the `draws` matrix across workers (zero-copy), so peak RSS stays close to a single copy rather than growing with the number of workers.",
+    "",
+    "| label | mode | cores | peak RSS (MB) |",
+    "|:---|:---|---:|---:|"
+  )
+  for (i in seq_len(nrow(peak))) {
+    md <- c(md, sprintf(
+      "| %s | %s | %s | %s |",
+      peak$label[i], peak$mode[i], peak$cores[i], md_int(peak$peak_mb[i])
+    ))
+  }
+}
+
+# Caveats footer.
+md <- c(
+  md,
+  "",
+  "## Caveats",
+  "",
+  "Results are platform-dependent and sensitive to machine load; run the baseline and new versions back to back on an idle machine, and ignore differences smaller than the run-to-run noise.",
+  ""
+)
+
+writeLines(md, md_out)
+cat(sprintf("\nMarkdown report written to %s\n", md_out))
diff --git a/benchmark/peak-mem-run.R b/benchmark/peak-mem-run.R
new file mode 100644
index 00000000..9a8c5f61
--- /dev/null
+++ b/benchmark/peak-mem-run.R
@@ -0,0 +1,45 @@
+# Single large-draws loo.function run for peak-memory measurement.
+# Driven by peak-mem.sh, which samples the total RSS of this process tree.
+#   LOO_LIB=... BENCH_LABEL=baseline|new MODE=per-call|persist CORES=8 Rscript peak-mem-run.R
+#
+# In "persist" mode (new version only) mirai::daemons() is started before the
+# loo() call so the pool is reused for the duration of the run.
+
+lib <- Sys.getenv("LOO_LIB")
+label <- Sys.getenv("BENCH_LABEL", unset = "unknown")
+mode <- Sys.getenv("MODE", unset = "per-call")
+cores <- as.integer(Sys.getenv("CORES", unset = "8"))
+stopifnot(nzchar(lib))
+suppressMessages(library(loo, lib.loc = lib))
+
+set.seed(7)
+S <- 30000L
+P <- 400L # draws ~ 30000 * 400 * 8 = 96 MB
+Nf <- 300L
+draws_big <- matrix(rnorm(S * P), nrow = S, dimnames = list(NULL, paste0("p", seq_len(P))))
+data_f <- data.frame(y = rnorm(Nf))
+llfun_b <- function(data_i, draws, ...) {
+  dnorm(data_i$y, mean = draws[, "p1"], sd = abs(draws[, "p2"]) + 0.5, log = TRUE)
+}
+
+# Per-worker transport size of the broadcast object (mori metric).
+if (label == "new") {
+  raw_bytes <- length(serialize(draws_big, NULL))
+  shared <- mori::share(draws_big)
+  ref_bytes <- length(serialize(shared, NULL))
+  cat(sprintf(
+    "TRANSPORT draws raw=%.1fMB  mori_ref=%d bytes  (%.0fx smaller)\n",
+    raw_bytes / 1e6, ref_bytes, raw_bytes / ref_bytes
+  ))
+}
+
+if (label == "new" && mode == "persist") {
+  mirai::daemons(cores)
+}
+
+invisible(suppressWarnings(loo(llfun_b, data = data_f, draws = draws_big, cores = cores)))
+
+if (label == "new" && mode == "persist") {
+  mirai::daemons(0)
+}
+cat("RUN COMPLETE\n")
diff --git a/benchmark/peak-mem.sh b/benchmark/peak-mem.sh
new file mode 100755
index 00000000..0973fece
--- /dev/null
+++ b/benchmark/peak-mem.sh
@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+# Measure peak total RSS (MB) of an R run and its entire process tree
+# (mclapply forks or mirai daemons), by sampling /proc every 20 ms.
+#
+# Usage: peak-mem.sh LOO_LIB BENCH_LABEL MODE CORES   (MODE = per-call|persist)
+set -u
+LOO_LIB="$1"; BENCH_LABEL="$2"; MODE="$3"; CORES="$4"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+LOO_LIB="$LOO_LIB" BENCH_LABEL="$BENCH_LABEL" MODE="$MODE" CORES="$CORES" \
+  Rscript "$SCRIPT_DIR/peak-mem-run.R" &
+RPID=$!
+
+tree_rss_kb() {
+  # Sum RSS (KB) of the root pid and all descendants.
+  local root=$1
+  local pids=$root
+  local frontier=$root
+  while [ -n "$frontier" ]; do
+    local next=""
+    for p in $frontier; do
+      local kids
+      kids=$(pgrep -P "$p" 2>/dev/null | tr '\n' ' ')
+      next="$next $kids"
+    done
+    frontier=$(echo "$next" | xargs)
+    pids="$pids $frontier"
+  done
+  local total=0 rss
+  for p in $pids; do
+    rss=$(awk '/^VmRSS:/{print $2}' "/proc/$p/status" 2>/dev/null)
+    [ -n "${rss:-}" ] && total=$((total + rss))
+  done
+  echo "$total"
+}
+
+PEAK=0
+while kill -0 "$RPID" 2>/dev/null; do
+  CUR=$(tree_rss_kb "$RPID")
+  [ "$CUR" -gt "$PEAK" ] && PEAK=$CUR
+  sleep 0.02
+done
+wait "$RPID"
+PEAK_MB=$(echo "$PEAK/1024" | bc -l)
+
+# Append a parseable record so compare.R can fold the peak-RSS results into its
+# report. Override the destination with PEAK_OUT; delete it between fresh runs.
+PEAK_OUT="${PEAK_OUT:-/tmp/bench-peakmem.tsv}"
+printf "%s\t%s\t%s\t%.0f\n" "$BENCH_LABEL" "$MODE" "$CORES" "$PEAK_MB" >> "$PEAK_OUT"
+
+printf "PEAK_RSS %s/%s/cores=%s : %.0f MB  (appended to %s)\n" \
+  "$BENCH_LABEL" "$MODE" "$CORES" "$PEAK_MB" "$PEAK_OUT"
diff --git a/man-roxygen/cores.R b/man-roxygen/cores.R
index 6fd28d3f..99313f63 100644
--- a/man-roxygen/cores.R
+++ b/man-roxygen/cores.R
@@ -1,12 +1,19 @@
-#' @param cores The number of cores to use for parallelization. This defaults to
-#'   the option `mc.cores` which can be set for an entire R session by
-#'   `options(mc.cores = NUMBER)`. The old option `loo.cores` is now
-#'   deprecated but will be given precedence over `mc.cores` until
-#'   `loo.cores` is removed in a future release. **As of version
-#'   2.0.0 the default is now 1 core if `mc.cores` is not set**, but we
-#'   recommend using as many (or close to as many) cores as possible.
+#' @param cores **Deprecated.** The number of cores to use for parallelization.
+#'   This argument will be removed in a future release. A deprecation warning is
+#'   emitted when `cores` is passed explicitly (even `cores = 1`), when
+#'   `options(mc.cores)` is set, or when the resolved value is `cores > 1`.
+#'   When `cores > 1` and no [mirai::daemons()] pool is connected, a per-call
+#'   local daemon pool of that size is started for the duration of the call.
+#'   Prefer [mirai::daemons()] for session-level pools or [loo_mirai()] for
+#'   map-style workflows over many models.
+#'
+#'   This defaults to `getOption("mc.cores", 1)`, but **`options(mc.cores)` is
+#'   also deprecated** and will be removed in a future release (it still works
+#'   on this branch as a bridge to per-call daemon pools). **As of version 2.0.0
+#'   the default is 1 core when `mc.cores` is not set**.
 #'   * Note for Windows 10 users: it is __strongly__
 #'     [recommended](https://github.com/stan-dev/loo/issues/94) to avoid using
-#'     the `.Rprofile` file to set `mc.cores` (using the `cores` argument or
-#'     setting `mc.cores` interactively or in a script is fine).
+#'     the `.Rprofile` file to set `mc.cores`.
+#'
+#'   See `vignette("loo2-parallel")` for the mirai-based replacement workflow.
 #'
diff --git a/man/ap_psis.Rd b/man/ap_psis.Rd
index 271718c8..a38a5e00 100644
--- a/man/ap_psis.Rd
+++ b/man/ap_psis.Rd
@@ -27,19 +27,26 @@ proposal distribution (g). A vector of length S.}
 
 \item{...}{Currently not in use.}
 
-\item{cores}{The number of cores to use for parallelization. This defaults to
-the option \code{mc.cores} which can be set for an entire R session by
-\code{options(mc.cores = NUMBER)}. The old option \code{loo.cores} is now
-deprecated but will be given precedence over \code{mc.cores} until
-\code{loo.cores} is removed in a future release. \strong{As of version
-2.0.0 the default is now 1 core if \code{mc.cores} is not set}, but we
-recommend using as many (or close to as many) cores as possible.
+\item{cores}{\strong{Deprecated.} The number of cores to use for parallelization.
+This argument will be removed in a future release. A deprecation warning is
+emitted when \code{cores} is passed explicitly (even \code{cores = 1}), when
+\code{options(mc.cores)} is set, or when the resolved value is \code{cores > 1}.
+When \code{cores > 1} and no \code{\link[mirai:daemons]{mirai::daemons()}} pool is connected, a per-call
+local daemon pool of that size is started for the duration of the call.
+Prefer \code{\link[mirai:daemons]{mirai::daemons()}} for session-level pools or \code{\link[=loo_mirai]{loo_mirai()}} for
+map-style workflows over many models.
+
+This defaults to \code{getOption("mc.cores", 1)}, but \strong{\code{options(mc.cores)} is
+also deprecated} and will be removed in a future release (it still works
+on this branch as a bridge to per-call daemon pools). \strong{As of version 2.0.0
+the default is 1 core when \code{mc.cores} is not set}.
 \itemize{
 \item Note for Windows 10 users: it is \strong{strongly}
 \href{https://github.com/stan-dev/loo/issues/94}{recommended} to avoid using
-the \code{.Rprofile} file to set \code{mc.cores} (using the \code{cores} argument or
-setting \code{mc.cores} interactively or in a script is fine).
-}}
+the \code{.Rprofile} file to set \code{mc.cores}.
+}
+
+See \code{vignette("loo2-parallel")} for the mirai-based replacement workflow.}
 }
 \description{
 Pareto smoothed importance sampling (PSIS)
diff --git a/man/importance_sampling.Rd b/man/importance_sampling.Rd
index b9cdf75d..95c45d14 100644
--- a/man/importance_sampling.Rd
+++ b/man/importance_sampling.Rd
@@ -56,19 +56,26 @@ value is used for all observations) or a vector with length equal to the
 number of observations. The default value is 1. See the \code{\link[=relative_eff]{relative_eff()}}
 helper function for computing \code{r_eff}.}
 
-\item{cores}{The number of cores to use for parallelization. This defaults to
-the option \code{mc.cores} which can be set for an entire R session by
-\code{options(mc.cores = NUMBER)}. The old option \code{loo.cores} is now
-deprecated but will be given precedence over \code{mc.cores} until
-\code{loo.cores} is removed in a future release. \strong{As of version
-2.0.0 the default is now 1 core if \code{mc.cores} is not set}, but we
-recommend using as many (or close to as many) cores as possible.
+\item{cores}{\strong{Deprecated.} The number of cores to use for parallelization.
+This argument will be removed in a future release. A deprecation warning is
+emitted when \code{cores} is passed explicitly (even \code{cores = 1}), when
+\code{options(mc.cores)} is set, or when the resolved value is \code{cores > 1}.
+When \code{cores > 1} and no \code{\link[mirai:daemons]{mirai::daemons()}} pool is connected, a per-call
+local daemon pool of that size is started for the duration of the call.
+Prefer \code{\link[mirai:daemons]{mirai::daemons()}} for session-level pools or \code{\link[=loo_mirai]{loo_mirai()}} for
+map-style workflows over many models.
+
+This defaults to \code{getOption("mc.cores", 1)}, but \strong{\code{options(mc.cores)} is
+also deprecated} and will be removed in a future release (it still works
+on this branch as a bridge to per-call daemon pools). \strong{As of version 2.0.0
+the default is 1 core when \code{mc.cores} is not set}.
 \itemize{
 \item Note for Windows 10 users: it is \strong{strongly}
 \href{https://github.com/stan-dev/loo/issues/94}{recommended} to avoid using
-the \code{.Rprofile} file to set \code{mc.cores} (using the \code{cores} argument or
-setting \code{mc.cores} interactively or in a script is fine).
-}}
+the \code{.Rprofile} file to set \code{mc.cores}.
+}
+
+See \code{vignette("loo2-parallel")} for the mirai-based replacement workflow.}
 }
 \description{
 A parent class for different importance sampling methods.
diff --git a/man/loo.Rd b/man/loo.Rd
index e6b48075..ed3de076 100644
--- a/man/loo.Rd
+++ b/man/loo.Rd
@@ -73,19 +73,26 @@ This is useful if you plan to use the \code{\link[=E_loo]{E_loo()}} function to
 weighted expectations after running \code{loo}. Several functions in the
 \pkg{bayesplot} package also accept \code{psis} objects.}
 
-\item{cores}{The number of cores to use for parallelization. This defaults to
-the option \code{mc.cores} which can be set for an entire R session by
-\code{options(mc.cores = NUMBER)}. The old option \code{loo.cores} is now
-deprecated but will be given precedence over \code{mc.cores} until
-\code{loo.cores} is removed in a future release. \strong{As of version
-2.0.0 the default is now 1 core if \code{mc.cores} is not set}, but we
-recommend using as many (or close to as many) cores as possible.
+\item{cores}{\strong{Deprecated.} The number of cores to use for parallelization.
+This argument will be removed in a future release. A deprecation warning is
+emitted when \code{cores} is passed explicitly (even \code{cores = 1}), when
+\code{options(mc.cores)} is set, or when the resolved value is \code{cores > 1}.
+When \code{cores > 1} and no \code{\link[mirai:daemons]{mirai::daemons()}} pool is connected, a per-call
+local daemon pool of that size is started for the duration of the call.
+Prefer \code{\link[mirai:daemons]{mirai::daemons()}} for session-level pools or \code{\link[=loo_mirai]{loo_mirai()}} for
+map-style workflows over many models.
+
+This defaults to \code{getOption("mc.cores", 1)}, but \strong{\code{options(mc.cores)} is
+also deprecated} and will be removed in a future release (it still works
+on this branch as a bridge to per-call daemon pools). \strong{As of version 2.0.0
+the default is 1 core when \code{mc.cores} is not set}.
 \itemize{
 \item Note for Windows 10 users: it is \strong{strongly}
 \href{https://github.com/stan-dev/loo/issues/94}{recommended} to avoid using
-the \code{.Rprofile} file to set \code{mc.cores} (using the \code{cores} argument or
-setting \code{mc.cores} interactively or in a script is fine).
-}}
+the \code{.Rprofile} file to set \code{mc.cores}.
+}
+
+See \code{vignette("loo2-parallel")} for the mirai-based replacement workflow.}
 
 \item{is_method}{The importance sampling method to use. The following methods
 are implemented:
diff --git a/man/loo_approximate_posterior.Rd b/man/loo_approximate_posterior.Rd
index a17d59a2..c9a1b84f 100644
--- a/man/loo_approximate_posterior.Rd
+++ b/man/loo_approximate_posterior.Rd
@@ -54,19 +54,26 @@ proposal distribution (g). A vector of length S.}
 \code{loo_approximate_posterior()} be saved in the returned object? See
 \code{\link[=loo]{loo()}} for details.}
 
-\item{cores}{The number of cores to use for parallelization. This defaults to
-the option \code{mc.cores} which can be set for an entire R session by
-\code{options(mc.cores = NUMBER)}. The old option \code{loo.cores} is now
-deprecated but will be given precedence over \code{mc.cores} until
-\code{loo.cores} is removed in a future release. \strong{As of version
-2.0.0 the default is now 1 core if \code{mc.cores} is not set}, but we
-recommend using as many (or close to as many) cores as possible.
+\item{cores}{\strong{Deprecated.} The number of cores to use for parallelization.
+This argument will be removed in a future release. A deprecation warning is
+emitted when \code{cores} is passed explicitly (even \code{cores = 1}), when
+\code{options(mc.cores)} is set, or when the resolved value is \code{cores > 1}.
+When \code{cores > 1} and no \code{\link[mirai:daemons]{mirai::daemons()}} pool is connected, a per-call
+local daemon pool of that size is started for the duration of the call.
+Prefer \code{\link[mirai:daemons]{mirai::daemons()}} for session-level pools or \code{\link[=loo_mirai]{loo_mirai()}} for
+map-style workflows over many models.
+
+This defaults to \code{getOption("mc.cores", 1)}, but \strong{\code{options(mc.cores)} is
+also deprecated} and will be removed in a future release (it still works
+on this branch as a bridge to per-call daemon pools). \strong{As of version 2.0.0
+the default is 1 core when \code{mc.cores} is not set}.
 \itemize{
 \item Note for Windows 10 users: it is \strong{strongly}
 \href{https://github.com/stan-dev/loo/issues/94}{recommended} to avoid using
-the \code{.Rprofile} file to set \code{mc.cores} (using the \code{cores} argument or
-setting \code{mc.cores} interactively or in a script is fine).
-}}
+the \code{.Rprofile} file to set \code{mc.cores}.
+}
+
+See \code{vignette("loo2-parallel")} for the mirai-based replacement workflow.}
 
 \item{data, draws, ...}{For the \code{loo_approximate_posterior.function()} method,
 these are the data, posterior draws, and other arguments to pass to the
diff --git a/man/loo_mirai.Rd b/man/loo_mirai.Rd
new file mode 100644
index 00000000..a47426d0
--- /dev/null
+++ b/man/loo_mirai.Rd
@@ -0,0 +1,57 @@
+% Generated by roxygen2: do not edit by hand
+% Please edit documentation in R/parallel.R
+\name{loo_mirai}
+\alias{loo_mirai}
+\title{Run a \pkg{loo} function over argument lists in parallel with mirai}
+\usage{
+loo_mirai(fun, args_list, n_daemons = NULL)
+}
+\arguments{
+\item{fun}{A \pkg{loo} function (e.g. \code{\link[=loo]{loo()}}, \code{\link[=psis]{psis()}}) to apply to each
+element of \code{args_list}.}
+
+\item{args_list}{A list of lists. Each element is passed to \code{fun} via
+\code{do.call(fun, element)}.}
+
+\item{n_daemons}{Number of local daemons to start for this call. When
+\code{NULL} (the default), an existing \code{\link[mirai:daemons]{mirai::daemons()}} pool is reused if
+connected; otherwise the work runs serially. When an integer \verb{>= 2}, a
+local pool of that size is created for the duration of the call and
+torn down automatically when it returns (unless a pool was already
+connected, in which case it is reused and left untouched).}
+}
+\value{
+A list of results in the same order as \code{args_list}.
+}
+\description{
+Intended for map-style workflows such as computing \code{\link[=loo]{loo()}}, \code{\link[=psis]{psis()}}, or
+other \pkg{loo} functions for many models in one session.
+}
+\details{
+Parallelism is controlled by \code{loo_mirai()} (via \code{n_daemons} or an
+existing daemon pool), not by a \code{cores} argument on the mapped calls.
+Any \code{cores} element in \code{args_list} is deprecated, ignored, and replaced
+with \code{cores = 1} so each job runs serially on its worker.
+}
+\examples{
+r_eff <- relative_eff(exp(example_loglik_array()))
+ll_list <- list(example_loglik_matrix(), example_loglik_matrix())
+args_list <- lapply(ll_list, function(LL) {
+  list(log_ratios = -LL, r_eff = r_eff)
+})
+
+# Serial when no pool is connected and n_daemons is NULL
+loo_mirai(psis, args_list)
+
+\dontrun{
+# Convenience wrapper: start workers, map, tear down
+loo_mirai(psis, args_list, n_daemons = 2)
+
+# Or manage the pool yourself and call loo functions directly
+mirai::daemons(4)
+loo_mirai(loo, lapply(ll_list, function(LL) {
+  list(x = LL, r_eff = r_eff)
+}))
+mirai::daemons(0)
+}
+}
diff --git a/man/loo_model_weights.Rd b/man/loo_model_weights.Rd
index e7323912..52a53254 100644
--- a/man/loo_model_weights.Rd
+++ b/man/loo_model_weights.Rd
@@ -73,19 +73,26 @@ each model. See \code{\link[=psis]{psis()}} and  \code{\link[=relative_eff]{rela
 function for computing \code{r_eff}. If \code{x} is a list of \code{"psis_loo"}
 objects then \code{r_eff_list} is ignored.}
 
-\item{cores}{The number of cores to use for parallelization. This defaults to
-the option \code{mc.cores} which can be set for an entire R session by
-\code{options(mc.cores = NUMBER)}. The old option \code{loo.cores} is now
-deprecated but will be given precedence over \code{mc.cores} until
-\code{loo.cores} is removed in a future release. \strong{As of version
-2.0.0 the default is now 1 core if \code{mc.cores} is not set}, but we
-recommend using as many (or close to as many) cores as possible.
+\item{cores}{\strong{Deprecated.} The number of cores to use for parallelization.
+This argument will be removed in a future release. A deprecation warning is
+emitted when \code{cores} is passed explicitly (even \code{cores = 1}), when
+\code{options(mc.cores)} is set, or when the resolved value is \code{cores > 1}.
+When \code{cores > 1} and no \code{\link[mirai:daemons]{mirai::daemons()}} pool is connected, a per-call
+local daemon pool of that size is started for the duration of the call.
+Prefer \code{\link[mirai:daemons]{mirai::daemons()}} for session-level pools or \code{\link[=loo_mirai]{loo_mirai()}} for
+map-style workflows over many models.
+
+This defaults to \code{getOption("mc.cores", 1)}, but \strong{\code{options(mc.cores)} is
+also deprecated} and will be removed in a future release (it still works
+on this branch as a bridge to per-call daemon pools). \strong{As of version 2.0.0
+the default is 1 core when \code{mc.cores} is not set}.
 \itemize{
 \item Note for Windows 10 users: it is \strong{strongly}
 \href{https://github.com/stan-dev/loo/issues/94}{recommended} to avoid using
-the \code{.Rprofile} file to set \code{mc.cores} (using the \code{cores} argument or
-setting \code{mc.cores} interactively or in a script is fine).
-}}
+the \code{.Rprofile} file to set \code{mc.cores}.
+}
+
+See \code{vignette("loo2-parallel")} for the mirai-based replacement workflow.}
 
 \item{lpd_point}{If calling \code{stacking_weights()} or \code{pseudobma_weights()}
 directly, a matrix of pointwise leave-one-out (or K-fold) log likelihoods
diff --git a/man/loo_moment_match.Rd b/man/loo_moment_match.Rd
index 6b1f648d..8337dc7d 100644
--- a/man/loo_moment_match.Rd
+++ b/man/loo_moment_match.Rd
@@ -66,19 +66,26 @@ at the end of moment matching for each LOO fold.}
 samples or not. If \code{FALSE}, only the mean and marginal variances are
 matched.}
 
-\item{cores}{The number of cores to use for parallelization. This defaults to
-the option \code{mc.cores} which can be set for an entire R session by
-\code{options(mc.cores = NUMBER)}. The old option \code{loo.cores} is now
-deprecated but will be given precedence over \code{mc.cores} until
-\code{loo.cores} is removed in a future release. \strong{As of version
-2.0.0 the default is now 1 core if \code{mc.cores} is not set}, but we
-recommend using as many (or close to as many) cores as possible.
+\item{cores}{\strong{Deprecated.} The number of cores to use for parallelization.
+This argument will be removed in a future release. A deprecation warning is
+emitted when \code{cores} is passed explicitly (even \code{cores = 1}), when
+\code{options(mc.cores)} is set, or when the resolved value is \code{cores > 1}.
+When \code{cores > 1} and no \code{\link[mirai:daemons]{mirai::daemons()}} pool is connected, a per-call
+local daemon pool of that size is started for the duration of the call.
+Prefer \code{\link[mirai:daemons]{mirai::daemons()}} for session-level pools or \code{\link[=loo_mirai]{loo_mirai()}} for
+map-style workflows over many models.
+
+This defaults to \code{getOption("mc.cores", 1)}, but \strong{\code{options(mc.cores)} is
+also deprecated} and will be removed in a future release (it still works
+on this branch as a bridge to per-call daemon pools). \strong{As of version 2.0.0
+the default is 1 core when \code{mc.cores} is not set}.
 \itemize{
 \item Note for Windows 10 users: it is \strong{strongly}
 \href{https://github.com/stan-dev/loo/issues/94}{recommended} to avoid using
-the \code{.Rprofile} file to set \code{mc.cores} (using the \code{cores} argument or
-setting \code{mc.cores} interactively or in a script is fine).
-}}
+the \code{.Rprofile} file to set \code{mc.cores}.
+}
+
+See \code{vignette("loo2-parallel")} for the mirai-based replacement workflow.}
 }
 \value{
 The \code{loo_moment_match()} methods return an updated \code{loo} object. The
diff --git a/man/loo_moment_match_split.Rd b/man/loo_moment_match_split.Rd
index 91a6d826..8a0d2b40 100644
--- a/man/loo_moment_match_split.Rd
+++ b/man/loo_moment_match_split.Rd
@@ -52,19 +52,26 @@ on the unconstrained posterior draws passed via \code{upars}.}
 \item{r_eff_i}{MCMC relative effective sample size of the \code{i}'th log
 likelihood draws.}
 
-\item{cores}{The number of cores to use for parallelization. This defaults to
-the option \code{mc.cores} which can be set for an entire R session by
-\code{options(mc.cores = NUMBER)}. The old option \code{loo.cores} is now
-deprecated but will be given precedence over \code{mc.cores} until
-\code{loo.cores} is removed in a future release. \strong{As of version
-2.0.0 the default is now 1 core if \code{mc.cores} is not set}, but we
-recommend using as many (or close to as many) cores as possible.
+\item{cores}{\strong{Deprecated.} The number of cores to use for parallelization.
+This argument will be removed in a future release. A deprecation warning is
+emitted when \code{cores} is passed explicitly (even \code{cores = 1}), when
+\code{options(mc.cores)} is set, or when the resolved value is \code{cores > 1}.
+When \code{cores > 1} and no \code{\link[mirai:daemons]{mirai::daemons()}} pool is connected, a per-call
+local daemon pool of that size is started for the duration of the call.
+Prefer \code{\link[mirai:daemons]{mirai::daemons()}} for session-level pools or \code{\link[=loo_mirai]{loo_mirai()}} for
+map-style workflows over many models.
+
+This defaults to \code{getOption("mc.cores", 1)}, but \strong{\code{options(mc.cores)} is
+also deprecated} and will be removed in a future release (it still works
+on this branch as a bridge to per-call daemon pools). \strong{As of version 2.0.0
+the default is 1 core when \code{mc.cores} is not set}.
 \itemize{
 \item Note for Windows 10 users: it is \strong{strongly}
 \href{https://github.com/stan-dev/loo/issues/94}{recommended} to avoid using
-the \code{.Rprofile} file to set \code{mc.cores} (using the \code{cores} argument or
-setting \code{mc.cores} interactively or in a script is fine).
-}}
+the \code{.Rprofile} file to set \code{mc.cores}.
+}
+
+See \code{vignette("loo2-parallel")} for the mirai-based replacement workflow.}
 
 \item{is_method}{The importance sampling method to use. The following methods
 are implemented:
diff --git a/man/loo_subsample.Rd b/man/loo_subsample.Rd
index 6f381db6..1ee666fc 100644
--- a/man/loo_subsample.Rd
+++ b/man/loo_subsample.Rd
@@ -68,19 +68,26 @@ functions for help computing \code{r_eff}.}
 \item{save_psis}{Should the \code{"psis"} object created internally by
 \code{loo_subsample()} be saved in the returned object? See \code{\link[=loo]{loo()}} for details.}
 
-\item{cores}{The number of cores to use for parallelization. This defaults to
-the option \code{mc.cores} which can be set for an entire R session by
-\code{options(mc.cores = NUMBER)}. The old option \code{loo.cores} is now
-deprecated but will be given precedence over \code{mc.cores} until
-\code{loo.cores} is removed in a future release. \strong{As of version
-2.0.0 the default is now 1 core if \code{mc.cores} is not set}, but we
-recommend using as many (or close to as many) cores as possible.
+\item{cores}{\strong{Deprecated.} The number of cores to use for parallelization.
+This argument will be removed in a future release. A deprecation warning is
+emitted when \code{cores} is passed explicitly (even \code{cores = 1}), when
+\code{options(mc.cores)} is set, or when the resolved value is \code{cores > 1}.
+When \code{cores > 1} and no \code{\link[mirai:daemons]{mirai::daemons()}} pool is connected, a per-call
+local daemon pool of that size is started for the duration of the call.
+Prefer \code{\link[mirai:daemons]{mirai::daemons()}} for session-level pools or \code{\link[=loo_mirai]{loo_mirai()}} for
+map-style workflows over many models.
+
+This defaults to \code{getOption("mc.cores", 1)}, but \strong{\code{options(mc.cores)} is
+also deprecated} and will be removed in a future release (it still works
+on this branch as a bridge to per-call daemon pools). \strong{As of version 2.0.0
+the default is 1 core when \code{mc.cores} is not set}.
 \itemize{
 \item Note for Windows 10 users: it is \strong{strongly}
 \href{https://github.com/stan-dev/loo/issues/94}{recommended} to avoid using
-the \code{.Rprofile} file to set \code{mc.cores} (using the \code{cores} argument or
-setting \code{mc.cores} interactively or in a script is fine).
-}}
+the \code{.Rprofile} file to set \code{mc.cores}.
+}
+
+See \code{vignette("loo2-parallel")} for the mirai-based replacement workflow.}
 
 \item{loo_approximation}{What type of approximation of the loo_i's should be used?
 The default is \code{"plpd"} (the log predictive density using the posterior expectation).
diff --git a/man/parallel_psis_list.Rd b/man/parallel_psis_list.Rd
index f9c0224c..d6616791 100644
--- a/man/parallel_psis_list.Rd
+++ b/man/parallel_psis_list.Rd
@@ -63,19 +63,26 @@ This is useful if you plan to use the \code{\link[=E_loo]{E_loo()}} function to
 weighted expectations after running \code{loo}. Several functions in the
 \pkg{bayesplot} package also accept \code{psis} objects.}
 
-\item{cores}{The number of cores to use for parallelization. This defaults to
-the option \code{mc.cores} which can be set for an entire R session by
-\code{options(mc.cores = NUMBER)}. The old option \code{loo.cores} is now
-deprecated but will be given precedence over \code{mc.cores} until
-\code{loo.cores} is removed in a future release. \strong{As of version
-2.0.0 the default is now 1 core if \code{mc.cores} is not set}, but we
-recommend using as many (or close to as many) cores as possible.
+\item{cores}{\strong{Deprecated.} The number of cores to use for parallelization.
+This argument will be removed in a future release. A deprecation warning is
+emitted when \code{cores} is passed explicitly (even \code{cores = 1}), when
+\code{options(mc.cores)} is set, or when the resolved value is \code{cores > 1}.
+When \code{cores > 1} and no \code{\link[mirai:daemons]{mirai::daemons()}} pool is connected, a per-call
+local daemon pool of that size is started for the duration of the call.
+Prefer \code{\link[mirai:daemons]{mirai::daemons()}} for session-level pools or \code{\link[=loo_mirai]{loo_mirai()}} for
+map-style workflows over many models.
+
+This defaults to \code{getOption("mc.cores", 1)}, but \strong{\code{options(mc.cores)} is
+also deprecated} and will be removed in a future release (it still works
+on this branch as a bridge to per-call daemon pools). \strong{As of version 2.0.0
+the default is 1 core when \code{mc.cores} is not set}.
 \itemize{
 \item Note for Windows 10 users: it is \strong{strongly}
 \href{https://github.com/stan-dev/loo/issues/94}{recommended} to avoid using
-the \code{.Rprofile} file to set \code{mc.cores} (using the \code{cores} argument or
-setting \code{mc.cores} interactively or in a script is fine).
-}}
+the \code{.Rprofile} file to set \code{mc.cores}.
+}
+
+See \code{vignette("loo2-parallel")} for the mirai-based replacement workflow.}
 
 \item{method}{See \code{is_method} for \code{\link[=loo]{loo()}}}
 }
diff --git a/man/psis.Rd b/man/psis.Rd
index 534792d8..c2ea43a6 100644
--- a/man/psis.Rd
+++ b/man/psis.Rd
@@ -44,19 +44,26 @@ value is used for all observations) or a vector with length equal to the
 number of observations. The default value is 1. See the \code{\link[=relative_eff]{relative_eff()}}
 helper function for computing \code{r_eff}.}
 
-\item{cores}{The number of cores to use for parallelization. This defaults to
-the option \code{mc.cores} which can be set for an entire R session by
-\code{options(mc.cores = NUMBER)}. The old option \code{loo.cores} is now
-deprecated but will be given precedence over \code{mc.cores} until
-\code{loo.cores} is removed in a future release. \strong{As of version
-2.0.0 the default is now 1 core if \code{mc.cores} is not set}, but we
-recommend using as many (or close to as many) cores as possible.
+\item{cores}{\strong{Deprecated.} The number of cores to use for parallelization.
+This argument will be removed in a future release. A deprecation warning is
+emitted when \code{cores} is passed explicitly (even \code{cores = 1}), when
+\code{options(mc.cores)} is set, or when the resolved value is \code{cores > 1}.
+When \code{cores > 1} and no \code{\link[mirai:daemons]{mirai::daemons()}} pool is connected, a per-call
+local daemon pool of that size is started for the duration of the call.
+Prefer \code{\link[mirai:daemons]{mirai::daemons()}} for session-level pools or \code{\link[=loo_mirai]{loo_mirai()}} for
+map-style workflows over many models.
+
+This defaults to \code{getOption("mc.cores", 1)}, but \strong{\code{options(mc.cores)} is
+also deprecated} and will be removed in a future release (it still works
+on this branch as a bridge to per-call daemon pools). \strong{As of version 2.0.0
+the default is 1 core when \code{mc.cores} is not set}.
 \itemize{
 \item Note for Windows 10 users: it is \strong{strongly}
 \href{https://github.com/stan-dev/loo/issues/94}{recommended} to avoid using
-the \code{.Rprofile} file to set \code{mc.cores} (using the \code{cores} argument or
-setting \code{mc.cores} interactively or in a script is fine).
-}}
+the \code{.Rprofile} file to set \code{mc.cores}.
+}
+
+See \code{vignette("loo2-parallel")} for the mirai-based replacement workflow.}
 
 \item{x}{For \code{is.psis()}, an object to check.}
 }
diff --git a/man/psis_approximate_posterior.Rd b/man/psis_approximate_posterior.Rd
index a86300ed..3e59dbde 100644
--- a/man/psis_approximate_posterior.Rd
+++ b/man/psis_approximate_posterior.Rd
@@ -26,19 +26,26 @@ of observations and S is the number of samples from q. See
 \code{\link[=loo.matrix]{loo.matrix()}} for details. Default is \code{NULL}. Then only the
 posterior is evaluated using the k_hat diagnostic.}
 
-\item{cores}{The number of cores to use for parallelization. This defaults to
-the option \code{mc.cores} which can be set for an entire R session by
-\code{options(mc.cores = NUMBER)}. The old option \code{loo.cores} is now
-deprecated but will be given precedence over \code{mc.cores} until
-\code{loo.cores} is removed in a future release. \strong{As of version
-2.0.0 the default is now 1 core if \code{mc.cores} is not set}, but we
-recommend using as many (or close to as many) cores as possible.
+\item{cores}{\strong{Deprecated.} The number of cores to use for parallelization.
+This argument will be removed in a future release. A deprecation warning is
+emitted when \code{cores} is passed explicitly (even \code{cores = 1}), when
+\code{options(mc.cores)} is set, or when the resolved value is \code{cores > 1}.
+When \code{cores > 1} and no \code{\link[mirai:daemons]{mirai::daemons()}} pool is connected, a per-call
+local daemon pool of that size is started for the duration of the call.
+Prefer \code{\link[mirai:daemons]{mirai::daemons()}} for session-level pools or \code{\link[=loo_mirai]{loo_mirai()}} for
+map-style workflows over many models.
+
+This defaults to \code{getOption("mc.cores", 1)}, but \strong{\code{options(mc.cores)} is
+also deprecated} and will be removed in a future release (it still works
+on this branch as a bridge to per-call daemon pools). \strong{As of version 2.0.0
+the default is 1 core when \code{mc.cores} is not set}.
 \itemize{
 \item Note for Windows 10 users: it is \strong{strongly}
 \href{https://github.com/stan-dev/loo/issues/94}{recommended} to avoid using
-the \code{.Rprofile} file to set \code{mc.cores} (using the \code{cores} argument or
-setting \code{mc.cores} interactively or in a script is fine).
-}}
+the \code{.Rprofile} file to set \code{mc.cores}.
+}
+
+See \code{vignette("loo2-parallel")} for the mirai-based replacement workflow.}
 
 \item{save_psis}{Should the \code{psis} object created internally by \code{loo()} be
 saved in the returned object? The \code{loo()} function calls \code{\link[=psis]{psis()}}
diff --git a/man/psislw.Rd b/man/psislw.Rd
index 96371ba5..b79762ab 100644
--- a/man/psislw.Rd
+++ b/man/psislw.Rd
@@ -27,12 +27,10 @@ distribution.}
 to zero for no truncation.}
 
 \item{cores}{The number of cores to use for parallelization. This defaults to
-the option \code{mc.cores} which can be set for an entire R session by
-\code{options(mc.cores = NUMBER)}, the old option \code{loo.cores} is now
-deprecated but will be given precedence over \code{mc.cores} until it is
-removed. \strong{As of version 2.0.0, the default is now 1 core if
-\code{mc.cores} is not set, but we recommend using as many (or close to as
-many) cores as possible.}}
+the option \code{mc.cores}, which can be set for an entire R session by
+\code{options(mc.cores = NUMBER)}. \strong{As of version 2.0.0, the default is now 1
+core if \code{mc.cores} is not set, but we recommend using as many (or close to
+as many) cores as possible.}}
 
 \item{llfun, llargs}{See \code{\link[=loo.function]{loo.function()}}.}
 
diff --git a/man/sis.Rd b/man/sis.Rd
index d39af007..f8831374 100644
--- a/man/sis.Rd
+++ b/man/sis.Rd
@@ -33,19 +33,26 @@ draws of the \code{log_ratios} not obtained from MCMC then the warning
 message thrown when not specifying \code{r_eff} can be disabled by
 setting \code{r_eff} to \code{NA}.}
 
-\item{cores}{The number of cores to use for parallelization. This defaults to
-the option \code{mc.cores} which can be set for an entire R session by
-\code{options(mc.cores = NUMBER)}. The old option \code{loo.cores} is now
-deprecated but will be given precedence over \code{mc.cores} until
-\code{loo.cores} is removed in a future release. \strong{As of version
-2.0.0 the default is now 1 core if \code{mc.cores} is not set}, but we
-recommend using as many (or close to as many) cores as possible.
+\item{cores}{\strong{Deprecated.} The number of cores to use for parallelization.
+This argument will be removed in a future release. A deprecation warning is
+emitted when \code{cores} is passed explicitly (even \code{cores = 1}), when
+\code{options(mc.cores)} is set, or when the resolved value is \code{cores > 1}.
+When \code{cores > 1} and no \code{\link[mirai:daemons]{mirai::daemons()}} pool is connected, a per-call
+local daemon pool of that size is started for the duration of the call.
+Prefer \code{\link[mirai:daemons]{mirai::daemons()}} for session-level pools or \code{\link[=loo_mirai]{loo_mirai()}} for
+map-style workflows over many models.
+
+This defaults to \code{getOption("mc.cores", 1)}, but \strong{\code{options(mc.cores)} is
+also deprecated} and will be removed in a future release (it still works
+on this branch as a bridge to per-call daemon pools). \strong{As of version 2.0.0
+the default is 1 core when \code{mc.cores} is not set}.
 \itemize{
 \item Note for Windows 10 users: it is \strong{strongly}
 \href{https://github.com/stan-dev/loo/issues/94}{recommended} to avoid using
-the \code{.Rprofile} file to set \code{mc.cores} (using the \code{cores} argument or
-setting \code{mc.cores} interactively or in a script is fine).
-}}
+the \code{.Rprofile} file to set \code{mc.cores}.
+}
+
+See \code{vignette("loo2-parallel")} for the mirai-based replacement workflow.}
 }
 \value{
 The \code{sis()} methods return an object of class \code{"sis"},
diff --git a/man/tis.Rd b/man/tis.Rd
index 1747a64f..9f8f7eb6 100644
--- a/man/tis.Rd
+++ b/man/tis.Rd
@@ -35,19 +35,26 @@ value is used for all observations) or a vector with length equal to the
 number of observations. The default value is 1. See the \code{\link[=relative_eff]{relative_eff()}}
 helper function for computing \code{r_eff}.}
 
-\item{cores}{The number of cores to use for parallelization. This defaults to
-the option \code{mc.cores} which can be set for an entire R session by
-\code{options(mc.cores = NUMBER)}. The old option \code{loo.cores} is now
-deprecated but will be given precedence over \code{mc.cores} until
-\code{loo.cores} is removed in a future release. \strong{As of version
-2.0.0 the default is now 1 core if \code{mc.cores} is not set}, but we
-recommend using as many (or close to as many) cores as possible.
+\item{cores}{\strong{Deprecated.} The number of cores to use for parallelization.
+This argument will be removed in a future release. A deprecation warning is
+emitted when \code{cores} is passed explicitly (even \code{cores = 1}), when
+\code{options(mc.cores)} is set, or when the resolved value is \code{cores > 1}.
+When \code{cores > 1} and no \code{\link[mirai:daemons]{mirai::daemons()}} pool is connected, a per-call
+local daemon pool of that size is started for the duration of the call.
+Prefer \code{\link[mirai:daemons]{mirai::daemons()}} for session-level pools or \code{\link[=loo_mirai]{loo_mirai()}} for
+map-style workflows over many models.
+
+This defaults to \code{getOption("mc.cores", 1)}, but \strong{\code{options(mc.cores)} is
+also deprecated} and will be removed in a future release (it still works
+on this branch as a bridge to per-call daemon pools). \strong{As of version 2.0.0
+the default is 1 core when \code{mc.cores} is not set}.
 \itemize{
 \item Note for Windows 10 users: it is \strong{strongly}
 \href{https://github.com/stan-dev/loo/issues/94}{recommended} to avoid using
-the \code{.Rprofile} file to set \code{mc.cores} (using the \code{cores} argument or
-setting \code{mc.cores} interactively or in a script is fine).
-}}
+the \code{.Rprofile} file to set \code{mc.cores}.
+}
+
+See \code{vignette("loo2-parallel")} for the mirai-based replacement workflow.}
 }
 \value{
 The \code{tis()} methods return an object of class \code{"tis"},
diff --git a/man/update.psis_loo_ss.Rd b/man/update.psis_loo_ss.Rd
index eed2eb34..52857993 100644
--- a/man/update.psis_loo_ss.Rd
+++ b/man/update.psis_loo_ss.Rd
@@ -50,19 +50,26 @@ for all observations) or a vector with length equal to the number of
 observations. The default value is 1. See the \code{\link[=relative_eff]{relative_eff()}} helper
 functions for help computing \code{r_eff}.}
 
-\item{cores}{The number of cores to use for parallelization. This defaults to
-the option \code{mc.cores} which can be set for an entire R session by
-\code{options(mc.cores = NUMBER)}. The old option \code{loo.cores} is now
-deprecated but will be given precedence over \code{mc.cores} until
-\code{loo.cores} is removed in a future release. \strong{As of version
-2.0.0 the default is now 1 core if \code{mc.cores} is not set}, but we
-recommend using as many (or close to as many) cores as possible.
+\item{cores}{\strong{Deprecated.} The number of cores to use for parallelization.
+This argument will be removed in a future release. A deprecation warning is
+emitted when \code{cores} is passed explicitly (even \code{cores = 1}), when
+\code{options(mc.cores)} is set, or when the resolved value is \code{cores > 1}.
+When \code{cores > 1} and no \code{\link[mirai:daemons]{mirai::daemons()}} pool is connected, a per-call
+local daemon pool of that size is started for the duration of the call.
+Prefer \code{\link[mirai:daemons]{mirai::daemons()}} for session-level pools or \code{\link[=loo_mirai]{loo_mirai()}} for
+map-style workflows over many models.
+
+This defaults to \code{getOption("mc.cores", 1)}, but \strong{\code{options(mc.cores)} is
+also deprecated} and will be removed in a future release (it still works
+on this branch as a bridge to per-call daemon pools). \strong{As of version 2.0.0
+the default is 1 core when \code{mc.cores} is not set}.
 \itemize{
 \item Note for Windows 10 users: it is \strong{strongly}
 \href{https://github.com/stan-dev/loo/issues/94}{recommended} to avoid using
-the \code{.Rprofile} file to set \code{mc.cores} (using the \code{cores} argument or
-setting \code{mc.cores} interactively or in a script is fine).
-}}
+the \code{.Rprofile} file to set \code{mc.cores}.
+}
+
+See \code{vignette("loo2-parallel")} for the mirai-based replacement workflow.}
 
 \item{loo_approximation}{What type of approximation of the loo_i's should be used?
 The default is \code{"plpd"} (the log predictive density using the posterior expectation).
diff --git a/notes/mirai-usage.md b/notes/mirai-usage.md
new file mode 100644
index 00000000..6ce9e2ab
--- /dev/null
+++ b/notes/mirai-usage.md
@@ -0,0 +1,451 @@
+# Parallelization with mirai in other packages
+
+This document surveys how R packages that depend on **mirai** integrate it into 
+their workflows. The goal is to inform design choices for **loo** 
+(user-facing API) by comparing established patterns.
+
+## Summary
+
+Inspected packages fall into two broad approaches:
+
+| Approach | User experience | Examples |
+|----------|-------------------|----------|
+| **Wrapper API** | A `workers` (or similar) argument on a domain function; mirai stays internal | bakerrr, bregr, pliman, GitStats |
+| **Direct mirai** | Users call `mirai::daemons()` themselves, then use package functions unchanged | slideimp, worldmet, rush |
+| **Abstraction layer** | Another parallel framework (future, crew) uses mirai as a backend | chopin, crew |
+
+Most wrapper-style packages call `mirai::daemons(n)` before parallel work and 
+`mirai::daemons(0)` (or `on.exit`) afterward. Several also expose convenience 
+helpers so users never touch mirai directly.
+
+For **loo**, two complementary options are implemented:
+
+1. **Use mirai directly and document workflow** in a vignette
+
+```
+mirai::daemons(n)
+
+loo(...)
+
+mirai::daemons(0)
+```
+2. **Provide a thin convenience wrapper** for users who want parallel 
+map-style execution without managing daemons:
+
+```
+loo_mirai(fun, args_list, n_daemons = NULL)
+```
+
+The earlier third path (lazy session-scoped pools via `options(loo.daemons)` /
+`LOO_DAEMONS`) was removed in favor of direct mirai usage.
+
+
+## bakerrr
+
+- **GitHub:** https://github.com/anirbanshaw24/bakerrr
+- **Description:** {bakerrr} provides a clean, modern interface for running 
+background parallel jobs using S7 classes, mirai daemon(s), and callr process 
+management.
+- **Pattern:** High-level job API; `n_daemons` controls pool size 
+(default: `ceiling(cores/5)`).
+
+### Mirai example usage
+
+- `n_daemons` — number of parallel workers (default: ceiling of cores/5).
+
+#### API
+
+```
+# Define your function
+compute_sum <- function(x, y) {
+  Sys.sleep(1)  # Simulate work
+  x + y
+}
+
+# Create argument lists for each job
+args_list <- list(
+  list(x = 1, y = 2),
+  list(x = 3, y = 4),
+  list(x = 5, y = 6),
+  list(x = 7, y = 8)
+)
+
+# Create and run bakerrr job
+job <- bakerrr::bakerrr(
+  fun = compute_sum,
+  args_list = args_list,
+  n_daemons = 2
+) |> 
+  bakerrr::run_jobs(wait_for_results = TRUE)
+```
+
+#### Backend
+
+```
+mirai::daemons(n_daemons)
+  results <- purrr::imap(
+    jobs,
+    purrr::in_parallel(
+      \(x, y) {
+        tryCatch({
+          do.call(x$fun, x$args)
+        },
+        error = function(e) {
+          glue::glue(
+            "Error in purrr::in_parallel: {conditionMessage(e)}"
+          )
+        })
+      }
+    )
+  )
+mirai::daemons(0)
+```
+
+## bregr
+
+- **GitHub:** https://github.com/WangLabCSU/bregr
+- **Description:** The bregr package provides batch regression modeling 
+in R, enabling you to run hundreds of models simultaneously with a clean, 
+intuitive workflow.
+- **Pattern:** `n_workers` on the pipeline function; uses 
+`with(daemons(n_workers), mirai_map(...))` for parallel paths and serial `map()`
+ when `n_workers == 1`.
+
+### Mirai example usage
+
+- `n_workers` — integer number of workers to launch (default `1L`). When `> 1`, 
+modeling runs in parallel in the background.
+
+#### API
+
+```
+lung <- survival::lung |>
+  dplyr::filter(ph.ecog != 3)
+lung$ph.ecog <- factor(lung$ph.ecog)
+
+mds_p <- br_pipeline(
+  lung,
+  y = c("time", "status"),
+  x = colnames(lung)[6:10],
+  x2 = c("age", "sex"),
+  method = "coxph",
+  n_workers = 3
+)
+#> exponentiate estimates of model(s) constructed from coxph method at default
+#> ■■■■■■■                           20% | ETA: 13s
+#> 
+#> ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■  100% | ETA:  0s
+```
+
+#### Backend
+
+```
+if (n_workers > 1) {
+    res <- with(
+      mirai::daemons(n_workers),
+      {
+        mp <- mirai::mirai_map(
+          ms, runner_,
+          .args = list(
+            data = data, dots = dots,
+            opts = options()
+          )
+        )
+        mp[.progress]
+      }
+    )
+  } else {
+    res <- map(
+      ms, runner_,
+      data = data, dots = dots,
+      opts = options()
+    )
+  }
+```
+
+## chopin
+
+- **GitHub:** https://github.com/ropensci/chopin
+- **Description:** This package automates parallelization in spatial operations 
+with chopin functions as well as sf/terra functions.
+- **Pattern:** Offers both **future.mirai** 
+(`future::plan(future.mirai::mirai_multisession)`) and a `par_grid_mirai()` 
+that expects users to manage `mirai::daemons()` directly. 
+
+### Mirai example usage
+
+#### API
+
+```
+# Users always need to register multiple CPU threads (logical cores) for 
+# parallelization. 
+future::plan(future.mirai::mirai_multisession, workers = 4L)
+
+system.time(
+  ncpoints_srtm_mthr <-
+    par_grid(
+      grids = compregions,
+      fun_dist = extract_at,
+      x = srtm_ras,
+      y = ncpoints,
+      id = "pid",
+      radius = 1e4L,
+      .standalone = FALSE
+    )
+)
+
+# The same workflow operates on mirai dispatchers.
+mirai::daemons(4L)
+
+system.time(
+  ncpoints_srtm_mthr <-
+    par_grid_mirai(
+      grids = compregions,
+      fun_dist = extract_at,
+      x = srtm_ras,
+      y = ncpoints,
+      id = "pid",
+      radius = 1e4L,
+      .standalone = FALSE
+    )
+)
+
+mirai::daemons(0L)
+```
+
+## crew
+
+- **GitHub:** https://github.com/wlandau/crew/
+- **Description:** crew is a distributed computing framework with a centralized
+ interface and auto-scaling.
+- **Pattern:** Controller object (`crew_controller_local`) manages mirai client
+ lifecycle.
+
+### Mirai example usage
+
+#### API
+
+```
+controller <- crew_controller_local(
+  name = "example",
+  workers = 2,
+  seconds_idle = 10
+)
+
+# create the mirai client
+controller$start()
+
+# submit a new task
+controller$push(name = "get pid", command = ps::ps_pid())
+
+# return completed task
+task <- controller$pop()
+
+# clean-up resources
+controller$terminate()
+```
+#### Backend
+
+```
+crew_client <- function(...) {
+  ...
+  #' @description Start listening for workers on the available sockets.
+    #' @return `NULL` (invisibly).
+    start = function() {
+      if (!is.null(.started) && .started) {
+        return(invisible())
+      }
+      existing_url <- mirai::nextget("url", .compute = .profile)
+      crew_assert(
+        is.null(existing_url),
+        message = sprintf(
+          paste(
+            "{mirai} compute profile '%s' is already active at URL %s.",
+            "Each {crew} controller must have a unique compute profile",
+            "that does not conflict with",
+            "an existing call to mirai::daemons()."
+          ),
+          .profile,
+          existing_url
+        )
+      )
+      mirai::daemons(
+        url = .tls$url(host = .host, port = .port),
+        dispatcher = TRUE,
+        seed = NULL,
+        serial = .serialization,
+        tls = .tls$client(),
+        pass = .tls$password,
+        .compute = .profile
+      )
+      .url <<- mirai::nextget("url", .compute = .profile)
+      .relay$set_from(mirai::nextget(x = "cv", .compute = .profile))
+      .relay$start()
+      .started <<- TRUE
+      invisible()
+    },
+    #' @description Stop the mirai client and disconnect from the
+    #'   worker websockets.
+    #' @return `NULL` (invisibly).
+    terminate = function() {
+      mirai::daemons(n = 0L, .compute = .profile)
+      .relay$terminate()
+      .url <<- NULL
+      .started <<- FALSE
+      invisible()
+    },
+    ...
+}
+```
+
+## GitStats
+
+- **GitHub:** https://github.com/r-world-devs/GitStats/tree/4942e5e569d18ea7064bba0901561e26265c0f8b
+- **Description:** Obtain standardized data from multiple 'Git' services, 
+including 'GitHub' and 'GitLab'.
+
+### Mirai example usage
+
+#### API
+
+```
+git_stats |>
+  set_parallel()
+  
+```
+#### Backend
+
+```
+set_parallel = function(workers = 10L) {
+      if (isFALSE(workers) || identical(workers, 0L) || identical(workers, 0)) {
+        status <- mirai::daemons(0)
+        private$settings$parallel <- FALSE
+        cli::cli_alert_info("Parallel processing disabled.")
+      } else {
+        if (isTRUE(workers)) {
+          workers <- parallel::detectCores(logical = FALSE)
+          if (is.na(workers) || workers < 2L) workers <- 2L
+        }
+        status <- mirai::daemons(workers)
+        ns <- asNamespace("GitStats")
+        ns_objects <- as.list(ns, all.names = TRUE)
+        do.call(mirai::everywhere, c(list(quote({})), ns_objects))
+        private$settings$parallel <- TRUE
+        cli::cli_alert_success(
+          "Parallel processing enabled with {workers} workers."
+        )
+      }
+      return(invisible(status))
+    },
+  ...
+```
+
+## pliman
+
+- **GitHub:** https://github.com/NEPEM-UFSC/pliman
+- **Description:** Tools for both single and batch image manipulation and 
+analysis and phytopathometry.
+- **Pattern:** `parallel` + `workers` arguments on `measure_injury()`; 
+`on.exit(daemons(0))` ensures cleanup even on error. Default worker count is 
+`trunc(detectCores() * 0.3)`.
+
+### Mirai example usage
+
+#### Backend
+
+```
+measure_injury <- function(..., parallel = FALSE, workers = NULL, verbose = TRUE) {
+  ...
+  init_time <- Sys.time()
+
+  if (parallel) {
+    # setup
+    # capture start time
+    init_time <- Sys.time()
+
+    # decide number of workers
+    nworkers <- if (is.null(workers)) trunc(parallel::detectCores() * 0.3) else workers
+
+    # start mirai daemons
+    mirai::daemons(nworkers)
+    on.exit(mirai::daemons(0), add = TRUE)
+    ...
+    # run all images in parallel
+    raw <- mirai::mirai_map(
+      .x = files,
+      .f = process_image
+    )[.progress]
+  }
+  ...
+}
+```
+
+## rush
+
+- **GitHub:** https://github.com/mlr-org/rush
+- **Description:** Package designed to solve large-scale problems 
+asynchronously across a distributed network.
+- **Pattern:** user starts `mirai::daemons()` and `rush$start_workers()` 
+separately. 
+
+### Mirai example usage
+
+#### API
+
+```
+config = redux::redis_config()
+rush = rsh(network_id = "my_network", config = config)
+
+mirai::daemons(n = 2L)
+
+rush$start_workers(
+  worker_loop = worker_loop,
+  n_workers = 2L)
+  
+rush$fetch_finished_tasks()
+  
+rush$stop_workers(type = "kill")
+```
+
+## slideimp
+
+- **GitHub:** https://github.com/hhp94/slideimp
+- **Description:** KNN and PCA Imputation of Numeric Data.
+- **Pattern:** Documentation tells users to call `mirai::daemons(n)` before 
+tuning functions and `mirai::daemons(0)` when finished. No `workers` argument 
+on the package API — parallelization is entirely user-driven.
+
+### Mirai example usage
+
+#### API
+
+```
+mirai::daemons(2) # 2 Cores
+
+# PCA imputation.
+pca_params <- data.frame(ncp = c(1, 5))
+# For machines with multi-threaded BLAS, turn on `pin_blas = TRUE`
+tune_pca <- tune_imp(obj, parameters = pca_params, .f = "pca_imp", n_reps = 10, 
+num_na = 50)
+
+mirai::daemons(0) # Close daemons
+```
+
+## worldmet
+
+- **GitHub:** https://github.com/openair-project/worldmet
+- **Description:** Open source tools to access NOAA meteorological observations.
+- **Pattern:** Same as slideimp: set daemons once per session; import functions 
+work unchanged when a pool is active.
+
+### Mirai example usage
+
+#### API
+
+```
+# set workers - once per session
+mirai::daemons(4)
+
+# import lots of data - NB: no change in import_ghcn_hourly()!
+big_met <- import_ghcn_hourly(code = "UKI0000EGLL", year = 2010:2025)
+```
diff --git a/tests/testthat/_snaps/loo_and_waic.md b/tests/testthat/_snaps/loo_and_waic.md
index 018b6d98..51d2aa35 100644
--- a/tests/testthat/_snaps/loo_and_waic.md
+++ b/tests/testthat/_snaps/loo_and_waic.md
@@ -1,54 +1,54 @@
 # loo, waic and elpd results haven't changed
 
-    WAoAAAACAAQFAAACAwAAAAMTAAAACgAAAg4AAAAGwFTltnf8GWZACqFzqDCa8kBk5bZ3/Blm
-    QBEipbqh/pI/8m8Dok+RiEAhIqW6of6SAAAEAgAAAAEABAAJAAAAA2RpbQAAAA0AAAACAAAA
+    WAoAAAACAAQGAQACAwAAAAMTAAAACgAAAg4AAAAGwFTltnf8GWhACqFzqDCbAEBk5bZ3/Blo
+    QBEipbqh/pA/8m8Dok+Rg0AhIqW6of6QAAAEAgAAAAEABAAJAAAAA2RpbQAAAA0AAAACAAAA
     AwAAAAIAAAQCAAAAAQAEAAkAAAAIZGltbmFtZXMAAAATAAAAAgAAABAAAAADAAQACQAAAAhl
     bHBkX2xvbwAEAAkAAAAFcF9sb28ABAAJAAAABWxvb2ljAAAAEAAAAAIABAAJAAAACEVzdGlt
     YXRlAAQACQAAAAJTRQAAAP4AAAIOAAAAoMAC+fJnaLHwwAEP7abtCtDAArJiAQQUDsABa6HW
-    xx3swAC19bRGOqbAAOVsk57EhMAHXE6oz8X6wAhOMwo4HzjAAxWJEz7wYMAAvCuQLdoawAEz
-    +EIq/LDAARqnVc5fZMAAuMi8GPlmwAJBKzhjQ9zAAe5YKyVuTsADlXoqYwIGwBIRlu/H12/A
+    xx3swAC19bRGOqbAAOVsk57EhMAHXE6oz8X6wAhOMwo4HzjAAxWJEz7wXsAAvCuQLdoawAEz
+    +EIq/LDAARqnVc5fZMAAuMi8GPlmwAJBKzhjQ9zAAe5YKyVuUsADlXoqYwIGwBIRlu/H127A
     E/WagapcWsACpJaoNucYwBLYLgxdc6fAA7rSrp1oIMAEf9XEej+SwAa4oZCQGv7ABf5oQger
-    6sADXWMppHVuwAEJEltQ9nLAAOaxVhD86sAB7SPP8uDQwAnDIjSfxULABAp5a+6r9sAFJHaV
-    7SH8wAEph84QBEw/eQDDaV43ET9xp+BQBCmTP3qfwKytXZ0/ctyOXeTxzz9xqi9N9aR4P3IZ
+    6sADXWMppHVuwAEJEltQ9nLAAOaxVhD86sAB7SPP8uDawAnDIjSfxULABAp5a+6r9sAFJHaV
+    7SH8wAEph84QBFA/eQDDaV43ET9xp+BQBCmTP3qfwKytXZ0/ctyOXeTxzz9xqi9N9aR4P3IZ
     d1RCmrs/hDyfFGZAlj+GNSCYztY2P3e6iLhToUY/cX4fUwwY4j9yNONK++tcP3MW2+Teir8/
     chrQtYH1VT94S/hkJOXvP4KGRiL5AqY/jR2tM+V2kj+xFwrjXj1kP6T55+1SS6g/h0J5DiSH
     Lz+l12L3soNYP36Eg9WZBwg/fE5degjr7j+CgjOtLdigP4MAE38XAjM/efuEjSOY2z938dyR
     QJQSP3UOviSS5E0/hJj7+xYimz+KmFtUHEseP3x0d1lSXvQ/fyjSq08iSD9x5Q1KokZ4P6BC
     0qXNAwA/kYGquy8AAD+imuIOTvsAP5NUpOQ/eAA/kQtugOBEAD+RMeghdl4AP7Jn3QxtCsA/
-    tE9QFCi4gD+bSeGjWlIAP5FVoLo7XwA/kbVn03S8AD+Ui/4kS28AP5F+F0mQ2wA/mP14d7y0
-    AD+pRBELXxKAP7xVzQoMgYA/6p0tx9H/CD/kuDZpjnkQP7DPsKVRKQA/5Y1g8Rh9sD+m1FBE
+    tE9QFCi4gD+bSeGjWlEAP5FVoLo7XwA/kbVn03S8AD+Ui/4kS28AP5F+F0mQ2wA/mP14d7y0
+    AD+pRBELXxOAP7xVzQoMgYA/6p0tx9H/AD/kuDZpjnkQP7DPsKVRKQA/5Y1g8Rh9sD+m1FBE
     ZMYAP6LmZaqjsIA/rvRkyt/1gD+wN1KCt4TAP6FZe4TNQ4A/lxkATIN0AD+UCq5AO8gAP6ku
-    qlvkC4A/u837aXIIAD+joD1aCLQAP6afX0AzCAA/khQ6CvIGAEAS+fJnaLHwQBEP7abtCtBA
+    qlvkDgA/u837aXIIAD+joD1aCLQAP6afX0AzCAA/khQ6CvIIAEAS+fJnaLHwQBEP7abtCtBA
     ErJiAQQUDkARa6HWxx3sQBC19bRGOqZAEOVsk57EhEAXXE6oz8X6QBhOMwo4HzhAExWJEz7w
-    YEAQvCuQLdoaQBEz+EIq/LBAERqnVc5fZEAQuMi8GPlmQBJBKzhjQ9xAEe5YKyVuTkATlXoq
-    YwIGQCIRlu/H129AI/WagapcWkASpJaoNucYQCLYLgxdc6dAE7rSrp1oIEAUf9XEej+SQBa4
-    oZCQGv5AFf5oQger6kATXWMppHVuQBEJEltQ9nJAEOaxVhD86kAR7SPP8uDQQBnDIjSfxUJA
-    FAp5a+6r9kAVJHaV7SH8QBEph84QBEw/qQv9LeIWyb+uWWyqUA9QP7GREVrajU6/qkhYWDHd
-    rL+9tsdoV7uMv7fBKJv14eU/t7YcNUPKsT/aTE3zYuljP6G3mVtQiba/vp1jR9XXbb+gLW87
-    Hw2mv7FTEHhMvSa/sxFLk3EUuz+5A6XuSljYP9idj04idy4/0bL+IIz1RT/e15NGvsbPP9VS
-    jdQVlsE/2LoPMwLTfD/U+wQrF7IQP6aKY3Lc//Q/zQFaAA69qT+4Rrgot4/8P8jynnS82Ey/
-    nP2U9Wg1Vj+9sDYbFcUYP4hK+zwAbv4/1HzUh2soqj/D6wM3SdjbP7XPnkuMip4/xNfwCK9V
-    Jj+1oylZVifyAAAEAgAAAf8AAAANAAAAAgAAACAAAAAFAAAEAgAAAv8AAAATAAAAAgAAAP4A
+    XkAQvCuQLdoaQBEz+EIq/LBAERqnVc5fZEAQuMi8GPlmQBJBKzhjQ9xAEe5YKyVuUkATlXoq
+    YwIGQCIRlu/H125AI/WagapcWkASpJaoNucYQCLYLgxdc6dAE7rSrp1oIEAUf9XEej+SQBa4
+    oZCQGv5AFf5oQger6kATXWMppHVuQBEJEltQ9nJAEOaxVhD86kAR7SPP8uDaQBnDIjSfxUJA
+    FAp5a+6r9kAVJHaV7SH8QBEph84QBFA/qQv9LeIWWL+uWWyqUBB0P7GREVrajQO/qkhYWDHd
+    p7+9tsdoV7yPv7fBKJv14XY/t7YcNUPKlD/aTE3zYulDP6G3mVtQig2/vp1jR9XX0b+gLW87
+    Hw2jv7FTEHhMvT2/sxFLk3EU8D+5A6XuSlkgP9idj04idtI/0bL+IIz1NT/e15NGvsZcP9VS
+    jdQVlrw/2LoPMwLTbj/U+wQrF7IVP6aKY3LdABo/zQFaAA69lT+4Rrgot4+MP8jynnS82GS/
+    nP2U9Wg06j+9sDYbFcUWP4hK+zwAbhI/1HzUh2soVD/D6wM3SdkcP7XPnkuMis0/xNfwCK9U
+    2T+1oylZVifvAAAEAgAAAf8AAAANAAAAAgAAACAAAAAFAAAEAgAAAv8AAAATAAAAAgAAAP4A
     AAAQAAAABQAEAAkAAAAIZWxwZF9sb28ABAAJAAAADW1jc2VfZWxwZF9sb28ABAAJAAAABXBf
     bG9vAAQACQAAAAVsb29pYwAEAAkAAAASaW5mbHVlbmNlX3BhcmV0b19rAAAA/gAAAhMAAAAD
-    AAAADgAAACA/qQv9LeIWyb+uWWyqUA9QP7GREVrajU6/qkhYWDHdrL+9tsdoV7uMv7fBKJv1
-    4eU/t7YcNUPKsT/aTE3zYuljP6G3mVtQiba/vp1jR9XXbb+gLW87Hw2mv7FTEHhMvSa/sxFL
-    k3EUuz+5A6XuSljYP9idj04idy4/0bL+IIz1RT/e15NGvsbPP9VSjdQVlsE/2LoPMwLTfD/U
-    +wQrF7IQP6aKY3Lc//Q/zQFaAA69qT+4Rrgot4/8P8jynnS82Ey/nP2U9Wg1Vj+9sDYbFcUY
-    P4hK+zwAbv4/1HzUh2soqj/D6wM3SdjbP7XPnkuMip4/xNfwCK9VJj+1oylZVifyAAAADgAA
-    ACBAjGtR4vOUSECNSIXMZdptQI1OzHDwC35AjCl3nEfMhECMV+BQfP7MQItWfnwINa1Aipoa
-    +DhXG0CJ4jnKlWa8QIp1d1J1ZG1AjUahmmkFkkCL5UfgNu4DQI2abt7PHcNAi6rgACII5UCH
-    F8533XLIQIiixsC750JAiRWGP5WHBUBkAZfpVM1eQHdzaroEDUlAhbbxJuuvP0B2G3GedgHa
+    AAAADgAAACA/qQv9LeIWWL+uWWyqUBB0P7GREVrajQO/qkhYWDHdp7+9tsdoV7yPv7fBKJv1
+    4XY/t7YcNUPKlD/aTE3zYulDP6G3mVtQig2/vp1jR9XX0b+gLW87Hw2jv7FTEHhMvT2/sxFL
+    k3EU8D+5A6XuSlkgP9idj04idtI/0bL+IIz1NT/e15NGvsZcP9VSjdQVlrw/2LoPMwLTbj/U
+    +wQrF7IVP6aKY3LdABo/zQFaAA69lT+4Rrgot4+MP8jynnS82GS/nP2U9Wg06j+9sDYbFcUW
+    P4hK+zwAbhI/1HzUh2soVD/D6wM3SdkcP7XPnkuMis0/xNfwCK9U2T+1oylZVifvAAAADgAA
+    ACBAjGtR4vOUSECNSIXMZdptQI1OzHDwC35AjCl3nEfMgkCMV+BQfP7EQItWfnwINa1Aipoa
+    +DhXG0CJ4jnKlWa8QIp1d1J1ZHBAjUahmmkFkkCL5UfgNu4DQI2abt7PHcNAi6rgACII5UCH
+    F8533XLHQIiixsC750RAiRWGP5WHBUBkAZfpVM1YQHdzaroEDU5AhbbxJuuvP0B2G3GedgHa
     QIurDxL70Z1AimK5GPqZQ0CKb2AkeCpMQIqX6UZQkVlAjPSaSuWUT0CGV1Ue/HaIQIgmSdq8
-    SDtAhKKy2922NECIf2FmaiksQIrvm5gPU99AioGA+OUNHUCNhdwLjHhJAAAADgAAACA/7iIj
-    iprtpD/uhgpFxKUzP+9C2+HteTo/7WeuRVdLxz/thpx9PZyZP+x8NVYA5gc/7bgj+feDuD/t
-    VJY/ijqGP+vk6tOVjqc/7oFMRnLCAz/tFUhNscONP+71S5Zdfro/7NXCRLX3pz/oSat+OPKu
-    P+rzPc6+kK4/7rBYQ1wZPj/h+KYWRg06P/BP+OJ7Frg/6GyNUDLmvD/v8/5XaLpuP+3Om11x
+    SDtAhKKy2922MkCIf2FmaiksQIrvm5gPU99AioGA+OUNHUCNhdwLjHhJAAAADgAAACA/7iIj
+    iprtpD/uhgpFxKUzP+9C2+HteTo/7WeuRVdLxz/thpx9PZyRP+x8NVYA5gc/7bgj+feDuD/t
+    VJY/ijqGP+vk6tOVjqo/7oFMRnLCAz/tFUhNscONP+71S5Zdfro/7NXCRLX3pz/oSat+OPKu
+    P+rzPc6+kK4/7rBYQ1wZPj/h+KYWRg06P/BP+OJ7Frs/6GyNUDLmvD/v8/5XaLpuP+3Om11x
     ZMc/7CaGH4VipT/tF1NNe4n9P+1mF6TWIdc/7s96p0MNpT/ndID3UIhJP+lAQASVPCI/5qSP
-    laOkhD/s9t8Xe5GFP+zJwNIA1oY/7It81CYJlj/uynC4minDAAAEAgAAAAEABAAJAAAABW5h
+    laOkgj/s9t8Xe5GFP+zJwNIA1oY/7It81CYJlj/uynC4minDAAAEAgAAAAEABAAJAAAABW5h
     bWVzAAAAEAAAAAMABAAJAAAACHBhcmV0b19rAAQACQAAAAVuX2VmZgAEAAkAAAAFcl9lZmYA
-    AAD+AAAA/gAAAA4AAAABwFTltnf8GWYAAAAOAAAAAUAKoXOoMJryAAAADgAAAAFAZOW2d/wZ
-    ZgAAAA4AAAABQBEipbqh/pIAAAAOAAAAAT/ybwOiT5GIAAAADgAAAAFAISKluqH+kgAABAIA
+    AAD+AAAA/gAAAA4AAAABwFTltnf8GWgAAAAOAAAAAUAKoXOoMJsAAAAADgAAAAFAZOW2d/wZ
+    aAAAAA4AAAABQBEipbqh/pAAAAAOAAAAAT/ybwOiT5GDAAAADgAAAAFAISKluqH+kAAABAIA
     AAP/AAAAEAAAAAoABAAJAAAACWVzdGltYXRlcwAEAAkAAAAJcG9pbnR3aXNlAAQACQAAAAtk
     aWFnbm9zdGljcwAEAAkAAAALcHNpc19vYmplY3QABAAJAAAACGVscGRfbG9vAAQACQAAAAVw
     X2xvbwAEAAkAAAAFbG9vaWMABAAJAAAAC3NlX2VscGRfbG9vAAQACQAAAAhzZV9wX2xvbwAE
@@ -58,7 +58,7 @@
 
 ---
 
-    WAoAAAACAAQFAAACAwAAAAMTAAAACAAAAg4AAAAGwFTh8N3JQlhACijAYdW5U0Bk4fDdyUJY
+    WAoAAAACAAQGAQACAwAAAAMTAAAACAAAAg4AAAAGwFTh8N3JQlhACijAYdW5U0Bk4fDdyUJY
     QBEIPbMRcF8/8f1l7HLzXkAhCD2zEXBfAAAEAgAAAAEABAAJAAAAA2RpbQAAAA0AAAACAAAA
     AwAAAAIAAAQCAAAAAQAEAAkAAAAIZGltbmFtZXMAAAATAAAAAgAAABAAAAADAAQACQAAAAll
     bHBkX3dhaWMABAAJAAAABnBfd2FpYwAEAAkAAAAEd2FpYwAAABAAAAACAAQACQAAAAhFc3Rp
@@ -88,7 +88,7 @@
 
 ---
 
-    WAoAAAACAAQFAAACAwAAAAMTAAAAAgAAAg4AAAAEwFQQqtq6lJBAZBCq2rqUkEAJ4d/NRDUI
+    WAoAAAACAAQGAQACAwAAAAMTAAAAAgAAAg4AAAAEwFQQqtq6lJBAZBCq2rqUkEAJ4d/NRDUI
     QBnh381ENQgAAAQCAAAAAQAEAAkAAAADZGltAAAADQAAAAIAAAACAAAAAgAABAIAAAABAAQA
     CQAAAAhkaW1uYW1lcwAAABMAAAACAAAAEAAAAAIABAAJAAAABGVscGQABAAJAAAAAmljAAAA
     EAAAAAIABAAJAAAACEVzdGltYXRlAAQACQAAAAJTRQAAAP4AAAIOAAAAQMACuOcc0X3kwADs
diff --git a/tests/testthat/test_0_helpers.R b/tests/testthat/test_0_helpers.R
index e17f3ec1..74910e2d 100644
--- a/tests/testthat/test_0_helpers.R
+++ b/tests/testthat/test_0_helpers.R
@@ -73,12 +73,12 @@ test_that("nlist works", {
 })
 
 test_that("loo_cores works", {
+  internal <- get(".loo_internal", envir = asNamespace("loo"))
+  internal$warned_cores_deprecated <- TRUE
+  on.exit({ internal$warned_cores_deprecated <- NULL }, add = TRUE)
+
   expect_equal(loo_cores(10), 10)
   options(mc.cores = 2)
+  on.exit(options(mc.cores = NULL), add = TRUE)
   expect_equal(loo_cores(getOption("mc.cores", 1)), 2)
-  options(mc.cores = 1)
-
-  options(loo.cores = 2)
-  expect_warning(expect_equal(loo_cores(10), 2), "deprecated")
-  options(loo.cores = NULL)
 })
diff --git a/tests/testthat/test_deprecated_extractors.R b/tests/testthat/test_deprecated_extractors.R
index 4cfda2f9..ce8a6a8e 100644
--- a/tests/testthat/test_deprecated_extractors.R
+++ b/tests/testthat/test_deprecated_extractors.R
@@ -1,4 +1,4 @@
-options(mc.cores = 1)
+options(mc.cores = NULL)
 set.seed(123)
 
 LLarr <- example_loglik_array()
diff --git a/tests/testthat/test_loo_and_waic.R b/tests/testthat/test_loo_and_waic.R
index 5cdc823e..6d379256 100644
--- a/tests/testthat/test_loo_and_waic.R
+++ b/tests/testthat/test_loo_and_waic.R
@@ -1,4 +1,4 @@
-options(mc.cores = 1)
+options(mc.cores = NULL)
 set.seed(123)
 
 LLarr <- example_loglik_array()
@@ -12,14 +12,6 @@ loo1 <- suppressWarnings(loo(LLarr, r_eff = r_eff_arr))
 waic1 <- suppressWarnings(waic(LLarr))
 elpd1 <- suppressWarnings(elpd(LLarr))
 
-test_that("using loo.cores is deprecated", {
-  options(mc.cores = NULL)
-  options(loo.cores = 1)
-  expect_warning(loo(LLarr, r_eff = r_eff_arr, cores = 2), "loo.cores")
-  options(loo.cores = NULL)
-  options(mc.cores = 1)
-})
-
 test_that("loo, waic and elpd results haven't changed", {
   expect_snapshot_value(loo1, style = "serialize")
   expect_snapshot_value(waic1, style = "serialize")
@@ -164,21 +156,6 @@ loo_with_mat <- loo(
   save_psis = TRUE
 )
 
-test_that("loo.cores deprecation warning works with function method", {
-  options(loo.cores = 1)
-  expect_warning(
-    loo(
-      llfun,
-      cores = 2,
-      data = data,
-      draws = draws,
-      r_eff = rep(1, nrow(data))
-    ),
-    "loo.cores"
-  )
-  options(loo.cores = NULL)
-})
-
 test_that("loo_i results match loo results for ith data point", {
   expect_no_warning(
     loo_i_val <- loo_i(i = 2, llfun = llfun, data = data, draws = draws),
diff --git a/tests/testthat/test_loo_moment_matching.R b/tests/testthat/test_loo_moment_matching.R
index f96ce70b..85cb4be3 100644
--- a/tests/testthat/test_loo_moment_matching.R
+++ b/tests/testthat/test_loo_moment_matching.R
@@ -1,4 +1,4 @@
-options(mc.cores = 1)
+options(mc.cores = NULL)
 
 set.seed(123)
 S <- 4000
diff --git a/tests/testthat/test_loo_subsampling.R b/tests/testthat/test_loo_subsampling.R
index 84e8d785..5c51007d 100644
--- a/tests/testthat/test_loo_subsampling.R
+++ b/tests/testthat/test_loo_subsampling.R
@@ -1,4 +1,9 @@
-options(mc.cores = 1)
+options(mc.cores = NULL)
+
+# Most tests here intentionally exercise the deprecated `cores` path; quiet the
+# once-per-session deprecation warning so parallel correctness remains testable.
+internal <- get(".loo_internal", envir = asNamespace("loo"))
+internal$warned_cores_deprecated <- TRUE
 
 test_that("overall loo_subampling works as expected (compared with loo) for diff_est", {
   set.seed(123)
diff --git a/tests/testthat/test_loo_subsampling_approximations.R b/tests/testthat/test_loo_subsampling_approximations.R
index e5a02d58..a30d6fe3 100644
--- a/tests/testthat/test_loo_subsampling_approximations.R
+++ b/tests/testthat/test_loo_subsampling_approximations.R
@@ -1,4 +1,4 @@
-options(mc.cores = 1)
+options(mc.cores = NULL)
 
 generate_test_elpd_dataset <- function() {
   N <- 10
diff --git a/tests/testthat/test_loo_subsampling_cases.R b/tests/testthat/test_loo_subsampling_cases.R
index 6bd244c0..0154ad53 100644
--- a/tests/testthat/test_loo_subsampling_cases.R
+++ b/tests/testthat/test_loo_subsampling_cases.R
@@ -1,4 +1,9 @@
-options(mc.cores = 1)
+options(mc.cores = NULL)
+
+# Most tests here intentionally exercise the deprecated `cores` path; quiet the
+# once-per-session deprecation warning so parallel correctness remains testable.
+internal <- get(".loo_internal", envir = asNamespace("loo"))
+internal$warned_cores_deprecated <- TRUE
 
 test_that("Test loo_subsampling and loo_approx with radon data", {
   skip_on_cran() # avoid going over time limit for tests
diff --git a/tests/testthat/test_parallel.R b/tests/testthat/test_parallel.R
new file mode 100644
index 00000000..8d4baf94
--- /dev/null
+++ b/tests/testthat/test_parallel.R
@@ -0,0 +1,417 @@
+options(mc.cores = NULL)
+set.seed(123)
+
+# Make sure no daemon pool leaks in from another test file.
+mirai::daemons(0)
+
+# Most tests here intentionally exercise the deprecated `cores` path; quiet the
+# once-per-session deprecation warning so parallel correctness remains testable.
+internal <- get(".loo_internal", envir = asNamespace("loo"))
+internal$warned_cores_deprecated <- TRUE
+
+LLarr <- example_loglik_array()
+LLmat <- example_loglik_matrix()
+chain_id <- rep(1:2, each = dim(LLarr)[1])
+r_eff <- relative_eff(exp(LLarr))
+
+# Shared data for the function-method end-to-end checks.
+set.seed(1)
+S_fn <- 200
+N_fn <- 30
+draws_fn <- cbind(mu = rnorm(S_fn), sigma = abs(rnorm(S_fn)) + 0.5)
+data_fn <- data.frame(y = rnorm(N_fn))
+llfun_test <- function(data_i, draws, ...) {
+  dnorm(data_i$y, mean = draws[, "mu"], sd = draws[, "sigma"], log = TRUE)
+}
+
+
+# Pool-introspection helpers -------------------------------------------------
+
+test_that("loo_has_pool() and loo_pool_is_local() detect a local pool", {
+  mirai::daemons(0)
+  expect_false(loo:::loo_has_pool())
+  expect_false(loo:::loo_pool_is_local())
+
+  skip_on_cran()
+  mirai::daemons(2)
+  on.exit(mirai::daemons(0), add = TRUE)
+  expect_true(loo:::loo_has_pool())
+  expect_true(loo:::loo_pool_is_local())
+  # Chunking uses the connected daemon count, not the requested cores.
+  expect_equal(loo:::loo_n_workers(1), 2L)
+})
+
+test_that("loo_pool_is_local() is FALSE for a tcp pool (remote-safety gate)", {
+  skip_on_cran()
+  mirai::daemons(0)
+  mirai::daemons(n = 2, url = mirai::local_url(tcp = TRUE))
+  on.exit(mirai::daemons(0), add = TRUE)
+  # The locality gate reads the configured transport URL (available
+  # immediately, regardless of connection timing). tcp:// may be a remote/SSH
+  # pool, so shared memory must not be assumed.
+  expect_false(loo:::loo_pool_is_local())
+})
+
+
+# loo_map() ------------------------------------------------------------------
+
+test_that("loo_map() runs serially when no pool is available", {
+  mirai::daemons(0)
+  res <- loo:::loo_map(1:5, function(x, m) x * m, m = 2, cores = 4)
+  expect_identical(res, as.list((1:5) * 2))
+})
+
+test_that("loo_map() uses a connected pool regardless of cores", {
+  skip_on_cran()
+  mirai::daemons(2)
+  on.exit(mirai::daemons(0), add = TRUE)
+  # cores = 1 no longer forces serial: a connected pool always wins.
+  res <- loo:::loo_map(1:5, function(x, m) x * m, m = 3, cores = 1)
+  expect_identical(res, as.list((1:5) * 3))
+})
+
+test_that("loo_map() parallel matches serial and preserves order", {
+  skip_on_cran()
+  worker <- function(i, mat, add) sum(mat[, i]) + add
+  mat <- matrix(as.numeric(1:60), nrow = 6) # 6 x 10
+  N <- ncol(mat)
+  expected <- lapply(seq_len(N), worker, mat = mat, add = 100)
+
+  mirai::daemons(3)
+  on.exit(mirai::daemons(0), add = TRUE)
+
+  # broadcast object shared via mori on a local pool; both chunk strategies
+  res_auto <- loo:::loo_map(
+    seq_len(N), worker, add = 100, cores = 3,
+    broadcast = list(mat = mat), chunk = "auto"
+  )
+  res_never <- loo:::loo_map(
+    seq_len(N), worker, add = 100, cores = 3,
+    broadcast = list(mat = mat), chunk = "never"
+  )
+  expect_identical(res_auto, expected)
+  expect_identical(res_never, expected)
+})
+
+test_that("loo_map() works when there are more workers than elements", {
+  skip_on_cran()
+  mirai::daemons(4)
+  on.exit(mirai::daemons(0), add = TRUE)
+  res <- loo:::loo_map(1:2, function(x) x + 1L, cores = 4)
+  expect_identical(res, list(2L, 3L))
+})
+
+test_that("loo_map() propagates worker errors", {
+  skip_on_cran()
+  mirai::daemons(2)
+  on.exit(mirai::daemons(0), add = TRUE)
+  expect_error(
+    loo:::loo_map(1:4, function(x) if (x == 3L) stop("boom") else x, cores = 2),
+    "boom"
+  )
+})
+
+
+# End-to-end: importance sampling --------------------------------------------
+
+test_that("psis() parallel equals serial", {
+  skip_on_cran()
+  ps_serial <- suppressWarnings(psis(-LLmat, r_eff = r_eff, cores = 1))
+
+  mirai::daemons(2)
+  on.exit(mirai::daemons(0), add = TRUE)
+  ps_parallel <- suppressWarnings(psis(-LLmat, r_eff = r_eff, cores = 2))
+
+  expect_equal(ps_serial$log_weights, ps_parallel$log_weights)
+  expect_equal(ps_serial$diagnostics, ps_parallel$diagnostics)
+})
+
+test_that("tis() and sis() parallel equal serial", {
+  skip_on_cran()
+  tis_serial <- suppressWarnings(tis(-LLmat, r_eff = r_eff, cores = 1))
+  sis_serial <- suppressWarnings(sis(-LLmat, r_eff = r_eff, cores = 1))
+
+  mirai::daemons(2)
+  on.exit(mirai::daemons(0), add = TRUE)
+  tis_parallel <- suppressWarnings(tis(-LLmat, r_eff = r_eff, cores = 2))
+  sis_parallel <- suppressWarnings(sis(-LLmat, r_eff = r_eff, cores = 2))
+
+  expect_equal(tis_serial$log_weights, tis_parallel$log_weights)
+  expect_equal(sis_serial$log_weights, sis_parallel$log_weights)
+})
+
+
+# End-to-end: loo() function method (broadcast draws/data) -------------------
+
+test_that("loo.function parallel equals serial", {
+  skip_on_cran()
+  loo_serial <- suppressWarnings(
+    loo(llfun_test, data = data_fn, draws = draws_fn, cores = 1)
+  )
+
+  mirai::daemons(2)
+  on.exit(mirai::daemons(0), add = TRUE)
+  loo_parallel <- suppressWarnings(
+    loo(llfun_test, data = data_fn, draws = draws_fn, cores = 2)
+  )
+
+  expect_equal(loo_serial$pointwise, loo_parallel$pointwise)
+  expect_equal(loo_serial$estimates, loo_parallel$estimates)
+})
+
+test_that("loo.function reuses an existing (user-configured) pool", {
+  skip_on_cran()
+  loo_serial <- suppressWarnings(
+    loo(llfun_test, data = data_fn, draws = draws_fn, cores = 1)
+  )
+
+  # User sets up the pool themselves; loo should reuse it untouched.
+  mirai::daemons(3)
+  on.exit(mirai::daemons(0), add = TRUE)
+  loo_reuse <- suppressWarnings(
+    loo(llfun_test, data = data_fn, draws = draws_fn, cores = 2)
+  )
+  # Pool is still alive after the call (loo did not tear it down).
+  expect_true(loo:::loo_has_pool())
+  expect_equal(loo_serial$pointwise, loo_reuse$pointwise)
+})
+
+
+# End-to-end: relative_eff ---------------------------------------------------
+
+test_that("relative_eff() array and function methods are parallel-invariant", {
+  skip_on_cran()
+  re_arr_serial <- relative_eff(exp(LLarr), cores = 1)
+  re_fn_serial <- relative_eff(
+    llfun_test, chain_id = rep(1, S_fn),
+    data = data_fn, draws = draws_fn, cores = 1
+  )
+
+  mirai::daemons(2)
+  on.exit(mirai::daemons(0), add = TRUE)
+  re_arr_parallel <- relative_eff(exp(LLarr), cores = 2)
+  re_fn_parallel <- relative_eff(
+    llfun_test, chain_id = rep(1, S_fn),
+    data = data_fn, draws = draws_fn, cores = 2
+  )
+
+  expect_equal(re_arr_serial, re_arr_parallel)
+  expect_equal(re_fn_serial, re_fn_parallel)
+})
+
+
+# End-to-end: loo_subsample --------------------------------------------------
+
+test_that("loo_subsample() parallel equals serial", {
+  skip_on_cran()
+  # Reset RNG before each call so the same subsample is drawn.
+  set.seed(4242)
+  ss_serial <- suppressWarnings(loo_subsample(
+    llfun_test, data = data_fn, draws = draws_fn,
+    observations = 20, loo_approximation = "plpd", cores = 1
+  ))
+
+  mirai::daemons(2)
+  on.exit(mirai::daemons(0), add = TRUE)
+  set.seed(4242)
+  ss_parallel <- suppressWarnings(loo_subsample(
+    llfun_test, data = data_fn, draws = draws_fn,
+    observations = 20, loo_approximation = "plpd", cores = 2
+  ))
+
+  expect_equal(ss_serial$estimates, ss_parallel$estimates)
+  expect_equal(ss_serial$pointwise, ss_parallel$pointwise)
+})
+
+
+# End-to-end: loo_model_weights (single pool across K models) ----------------
+
+test_that("loo_model_weights() parallel equals serial", {
+  skip_on_cran()
+  set.seed(11)
+  ll_list <- list(
+    matrix(rnorm(200 * 25), nrow = 200),
+    matrix(rnorm(200 * 25), nrow = 200),
+    matrix(rnorm(200 * 25), nrow = 200)
+  )
+  wts_serial <- suppressWarnings(
+    loo_model_weights(ll_list, method = "stacking", cores = 1)
+  )
+
+  mirai::daemons(2)
+  on.exit(mirai::daemons(0), add = TRUE)
+  wts_parallel <- suppressWarnings(
+    loo_model_weights(ll_list, method = "stacking", cores = 2)
+  )
+
+  expect_equal(as.numeric(wts_serial), as.numeric(wts_parallel),
+               tolerance = 1e-6)
+})
+
+# loo_mirai() ---------------------------------------------------------------
+
+psis_args_list <- function(n = 2L) {
+  arg <- list(log_ratios = -LLmat, r_eff = r_eff)
+  replicate(n, arg, simplify = FALSE)
+}
+
+test_that("loo_mirai() runs psis serially when no pool is connected", {
+  mirai::daemons(0)
+  args_list <- psis_args_list()
+  expected <- suppressWarnings(lapply(args_list, function(a) do.call(psis, a)))
+  res <- suppressWarnings(loo_mirai(psis, args_list))
+  expect_equal(
+    lapply(res, `[[`, "log_weights"),
+    lapply(expected, `[[`, "log_weights")
+  )
+})
+
+test_that("loo_mirai() with n_daemons runs psis in parallel", {
+  skip_on_cran()
+  mirai::daemons(0)
+  on.exit(mirai::daemons(0), add = TRUE)
+  args_list <- psis_args_list()
+  serial <- suppressWarnings(lapply(args_list, function(a) do.call(psis, a)))
+  parallel <- suppressWarnings(loo_mirai(psis, args_list, n_daemons = 2))
+  expect_equal(
+    lapply(parallel, `[[`, "log_weights"),
+    lapply(serial, `[[`, "log_weights")
+  )
+})
+
+test_that("loo_mirai() reuses an existing pool for psis", {
+  skip_on_cran()
+  mirai::daemons(0)
+  mirai::daemons(2)
+  on.exit(mirai::daemons(0), add = TRUE)
+  args_list <- psis_args_list()
+  serial <- suppressWarnings(lapply(args_list, function(a) do.call(psis, a)))
+  res <- suppressWarnings(loo_mirai(psis, args_list))
+  expect_equal(
+    lapply(res, `[[`, "log_weights"),
+    lapply(serial, `[[`, "log_weights")
+  )
+  expect_true(loo:::loo_has_pool())
+})
+
+test_that("loo_mirai() warns when cores is passed in args_list", {
+  mirai::daemons(0)
+  internal <- get(".loo_internal", envir = asNamespace("loo"))
+  internal$warned_cores_in_mirai <- NULL
+  on.exit({ internal$warned_cores_in_mirai <- NULL }, add = TRUE)
+
+  args_list <- list(list(log_ratios = -LLmat, r_eff = r_eff, cores = 8L))
+  expect_warning(
+    loo_mirai(psis, args_list),
+    "args_list"
+  )
+})
+
+test_that("options(mc.cores) triggers a deprecation warning", {
+  mirai::daemons(0)
+  internal <- get(".loo_internal", envir = asNamespace("loo"))
+  internal$warned_cores_deprecated <- NULL
+  on.exit({ internal$warned_cores_deprecated <- NULL }, add = TRUE)
+
+  old_mc <- options(mc.cores = 1)
+  on.exit(options(old_mc), add = TRUE)
+
+  expect_warning(
+    psis(-LLmat, r_eff = r_eff),
+    "options\\('mc.cores'\\)"
+  )
+})
+
+test_that("options(mc.cores) > 1 still parallelizes (deprecated bridge)", {
+  skip_on_cran()
+  mirai::daemons(0)
+  on.exit(mirai::daemons(0), add = TRUE)
+
+  ps_serial <- suppressWarnings(psis(-LLmat, r_eff = r_eff, cores = 1))
+
+  internal <- get(".loo_internal", envir = asNamespace("loo"))
+  internal$warned_cores_deprecated <- NULL
+  on.exit({ internal$warned_cores_deprecated <- NULL }, add = TRUE)
+
+  old_mc <- options(mc.cores = 2)
+  on.exit(options(old_mc), add = TRUE)
+
+  expect_warning(
+    ps_parallel <- psis(-LLmat, r_eff = r_eff),
+    "will be removed in a future release"
+  )
+  expect_equal(ps_serial$log_weights, ps_parallel$log_weights)
+})
+
+test_that("explicit cores = 1 triggers a deprecation warning", {
+  mirai::daemons(0)
+  internal <- get(".loo_internal", envir = asNamespace("loo"))
+  internal$warned_cores_deprecated <- NULL
+  on.exit({ internal$warned_cores_deprecated <- NULL }, add = TRUE)
+
+  expect_warning(
+    psis(-LLmat, r_eff = r_eff, cores = 1),
+    "options\\('mc.cores'\\)|'cores' argument"
+  )
+})
+
+test_that("cores > 1 triggers a deprecation warning", {
+  mirai::daemons(0)
+  internal <- get(".loo_internal", envir = asNamespace("loo"))
+  internal$warned_cores_deprecated <- NULL
+  on.exit({ internal$warned_cores_deprecated <- NULL }, add = TRUE)
+
+  expect_warning(
+    psis(-LLmat, r_eff = r_eff, cores = 2),
+    "options\\('mc.cores'\\)|'cores' argument"
+  )
+})
+
+test_that("loo_mirai() validates inputs", {
+  expect_error(loo_mirai("not a function", list()), "'fun' must be a function")
+  expect_error(
+    loo_mirai(`+`, list(list(x = 1))),
+    "'fun' must be a loo function"
+  )
+  expect_error(loo_mirai(psis, "not a list"), "'args_list' must be a list")
+  expect_error(
+    loo_mirai(psis, list(list(log_ratios = -LLmat)), n_daemons = 0),
+    "'n_daemons' must be a single positive integer or NULL"
+  )
+})
+
+
+# with_loo_daemons() messaging -----------------------------------------------
+
+test_that("with_loo_daemons() informs (once) that cores is ignored with a pool", {
+  skip_on_cran()
+  mirai::daemons(0)
+  # Reset the once-per-session guard so this test is order-independent.
+  internal <- get(".loo_internal", envir = asNamespace("loo"))
+  internal$informed_cores_ignored <- NULL
+  on.exit({ internal$informed_cores_ignored <- NULL }, add = TRUE)
+
+  # No pool connected: cores = 1 runs serially without a message.
+  expect_silent(loo:::with_loo_daemons(1, 42))
+
+  mirai::daemons(2)
+  on.exit(mirai::daemons(0), add = TRUE)
+
+  # Pool connected and cores = 1: informs once that cores is ignored, and the
+  # value still comes back (work runs on the pool).
+  expect_message(
+    out <- loo:::with_loo_daemons(1, 42),
+    "'cores' is ignored"
+  )
+  expect_identical(out, 42)
+
+  # Message is emitted at most once per session.
+  expect_silent(loo:::with_loo_daemons(1, 42))
+
+  # cores > 1 with a pool never triggers the message (parallel was requested).
+  internal$informed_cores_ignored <- NULL
+  expect_silent(loo:::with_loo_daemons(2, 42))
+})
+
+# Final safety net in case any test above exited early with a live pool.
+mirai::daemons(0)
diff --git a/tests/testthat/test_psis.R b/tests/testthat/test_psis.R
index d43b6ed0..d2d97e7b 100644
--- a/tests/testthat/test_psis.R
+++ b/tests/testthat/test_psis.R
@@ -1,5 +1,4 @@
-options(mc.cores = 1)
-options(loo.cores = NULL)
+options(mc.cores = NULL)
 set.seed(123)
 
 LLarr <- example_loglik_array()
diff --git a/tests/testthat/test_relative_eff.R b/tests/testthat/test_relative_eff.R
index 195a2c47..224f1fbe 100644
--- a/tests/testthat/test_relative_eff.R
+++ b/tests/testthat/test_relative_eff.R
@@ -1,4 +1,4 @@
-options(mc.cores = 1)
+options(mc.cores = NULL)
 set.seed(123)
 
 LLarr <- example_loglik_array()
diff --git a/tests/testthat/test_tisis.R b/tests/testthat/test_tisis.R
index edfcbd3f..dae08d75 100644
--- a/tests/testthat/test_tisis.R
+++ b/tests/testthat/test_tisis.R
@@ -1,5 +1,4 @@
-options(mc.cores = 1)
-options(loo.cores = NULL)
+options(mc.cores = NULL)
 set.seed(123)
 
 LLarr <- example_loglik_array()
diff --git a/vignettes/loo2-example.Rmd b/vignettes/loo2-example.Rmd
index 2a5037a7..06dbaea2 100644
--- a/vignettes/loo2-example.Rmd
+++ b/vignettes/loo2-example.Rmd
@@ -23,6 +23,8 @@ params:
 This vignette demonstrates how to use the __loo__ package to carry out 
 Pareto smoothed importance-sampling leave-one-out cross-validation (PSIS-LOO) 
 for purposes of model checking and model comparison. 
+For parallel computation see `vignette("loo2-parallel")` (`mirai::daemons()` or
+`loo_mirai()`; the `cores` argument is deprecated but still works).
 
 In this vignette we can't provide all necessary background information on
 PSIS-LOO and its diagnostics (Pareto $k$ and effective sample size), so we
diff --git a/vignettes/loo2-large-data.Rmd b/vignettes/loo2-large-data.Rmd
index 0dadaf7e..9b6e7be0 100644
--- a/vignettes/loo2-large-data.Rmd
+++ b/vignettes/loo2-large-data.Rmd
@@ -23,7 +23,9 @@ params:
 
 This vignette demonstrates how to do leave-one-out cross-validation for large
 data using the __loo__ package and Stan. There are two approaches covered:
-LOO with subsampling and LOO using approximations to posterior distributions. 
+LOO with subsampling and LOO using approximations to posterior distributions.
+For parallel computation see `vignette("loo2-parallel")` (`mirai::daemons()` or
+`loo_mirai()`; the `cores` argument in examples below is a deprecated bridge).
 Some sections from this vignette are excerpted from the papers
 
 * Magnusson, M., Riis Andersen, M., Jonasson, J. and Vehtari, A. (2020). Leave-One-Out Cross-Validation for Model Comparison in Large Data.
diff --git a/vignettes/loo2-parallel.Rmd b/vignettes/loo2-parallel.Rmd
new file mode 100644
index 00000000..704863dd
--- /dev/null
+++ b/vignettes/loo2-parallel.Rmd
@@ -0,0 +1,261 @@
+---
+title: "Parallel and distributed loo"
+author: "The loo developers"
+date: "`r Sys.Date()`"
+output:
+  html_vignette:
+    toc: yes
+params:
+  EVAL: !r identical(Sys.getenv("NOT_CRAN"), "true")
+---
+<!--
+%\VignetteEngine{knitr::rmarkdown}
+%\VignetteIndexEntry{Parallel and distributed loo}
+-->
+```{r, child="children/SETTINGS-knitr.txt"}
+```
+
+```{r, child="children/SEE-ONLINE.txt", eval = if (isTRUE(exists("params"))) !params$EVAL else TRUE}
+```
+
+# Introduction
+
+Computing PSIS-LOO, WAIC, and related quantities is *embarrassingly parallel*:
+the expensive work is done once per observation (or per fold), and these
+computations are independent of one another. The __loo__ package can therefore
+spread this work across multiple cores or even multiple machines.
+
+As of __loo__ 2.10 the parallel backend is built on the
+[__mirai__](https://mirai.r-lib.org/) package, with
+[__mori__](https://mirai.r-lib.org/) providing zero-copy sharing of large
+objects (such as the posterior draws) between local workers. You do not need to
+learn mirai to benefit from parallelism, but understanding the recommended
+workflows (and the deprecated bridges) helps you pick the right approach:
+
+1. **A pool you manage yourself** with `mirai::daemons()` --- recommended for
+   repeated calls in one session and for remote/SSH/HPC workers. A connected
+   pool always takes precedence over deprecated parallel controls.
+2. **[loo_mirai()]** --- a convenience wrapper for map-style workflows over
+   many models (optional `n_daemons` argument).
+
+**Deprecated (still works, with a once-per-session warning):**
+
+* The `cores` argument on __loo__ functions (`cores > 1` starts a per-call
+  local pool when no mirai pool is connected).
+* `options(mc.cores)` as a session default for loo parallelism.
+
+Every __loo__ function that does per-observation work accepts a deprecated
+`cores` argument, including `loo()`, `psis()`, `waic()`, `relative_eff()`,
+`loo_subsample()`, `loo_moment_match()`, and `loo_model_weights()`.
+
+See `vignette("migration-guide")` for migration examples. The section
+[How deprecated `cores` / `mc.cores` interact with a pool](#how-deprecated-cores--mc.cores-interact-with-a-pool) spells
+out how deprecated controls interact with user-managed pools.
+
+# Setup
+
+The examples below only need the __loo__ package and its built-in example
+log-likelihood objects, so they are fast and self-contained.
+
+```{r setup, message=FALSE}
+library("loo")
+
+# A 500 (draws) x 2 (chains) x 32 (observations) log-likelihood array.
+LLarr <- example_loglik_array()
+r_eff <- relative_eff(exp(LLarr))
+```
+
+# 1. Deprecated per-call parallelism (`cores` and `mc.cores`)
+
+The `cores` argument and `options(mc.cores)` are **deprecated** and will be
+removed in a future release. They **still work** as a bridge:
+when the resolved core count is `> 1` and no mirai pool is connected, __loo__
+starts a local per-call daemon pool. A once-per-session deprecation warning is
+emitted if you pass `cores` explicitly (even `cores = 1`), if `options(mc.cores)`
+is set, or if the resolved value is `> 1`. Prefer `mirai::daemons()` or
+[loo_mirai()] for new code (Sections 2--3).
+
+```{r cores-basic}
+# Deprecated: explicit cores (warns once per session)
+loo_serial <- loo(LLarr, r_eff = r_eff, cores = 1)
+loo_parallel <- loo(LLarr, r_eff = r_eff, cores = 2)
+
+# Deprecated: session default via mc.cores (also warns once per session)
+# options(mc.cores = 2)
+# loo_via_mc <- loo(LLarr, r_eff = r_eff)
+```
+
+The results are identical --- parallelism only changes *how* the work is
+scheduled, never the answer:
+
+```{r cores-equal}
+all.equal(loo_serial$estimates, loo_parallel$estimates)
+```
+
+You can still set a session default with `options(mc.cores = k)` --- it remains currently
+functional but is deprecated for loo parallelism (use
+`mirai::daemons(k)` instead; see Section 2).
+
+Because the pool is created and destroyed on every call, this mode pays a small
+start-up/teardown cost each time. For a single analysis that cost is
+negligible, but if you call __loo__ functions repeatedly it can add up ---
+which is exactly what the next sections address.
+
+# 2. User-managed pools, including remote/HPC workers (recommended)
+
+If you configure a pool yourself with `mirai::daemons()`, __loo__ will **reuse
+it and never tear it down**. A user-managed pool always takes precedence over
+the `cores` per-call behavior, which makes it the right tool for repeated
+calls in one session and for **remote, SSH, or HPC cluster** workers.
+
+A local pool you manage by hand behaves like a persistent session pool. Because
+a connected pool always wins, you do not even need to pass `cores` --- __loo__
+uses the pool whatever `cores` is:
+
+```{r user-local, eval=FALSE}
+library(mirai)
+
+daemons(4)                       # start 4 local workers
+loo1 <- loo(LLarr, r_eff = r_eff) # reuses your pool (cores not needed)
+loo2 <- loo(LLarr, r_eff = r_eff) # reuses it again
+daemons(0)                       # you decide when to stop them
+```
+
+For distributed computing, point __mirai__ at remote machines or a cluster
+scheduler. __loo__ does not need to know any of the details --- it simply uses
+whatever pool is connected:
+
+```{r user-remote, eval=FALSE}
+library(mirai)
+
+# Launch workers on remote hosts over SSH (see ?mirai::daemons and
+# ?mirai::ssh_config for the full set of options, including HPC launchers).
+daemons(
+  n = 8,
+  url = host_url(),
+  remote = ssh_config(c("ssh://node1", "ssh://node2"))
+)
+
+loo_big <- loo(large_loglik, r_eff = r_eff_big)
+
+daemons(0)
+```
+
+# 3. Map-style workflows with `loo_mirai()`
+
+When you have many independent jobs --- for example, one `psis()` or `loo()`
+call per model in a simulation study --- [loo_mirai()] provides a thin
+convenience wrapper around `mirai::mirai_map()`. Each element of `args_list`
+is a named list of arguments passed to a \pkg{loo} function via `do.call()`:
+
+```{r loo-mirai, eval=FALSE}
+r_eff <- relative_eff(exp(example_loglik_array()))
+ll_list <- list(model_a_loglik, model_b_loglik)
+
+args_list <- lapply(ll_list, function(ll) {
+  list(log_ratios = -ll, r_eff = r_eff)
+})
+
+# Start workers, map, tear down automatically.
+results <- loo_mirai(psis, args_list, n_daemons = 4)
+```
+
+Alternatively, manage the pool yourself and call `loo_mirai()` without
+`n_daemons` (or call `psis()`/`loo()` directly --- both reuse a connected
+pool):
+
+```{r loo-mirai-pool, eval=FALSE}
+library(mirai)
+
+daemons(4)
+results <- loo_mirai(psis, args_list)
+daemons(0)
+```
+
+When no pool is connected and `n_daemons` is `NULL`, `loo_mirai()` runs
+serially. Do not pass `cores` in `args_list` --- parallelism is controlled by
+`n_daemons` or an existing `mirai::daemons()` pool.
+
+# How deprecated `cores` / `mc.cores` interact with a pool
+
+The rule for user-managed pools is unchanged: **whenever a daemon pool is
+connected, __loo__ always uses it and ignores deprecated parallel controls.**
+In that state the *value* of `cores` does not matter --- `cores = 2` and
+`cores = 6` behave identically, and even the default (`cores = 1` when
+`mc.cores` is unset) still runs in parallel on the pool. The first time a call
+would otherwise have looked like a request for serial execution (`cores <= 1`)
+while a pool is connected, __loo__ prints a one-time message noting that
+`cores` is being ignored.
+
+Deprecated controls only start per-call pools when **no** mirai pool is
+connected: `cores > 1` or `options(mc.cores = k)` with `k > 1` both resolve to
+a temporary pool for that call (Section 1). If you genuinely want a single call
+to run serially while a pool is up, stop the pool first with `mirai::daemons(0)`.
+
+## When is the number of worker daemons equal to `cores`?
+
+It follows directly from the rule above. The number of workers actually doing
+the computation equals `cores` **only in the per-call case**; when a
+user-managed pool is connected the worker count comes from your
+`mirai::daemons()` call and `cores` is irrelevant:
+
+| How parallelism is set up | Number of worker daemons | Equal to `cores`? |
+|---|---|---|
+| Per-call, no pool connected (`cores = k`, Section 1) | `k` | **Yes** --- loo spawns exactly `cores` daemons for the call |
+| User-managed pool (`mirai::daemons(n)`, Section 2) | `n` (whatever you started) | Only if you happen to pass the same `cores` |
+
+In other words, `cores` *is* the daemon count in the per-call path, but for a
+user-managed pool the daemon count is fixed by your `mirai::daemons()` call,
+and passing a different `cores` (including the default `1`) does **not** change
+how many workers run. Internally __loo__ always splits the work according to
+the number of daemons that are actually connected, not the requested `cores`.
+
+# Large objects and shared memory
+
+When __loo__ uses the function method (e.g. `loo(llfun, data = ..., draws =
+...)`), the posterior `draws` are reused identically by every observation. On a
+**local** pool these large objects are written once into shared memory with
+__mori__ so each worker maps the same physical pages (zero-copy), which keeps
+memory use low even with many workers.
+
+On a **remote** pool shared memory is not available, so __loo__ falls back to
+ordinary serialization and chunks the work to send each large object roughly
+once per worker rather than once per observation. You don't need to do anything
+to get this behavior --- __loo__ detects whether the active pool is local and
+chooses the appropriate transport automatically.
+
+# Choosing a strategy
+
+| Situation | Recommended approach |
+|---|---|
+| A single `loo()`/`psis()` call | `mirai::daemons(k)` … `loo()` … `mirai::daemons(0)` (Section 2) |
+| Default parallelism for a session | `mirai::daemons(k)` (Section 2) |
+| Many calls in one session (simulations, benchmarks, batch jobs) | `mirai::daemons(k)` (Section 2) or `loo_mirai(..., n_daemons = k)` (Section 3) |
+| Remote / SSH / HPC workers | `mirai::daemons(url = ..., remote = ...)` (Section 2) |
+| Legacy code (deprecated bridge) | `cores = k` or `options(mc.cores = k)` (Section 1; warns once per session) |
+
+A few general notes:
+
+* All approaches give identical results; they differ only in scheduling and
+  set-up cost.
+* These mechanisms compose safely. A pool you set up yourself is always reused
+  and never removed by __loo__, and nested __loo__ calls reuse an outer pool
+  rather than creating a new one. For example, `loo_model_weights()` sets up a
+  single pool and reuses it across all of the models it evaluates.
+* Deprecated `cores` / `mc.cores` controls still work on this branch but emit
+  a once-per-session warning; they start per-call pools only when no mirai
+  pool is connected and the resolved core count is `> 1`.
+* A connected pool always wins: when one is active, deprecated parallel
+  controls are ignored and the work runs on the pool (the first time a
+  `cores <= 1` call is overridden this way, __loo__ prints a one-time message).
+  Stop the pool with `mirai::daemons(0)` if you need a call to run serially.
+* On Windows, avoid setting deprecated parallel options in your `.Rprofile`
+  (see [this issue](https://github.com/stan-dev/loo/issues/94)); use
+  `mirai::daemons()` in your script instead.
+
+# See also
+
+* `help("loo", package = "loo")` for the `cores` argument documentation.
+* `?loo_mirai` for the map-style convenience wrapper.
+* The [__mirai__](https://mirai.r-lib.org/) documentation, especially
+  `?mirai::daemons`, for configuring local, remote, and HPC pools.
diff --git a/vignettes/loo2-weights.Rmd b/vignettes/loo2-weights.Rmd
index 36280aa6..f0fc1579 100644
--- a/vignettes/loo2-weights.Rmd
+++ b/vignettes/loo2-weights.Rmd
@@ -121,8 +121,8 @@ packages for fitting Stan models, e.g. __brms__, also provide similar methods
 for interfacing with the __loo__ package.)
 
 ```{r loo}
-# note: the loo function accepts a 'cores' argument that we recommend specifying
-# when working with bigger datasets
+# For parallel loo on large datasets, see vignette("loo2-parallel")
+# (mirai::daemons() or loo_mirai(); cores is deprecated but still works)
 
 loo1 <- loo(fit1)
 loo2 <- loo(fit2)
diff --git a/vignettes/loo2-with-rstan.Rmd b/vignettes/loo2-with-rstan.Rmd
index 23ddf364..02271146 100644
--- a/vignettes/loo2-with-rstan.Rmd
+++ b/vignettes/loo2-with-rstan.Rmd
@@ -133,8 +133,8 @@ log_lik_1 <- extract_log_lik(fit_1, merge_chains = FALSE)
 # sample sizes and Monte Carlo error
 r_eff <- relative_eff(exp(log_lik_1), cores = 2) 
 
-# preferably use more than 2 cores (as many cores as possible)
-# will use value of 'mc.cores' option if cores is not specified
+# For parallel PSIS-LOO, see vignette("loo2-parallel"): prefer mirai::daemons()
+# for session pools. The cores argument still works as a deprecated bridge.
 loo_1 <- loo(log_lik_1, r_eff = r_eff, cores = 2)
 print(loo_1)
 ```
diff --git a/vignettes/migration-guide.Rmd b/vignettes/migration-guide.Rmd
index 8b265380..d44834de 100644
--- a/vignettes/migration-guide.Rmd
+++ b/vignettes/migration-guide.Rmd
@@ -79,7 +79,6 @@ loo_compare(loo1, loo2)
 | Deprecated | Replacement | Since | Planned removal |
 |------------|-------------|-------|-----------------|
 | `psislw()` | `psis()` | 2.0.0 | 3.0.0 |
-| `options(loo.cores = ...)` | `options(mc.cores = ...)` or `cores` argument | 2.0.0 | |
 
 ```r
 # Deprecated
@@ -89,6 +88,9 @@ psislw(-log_lik_matrix)
 psis(-log_lik_matrix)
 ```
 
+See [Parallelization](#parallelization-cores-argument-and-mc.cores-option) below
+for deprecated `cores` / `mc.cores` controls and their mirai replacements.
+
 ## Accessing estimates from loo and waic objects
 
 Direct extraction of summary estimates via `$`, `[`, or `[[` on loo objects
@@ -107,6 +109,35 @@ The same pattern applies to `waic` objects (`elpd_waic`, `waic`, etc.).
 |----------|------------|-------------|-------|
 | `psis_approximate_posterior()` | `log_q` | `log_g` | 2.x |
 
+## Parallelization (`cores` argument and `mc.cores` option) {#parallelization-cores-argument-and-mc.cores-option}
+
+| Deprecated | Replacement | Since | Planned removal |
+|------------|-------------|-------|-----------------|
+| `cores` argument on `loo()`, `psis()`, etc. | `mirai::daemons()` before calling loo functions | 3.0.0 | future release |
+| | `loo_mirai(..., n_daemons = k)` for many models | 3.0.0 | |
+| `options(mc.cores = ...)` (when used for loo parallelism) | `mirai::daemons()` / `loo_mirai()` | 3.0.0 | future release |
+
+When the resolved core count is `> 1` and no daemon pool is connected, loo still
+starts a scoped per-call local pool (as on this branch). A deprecation warning
+is emitted once per session when `cores` is passed explicitly (even `cores = 1`),
+when `options(mc.cores)` is set, or when the resolved value is `cores > 1`.
+
+```r
+# Deprecated (still works for now)
+loo(LLarr, r_eff = r_eff, cores = 4)
+
+# Current: one-off parallel call with a user-managed pool
+mirai::daemons(4)
+loo(LLarr, r_eff = r_eff)
+mirai::daemons(0)
+
+# Current: many models in one session
+loo_mirai(loo, args_list, n_daemons = 4)
+```
+
+Do not pass `cores` in `args_list` to `loo_mirai()`; parallelism is controlled
+by `n_daemons` or an existing `mirai::daemons()` pool.
+
 ---
 
 # Planned removals in 3.0.0
@@ -115,9 +146,12 @@ The following are targeted for **removal** in loo 3.0.0:
 
 - `compare()` and `R/compare.R`
 - `psislw()` and `R/psislw.R`
+- `options(loo.cores)` (deprecated since loo 2.x in favor of `options(mc.cores)`)
 
-The deprecated option `options(loo.cores = ...)` remains for backward
-compatibility until a separate removal decision is made.
+Deprecated parallel controls (`cores` and `options(mc.cores)`) remain
+functional on this branch with deprecation warnings but are planned for removal
+in a future release after mirai-based workflows are documented in
+`vignette("loo2-parallel")`.
 
 ---