diff --git a/.gitignore b/.gitignore
index e3b2d76a492..c36591f03d8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -35,6 +35,8 @@ benchmarks/*.csv
 *.o-*
 *.exe
 *.a
+# mac debug folders
+*.dSYM/
 
 # Intel template building blocks (TBB)
 lib/tbb
diff --git a/Jenkinsfile b/Jenkinsfile
index 991215acca3..78c9e6be934 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -322,6 +322,32 @@ pipeline {
                     }
                     post { always { retry(3) { deleteDir() } } }
                 }
+                stage('Laplace Unit Tests') {
+                    agent {
+                        docker {
+                            image 'stanorg/ci:gpu-cpp17'
+                            label 'linux'
+                            args '--cap-add SYS_PTRACE'
+                        }
+                    }
+                    when {
+                        expression {
+                            !skipRemainingStages
+                        }
+                    }
+                    steps {
+                        unstash 'MathSetup'
+                        sh "echo CXXFLAGS += -march=native -mtune=native >> make/local"
+                        sh "echo O=3 >> make/local"
+                        script {
+                            if (params.optimizeUnitTests || isBranch('develop') || isBranch('master')) {
+                                sh "echo CXXFLAGS += -fsanitize=address >> make/local"
+                            }
+                            runTests("test/unit/math/laplace/*_test.cpp", false)
+                        }
+                    }
+                    post { always { retry(3) { deleteDir() } } }
+                }
                 stage('OpenCL GPU tests') {
                     agent {
                         docker {
diff --git a/doxygen/doxygen.cfg b/doxygen/doxygen.cfg
index 3d2ca2ee1c8..e2b8ced498a 100644
--- a/doxygen/doxygen.cfg
+++ b/doxygen/doxygen.cfg
@@ -2741,3 +2741,38 @@ MSCGEN_TOOL            =
 # command).
 
 MSCFILE_DIRS           =
+
+ALIASES += laplace_options="\
+\param[in] tolerance controls the convergence criterion when finding the mode in the Laplace approximation. \
+\param[in] max_num_steps maximum number of steps before the Newton solver breaks and returns an error. \
+\param[in] hessian_block_size Block size of Hessian of log likelihood w.r.t latent Gaussian variable theta. \
+\param[in] solver Type of Newton solver. Each corresponds to a distinct choice of B matrix (i.e. application SWM formula): \
+1. computes square-root of negative Hessian. \
+2. computes square-root of covariance matrix. \
+3. computes no square-root and uses LU decomposition. \
+\param[in] max_steps_line_search Number of steps after which the algorithm gives up on doing a line search. If 0, no linesearch. \
+"
+
+ALIASES += laplace_common_template_args="\
+ \tparam ThetaVec A type inheriting from `Eigen::EigenBase` with dynamic sized rows and 1 column. \
+ \tparam CovarFun A functor with an `operator()(CovarArgsElements..., {TrainTupleElements...| PredTupleElements...})` \
+ method. The `operator()` method should accept as arguments the \
+ inner elements of `CovarArgs`. The return type of the `operator()` method \
+ should be a type inheriting from `Eigen::EigenBase` with dynamic sized \
+ rows and columns. \
+ \tparam CovarArgs A tuple of types to passed as the first arguments of `CovarFun::operator()`\
+"
+
+ALIASES += laplace_common_args="\
+\param[in] theta_0 the initial guess for the Laplace approximation. \
+\param[in] covariance_function a function which returns the prior covariance. \
+\param[in] covar_args arguments for the covariance function. \
+"
+
+ALIASES += msg_arg="\
+\param[in, out] msgs stream for messages from likelihood and covariance \
+"
+
+ALIASES += rng_arg="\
+\param[in, out] rng Random number generator \
+"
diff --git a/make/tests b/make/tests
index 5f608b65381..0fbe233945b 100644
--- a/make/tests
+++ b/make/tests
@@ -23,7 +23,6 @@ benchmarks/%$(EXE) : benchmarks/%.cpp $(GTEST)/src/gtest-all.o $(MPI_TARGETS) $(
 test/% : CXXFLAGS += $(CXXFLAGS_GTEST)
 test/% : CPPFLAGS += $(CPPFLAGS_GTEST)
 test/% : INC += $(INC_GTEST)
-
 test/%$(EXE) : test/%.o $(GTEST)/src/gtest_main.cc $(GTEST)/src/gtest-all.o $(MPI_TARGETS) $(TBB_TARGETS)
 	$(LINK.cpp) $^ $(LDLIBS) $(OUTPUT_OPTION)
 
diff --git a/stan/math/fwd/meta/is_fvar.hpp b/stan/math/fwd/meta/is_fvar.hpp
index e208d08bc71..c5d67de8894 100644
--- a/stan/math/fwd/meta/is_fvar.hpp
+++ b/stan/math/fwd/meta/is_fvar.hpp
@@ -21,5 +21,8 @@ struct is_fvar<T,
                std::enable_if_t<internal::is_fvar_impl<std::decay_t<T>>::value>>
     : std::true_type {};
 
+template <typename T>
+inline constexpr bool is_fvar_v = is_fvar<T>::value;
+
 }  // namespace stan
 #endif
diff --git a/stan/math/mix.hpp b/stan/math/mix.hpp
index 876916443ce..62f9cf96465 100644
--- a/stan/math/mix.hpp
+++ b/stan/math/mix.hpp
@@ -1,6 +1,10 @@
 #ifndef STAN_MATH_MIX_HPP
 #define STAN_MATH_MIX_HPP
 
+#include <stan/math/fwd/fun/Eigen_NumTraits.hpp>
+#include <stan/math/rev/core/Eigen_NumTraits.hpp>
+#include <stan/math/prim/fun/Eigen.hpp>
+
 #include <stan/math/mix/meta.hpp>
 #include <stan/math/mix/fun.hpp>
 #include <stan/math/mix/functor.hpp>
@@ -26,4 +30,6 @@
 
 #include <stan/math/prim.hpp>
 
+#include <stan/math/mix/prob.hpp>
+
 #endif
diff --git a/stan/math/mix/functor.hpp b/stan/math/mix/functor.hpp
index 8e4367ee187..d8e76990be8 100644
--- a/stan/math/mix/functor.hpp
+++ b/stan/math/mix/functor.hpp
@@ -2,13 +2,16 @@
 #define STAN_MATH_MIX_FUNCTOR_HPP
 
 #include <stan/math/mix/functor/derivative.hpp>
-#include <stan/math/mix/functor/finite_diff_grad_hessian.hpp>
 #include <stan/math/mix/functor/finite_diff_grad_hessian_auto.hpp>
+#include <stan/math/mix/functor/finite_diff_grad_hessian.hpp>
 #include <stan/math/mix/functor/grad_hessian.hpp>
 #include <stan/math/mix/functor/grad_tr_mat_times_hessian.hpp>
 #include <stan/math/mix/functor/gradient_dot_vector.hpp>
 #include <stan/math/mix/functor/hessian.hpp>
+#include <stan/math/mix/functor/laplace_base_rng.hpp>
+#include <stan/math/mix/functor/laplace_likelihood.hpp>
+#include <stan/math/mix/functor/laplace_marginal_density.hpp>
+#include <stan/math/mix/functor/hessian_block_diag.hpp>
 #include <stan/math/mix/functor/hessian_times_vector.hpp>
 #include <stan/math/mix/functor/partial_derivative.hpp>
-
 #endif
diff --git a/stan/math/mix/functor/derivative.hpp b/stan/math/mix/functor/derivative.hpp
index 478063fe82b..7acc00934da 100644
--- a/stan/math/mix/functor/derivative.hpp
+++ b/stan/math/mix/functor/derivative.hpp
@@ -1,9 +1,9 @@
 #ifndef STAN_MATH_MIX_FUNCTOR_DERIVATIVE_HPP
 #define STAN_MATH_MIX_FUNCTOR_DERIVATIVE_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/fwd/core.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
 #include <vector>
 
 namespace stan {
@@ -21,7 +21,7 @@ namespace math {
  * @param[out] dfx_dx Value of derivative
  */
 template <typename T, typename F>
-void derivative(const F& f, const T& x, T& fx, T& dfx_dx) {
+inline void derivative(const F& f, const T& x, T& fx, T& dfx_dx) {
   fvar<T> x_fvar = fvar<T>(x, 1.0);
   fvar<T> fx_fvar = f(x_fvar);
   fx = fx_fvar.val_;
diff --git a/stan/math/mix/functor/finite_diff_grad_hessian.hpp b/stan/math/mix/functor/finite_diff_grad_hessian.hpp
index 95bab8427e3..42ac3f5652b 100644
--- a/stan/math/mix/functor/finite_diff_grad_hessian.hpp
+++ b/stan/math/mix/functor/finite_diff_grad_hessian.hpp
@@ -38,10 +38,10 @@ namespace math {
  * @param[in] epsilon perturbation size
  */
 template <typename F>
-void finite_diff_grad_hessian(const F& f, const Eigen::VectorXd& x, double& fx,
-                              Eigen::MatrixXd& hess,
-                              std::vector<Eigen::MatrixXd>& grad_hess_fx,
-                              double epsilon = 1e-04) {
+inline void finite_diff_grad_hessian(const F& f, const Eigen::VectorXd& x,
+                                     double& fx, Eigen::MatrixXd& hess,
+                                     std::vector<Eigen::MatrixXd>& grad_hess_fx,
+                                     double epsilon = 1e-04) {
   int d = x.size();
   grad_hess_fx.clear();
 
diff --git a/stan/math/mix/functor/finite_diff_grad_hessian_auto.hpp b/stan/math/mix/functor/finite_diff_grad_hessian_auto.hpp
index 8c38ed5477f..b41a54e0320 100644
--- a/stan/math/mix/functor/finite_diff_grad_hessian_auto.hpp
+++ b/stan/math/mix/functor/finite_diff_grad_hessian_auto.hpp
@@ -41,9 +41,9 @@ namespace math {
  * @param[out] grad_hess_fx gradient of Hessian of function at argument
  */
 template <typename F>
-void finite_diff_grad_hessian_auto(const F& f, const Eigen::VectorXd& x,
-                                   double& fx, Eigen::MatrixXd& hess,
-                                   std::vector<Eigen::MatrixXd>& grad_hess_fx) {
+inline void finite_diff_grad_hessian_auto(
+    const F& f, const Eigen::VectorXd& x, double& fx, Eigen::MatrixXd& hess,
+    std::vector<Eigen::MatrixXd>& grad_hess_fx) {
   int d = x.size();
 
   grad_hess_fx.clear();
diff --git a/stan/math/mix/functor/grad_hessian.hpp b/stan/math/mix/functor/grad_hessian.hpp
index d8abb272feb..c3478bcc113 100644
--- a/stan/math/mix/functor/grad_hessian.hpp
+++ b/stan/math/mix/functor/grad_hessian.hpp
@@ -1,9 +1,9 @@
 #ifndef STAN_MATH_MIX_FUNCTOR_GRAD_HESSIAN_HPP
 #define STAN_MATH_MIX_FUNCTOR_GRAD_HESSIAN_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/fwd/core.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
 #include <stdexcept>
 #include <vector>
 
@@ -39,7 +39,7 @@ namespace math {
  * @param[out] grad_H Gradient of the Hessian of function at argument
  */
 template <typename F>
-void grad_hessian(
+inline void grad_hessian(
     const F& f, const Eigen::Matrix<double, Eigen::Dynamic, 1>& x, double& fx,
     Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>& H,
     std::vector<Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic> >&
diff --git a/stan/math/mix/functor/grad_tr_mat_times_hessian.hpp b/stan/math/mix/functor/grad_tr_mat_times_hessian.hpp
index c8f72b98a00..7b7bec13b32 100644
--- a/stan/math/mix/functor/grad_tr_mat_times_hessian.hpp
+++ b/stan/math/mix/functor/grad_tr_mat_times_hessian.hpp
@@ -1,10 +1,10 @@
 #ifndef STAN_MATH_MIX_FUNCTOR_GRAD_TR_MAT_TIMES_HESSIAN_HPP
 #define STAN_MATH_MIX_FUNCTOR_GRAD_TR_MAT_TIMES_HESSIAN_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/mix/functor/gradient_dot_vector.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/fwd/core.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
 #include <stdexcept>
 #include <vector>
 
@@ -12,7 +12,7 @@ namespace stan {
 namespace math {
 
 template <typename F>
-void grad_tr_mat_times_hessian(
+inline void grad_tr_mat_times_hessian(
     const F& f, const Eigen::Matrix<double, Eigen::Dynamic, 1>& x,
     const Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>& M,
     Eigen::Matrix<double, Eigen::Dynamic, 1>& grad_tr_MH) {
@@ -26,7 +26,7 @@ void grad_tr_mat_times_hessian(
 
   Matrix<var, Dynamic, 1> x_var(x.size());
   for (int i = 0; i < x.size(); ++i) {
-    x_var(i) = x(i);
+    x_var.coeffRef(i) = x(i);
   }
 
   Matrix<fvar<var>, Dynamic, 1> x_fvar(x.size());
diff --git a/stan/math/mix/functor/gradient_dot_vector.hpp b/stan/math/mix/functor/gradient_dot_vector.hpp
index b664effd19b..5b5326ddb0a 100644
--- a/stan/math/mix/functor/gradient_dot_vector.hpp
+++ b/stan/math/mix/functor/gradient_dot_vector.hpp
@@ -1,19 +1,19 @@
 #ifndef STAN_MATH_MIX_FUNCTOR_GRADIENT_DOT_VECTOR_HPP
 #define STAN_MATH_MIX_FUNCTOR_GRADIENT_DOT_VECTOR_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/fwd/core.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
 #include <vector>
 
 namespace stan {
 namespace math {
 
 template <typename T1, typename T2, typename F>
-void gradient_dot_vector(const F& f,
-                         const Eigen::Matrix<T1, Eigen::Dynamic, 1>& x,
-                         const Eigen::Matrix<T2, Eigen::Dynamic, 1>& v, T1& fx,
-                         T1& grad_fx_dot_v) {
+inline void gradient_dot_vector(const F& f,
+                                const Eigen::Matrix<T1, Eigen::Dynamic, 1>& x,
+                                const Eigen::Matrix<T2, Eigen::Dynamic, 1>& v,
+                                T1& fx, T1& grad_fx_dot_v) {
   using Eigen::Matrix;
   Matrix<fvar<T1>, Eigen::Dynamic, 1> x_fvar(x.size());
   for (int i = 0; i < x.size(); ++i) {
diff --git a/stan/math/mix/functor/hessian.hpp b/stan/math/mix/functor/hessian.hpp
index 601444384ea..ae0e93132d4 100644
--- a/stan/math/mix/functor/hessian.hpp
+++ b/stan/math/mix/functor/hessian.hpp
@@ -1,9 +1,9 @@
 #ifndef STAN_MATH_MIX_FUNCTOR_HESSIAN_HPP
 #define STAN_MATH_MIX_FUNCTOR_HESSIAN_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/fwd/core.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
 #include <stdexcept>
 
 namespace stan {
@@ -39,9 +39,10 @@ namespace math {
  * @param[out] H Hessian of function at argument
  */
 template <typename F>
-void hessian(const F& f, const Eigen::Matrix<double, Eigen::Dynamic, 1>& x,
-             double& fx, Eigen::Matrix<double, Eigen::Dynamic, 1>& grad,
-             Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>& H) {
+inline void hessian(const F& f,
+                    const Eigen::Matrix<double, Eigen::Dynamic, 1>& x,
+                    double& fx, Eigen::Matrix<double, Eigen::Dynamic, 1>& grad,
+                    Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>& H) {
   H.resize(x.size(), x.size());
   grad.resize(x.size());
 
diff --git a/stan/math/mix/functor/hessian_block_diag.hpp b/stan/math/mix/functor/hessian_block_diag.hpp
new file mode 100644
index 00000000000..80e84f68454
--- /dev/null
+++ b/stan/math/mix/functor/hessian_block_diag.hpp
@@ -0,0 +1,56 @@
+#ifndef STAN_MATH_MIX_FUNCTOR_HESSIAN_BLOCK_DIAG_HPP
+#define STAN_MATH_MIX_FUNCTOR_HESSIAN_BLOCK_DIAG_HPP
+
+#include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/mix/functor/hessian_times_vector.hpp>
+
+namespace stan {
+namespace math {
+
+/**
+ * Returns a block diagonal Hessian by computing the relevant directional
+ * derivatives and storing them in a matrix.
+ * For m the size of each block, the operations const m calls to
+ * hessian_times_vector, that is m forward sweeps and m reverse sweeps.
+ * @tparam F Type of function to differentiate.
+ * @tparam Eta Type of additional arguments passed to F.
+ * @tparam Args Type of variadic arguments passed to F.
+ * @param f Function to differentiate.
+ * @param x Arguments with respect to which we differentiate.
+ * @param eta Additional arguments for f.
+ * @param hessian_block_size
+ * @param args Additional variadic arguments for f.
+ */
+template <typename F, typename... Args>
+inline Eigen::SparseMatrix<double> hessian_block_diag(
+    F&& f, const Eigen::VectorXd& x, const Eigen::Index hessian_block_size,
+    Args&&... args) {
+  using Eigen::MatrixXd;
+  using Eigen::VectorXd;
+
+  const Eigen::Index x_size = x.size();
+  Eigen::SparseMatrix<double> H(x_size, x_size);
+  H.reserve(Eigen::VectorXi::Constant(x_size, hessian_block_size));
+  VectorXd v(x_size);
+  Eigen::Index n_blocks = x_size / hessian_block_size;
+  Eigen::VectorXd Hv = Eigen::VectorXd::Zero(x_size);
+  for (Eigen::Index i = 0; i < hessian_block_size; ++i) {
+    v.setZero();
+    for (Eigen::Index j = i; j < x_size; j += hessian_block_size) {
+      v.coeffRef(j) = 1;
+    }
+    hessian_times_vector(f, Hv, x, v, args...);
+    for (int j = 0; j < n_blocks; ++j) {
+      for (int k = 0; k < hessian_block_size; ++k) {
+        H.insert(k + j * hessian_block_size, i + j * hessian_block_size)
+            = Hv(k + j * hessian_block_size);
+      }
+    }
+  }
+  return H;
+}
+
+}  // namespace math
+}  // namespace stan
+
+#endif
diff --git a/stan/math/mix/functor/hessian_times_vector.hpp b/stan/math/mix/functor/hessian_times_vector.hpp
index 5d3bf9fb567..dbd1c62c347 100644
--- a/stan/math/mix/functor/hessian_times_vector.hpp
+++ b/stan/math/mix/functor/hessian_times_vector.hpp
@@ -1,9 +1,9 @@
 #ifndef STAN_MATH_MIX_FUNCTOR_HESSIAN_TIMES_VECTOR_HPP
 #define STAN_MATH_MIX_FUNCTOR_HESSIAN_TIMES_VECTOR_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/fwd/core.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
 #include <stdexcept>
 #include <vector>
 
@@ -11,11 +11,10 @@ namespace stan {
 namespace math {
 
 template <typename F>
-void hessian_times_vector(const F& f,
-                          const Eigen::Matrix<double, Eigen::Dynamic, 1>& x,
-                          const Eigen::Matrix<double, Eigen::Dynamic, 1>& v,
-                          double& fx,
-                          Eigen::Matrix<double, Eigen::Dynamic, 1>& Hv) {
+inline void hessian_times_vector(
+    const F& f, const Eigen::Matrix<double, Eigen::Dynamic, 1>& x,
+    const Eigen::Matrix<double, Eigen::Dynamic, 1>& v, double& fx,
+    Eigen::Matrix<double, Eigen::Dynamic, 1>& Hv) {
   using Eigen::Matrix;
 
   // Run nested autodiff in this scope
@@ -35,10 +34,13 @@ void hessian_times_vector(const F& f,
     Hv(i) = x_var(i).adj();
   }
 }
-template <typename T, typename F>
+
+template <typename T, typename F, typename EigVec,
+          require_eigen_vector_t<EigVec>* = nullptr,
+          require_stan_scalar_t<T>* = nullptr>
 void hessian_times_vector(const F& f,
                           const Eigen::Matrix<T, Eigen::Dynamic, 1>& x,
-                          const Eigen::Matrix<T, Eigen::Dynamic, 1>& v, T& fx,
+                          const EigVec& v, T& fx,
                           Eigen::Matrix<T, Eigen::Dynamic, 1>& Hv) {
   using Eigen::Matrix;
   Matrix<T, Eigen::Dynamic, 1> grad;
@@ -47,6 +49,29 @@ void hessian_times_vector(const F& f,
   Hv = H * v;
 }
 
+/**
+ * Overload Hessian_times_vector function, under stan/math/mix/functor
+ * to handle functions which take in arguments
+ * and pstream.
+ */
+template <typename F, typename XAdj, typename XVec, typename VVec,
+          typename... Args,
+          require_all_eigen_vector_t<XAdj, XVec, VVec>* = nullptr>
+inline void hessian_times_vector(const F& f, XAdj& x_adj, XVec&& x, VVec&& v,
+                                 Args&&... args) {
+  nested_rev_autodiff nested;
+  const Eigen::Index x_size = x.size();
+  Eigen::Matrix<var, Eigen::Dynamic, 1> x_var = std::forward<XVec>(x);
+  Eigen::Matrix<fvar<var>, Eigen::Dynamic, 1> x_fvar(x_size);
+  for (Eigen::Index i = 0; i < x_size; i++) {
+    x_fvar(i) = fvar<var>(x_var(i), v(i));
+  }
+  fvar<var> fx_fvar = f(x_fvar, args...);
+  grad(fx_fvar.d_.vi_);
+  x_adj = x_var.adj();
+}
+
 }  // namespace math
 }  // namespace stan
+
 #endif
diff --git a/stan/math/mix/functor/laplace_base_rng.hpp b/stan/math/mix/functor/laplace_base_rng.hpp
new file mode 100644
index 00000000000..822388ed166
--- /dev/null
+++ b/stan/math/mix/functor/laplace_base_rng.hpp
@@ -0,0 +1,72 @@
+#ifndef STAN_MATH_MIX_FUNCTOR_LAPLACE_BASE_RNG_HPP
+#define STAN_MATH_MIX_FUNCTOR_LAPLACE_BASE_RNG_HPP
+
+#include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/mix/functor/laplace_marginal_density.hpp>
+#include <stan/math/prim/prob/multi_normal_cholesky_rng.hpp>
+#include <stan/math/prim/prob/multi_normal_rng.hpp>
+
+namespace stan {
+namespace math {
+
+/**
+ * In a latent gaussian model,
+ *
+ *   theta ~ Normal(theta | 0, Sigma(phi, x))
+ *   y ~ pi(y | theta, eta)
+ *
+ * returns a multivariate normal random variate sampled
+ * from the Laplace approximation of p(theta_pred | y, phi, x_pred).
+ * Note that while the data is observed at x (train_tuple), the new samples
+ * are drawn for covariates x_pred (pred_tuple).
+ * To sample the "original" theta's, set pred_tuple = train_tuple.
+ * @tparam LLFunc Type of likelihood function.
+ * @tparam LLArgs Tuple of arguments types of likelihood function.
+ * \laplace_common_template_args
+ * @tparam RNG A valid boost rng type
+ * @param ll_fun Likelihood function.
+ * @param ll_args Arguments for likelihood function.
+ * \laplace_common_args
+ * @param options Control parameter for optimizer underlying Laplace approx.
+ * \rng_arg
+ * \msg_arg
+ */
+template <
+    typename LLFunc, typename LLArgs, typename ThetaVec, typename CovarFun,
+    typename CovarArgs, typename RNG, require_all_eigen_t<ThetaVec>* = nullptr,
+    require_t<is_all_arithmetic_scalar<CovarArgs, LLArgs, ThetaVec>>* = nullptr>
+inline Eigen::VectorXd laplace_base_rng(LLFunc&& ll_fun, LLArgs&& ll_args,
+                                        ThetaVec&& theta_0,
+                                        CovarFun&& covariance_function,
+                                        CovarArgs&& covar_args,
+                                        const laplace_options& options,
+                                        RNG& rng, std::ostream* msgs) {
+  auto md_est = internal::laplace_marginal_density_est(
+      ll_fun, std::forward<LLArgs>(ll_args), std::forward<ThetaVec>(theta_0),
+      std::forward<CovarFun>(covariance_function),
+      to_ref(std::forward<CovarArgs>(covar_args)), options, msgs);
+  // Modified R&W method
+  auto&& covariance_train = md_est.covariance;
+  Eigen::VectorXd mean_train = covariance_train * md_est.theta_grad;
+  if (options.solver == 1 || options.solver == 2) {
+    Eigen::MatrixXd V_dec
+        = md_est.L.template triangularView<Eigen::Lower>().solve(
+            md_est.W_r * covariance_train);
+    Eigen::MatrixXd Sigma = covariance_train - V_dec.transpose() * V_dec;
+    return multi_normal_rng(std::move(mean_train), std::move(Sigma), rng);
+  } else {
+    Eigen::MatrixXd Sigma
+        = covariance_train
+          - covariance_train
+                * (md_est.W_r
+                   - md_est.W_r
+                         * md_est.LU.solve(covariance_train * md_est.W_r))
+                * covariance_train;
+    return multi_normal_rng(std::move(mean_train), std::move(Sigma), rng);
+  }
+}
+
+}  // namespace math
+}  // namespace stan
+
+#endif
diff --git a/stan/math/mix/functor/laplace_likelihood.hpp b/stan/math/mix/functor/laplace_likelihood.hpp
new file mode 100644
index 00000000000..1b54f33fcd9
--- /dev/null
+++ b/stan/math/mix/functor/laplace_likelihood.hpp
@@ -0,0 +1,454 @@
+#ifndef STAN_MATH_MIX_FUNCTOR_LAPLACE_LIKELIHOOD_HPP
+#define STAN_MATH_MIX_FUNCTOR_LAPLACE_LIKELIHOOD_HPP
+
+#include <stan/math/mix/functor/hessian_block_diag.hpp>
+#include <stan/math/prim/functor.hpp>
+#include <stan/math/prim/fun.hpp>
+
+namespace stan {
+namespace math {
+
+/**
+ * functions to compute the log density, first, second,
+ * and third-order derivatives for a likelihoood specified by the user.
+ */
+namespace laplace_likelihood {
+namespace internal {
+/**
+ * @tparam F A functor with `opertor()(Args&&...)` returning a scalar
+ * @tparam Theta A class assignable to an Eigen vector type
+ * @tparam Stream Type of stream for messages.
+ * @tparam Args Type of variadic arguments.
+ * @param f Log likelihood function.
+ * @param theta Latent Gaussian variable.
+ * @param msgs Stream for messages.
+ * @param args Additional variational arguments for likelihood function.
+ */
+template <typename F, typename Theta, typename Stream, typename... Args,
+          require_eigen_vector_t<Theta>* = nullptr>
+inline auto log_likelihood(F&& f, Theta&& theta, Stream* msgs, Args&&... args) {
+  return std::forward<F>(f)(std::forward<Theta>(theta),
+                            std::forward<Args>(args)..., msgs);
+}
+
+/**
+ * Decide if object should be deep or shallow copied when
+ * using @ref conditional_copy_and_promote .
+ */
+enum class COPY_TYPE { SHALLOW = 0, DEEP = 1 };
+
+/**
+ * Conditional copy and promote a type's scalar type to a `PromotedType`.
+ * @tparam Filter type trait with a static constexpr bool member `value`
+ *  that is true if the type should be promoted. Otherwise, the type is
+ *  left unchanged.
+ * @tparam PromotedType type to promote the scalar to.
+ * @tparam CopyType type of copy to perform.
+ * @tparam Args variadic arguments.
+ * @param args variadic arguments to conditionally copy and promote.
+ * @return a tuple where each element is either a reference to the original
+ * argument or a promoted copy of the argument.
+ */
+template <template <typename...> class Filter,
+          typename PromotedType = stan::math::var,
+          COPY_TYPE CopyType = COPY_TYPE::DEEP, typename... Args>
+inline auto conditional_copy_and_promote(Args&&... args) {
+  return map_if<Filter>(
+      [](auto&& arg) {
+        if constexpr (is_tuple_v<decltype(arg)>) {
+          return stan::math::apply(
+              [](auto&&... inner_args) {
+                return make_holder_tuple(
+                    conditional_copy_and_promote<Filter, PromotedType,
+                                                 CopyType>(
+                        std::forward<decltype(inner_args)>(inner_args))...);
+              },
+              std::forward<decltype(arg)>(arg));
+        } else if constexpr (is_std_vector_v<decltype(arg)>) {
+          std::vector<decltype(conditional_copy_and_promote<
+                               Filter, PromotedType, CopyType>(arg[0]))>
+              ret;
+          for (std::size_t i = 0; i < arg.size(); ++i) {
+            ret.push_back(
+                conditional_copy_and_promote<Filter, PromotedType, CopyType>(
+                    arg[i]));
+          }
+          return ret;
+        } else {
+          if constexpr (CopyType == COPY_TYPE::DEEP) {
+            return stan::math::eval(promote_scalar<PromotedType>(
+                value_of_rec(std::forward<decltype(arg)>(arg))));
+          } else if (CopyType == COPY_TYPE::SHALLOW) {
+            if constexpr (std::is_same_v<PromotedType,
+                                         scalar_type_t<decltype(arg)>>) {
+              return std::forward<decltype(arg)>(arg);
+            } else {
+              return stan::math::eval(promote_scalar<PromotedType>(
+                  std::forward<decltype(arg)>(arg)));
+            }
+          }
+        }
+      },
+      std::forward<Args>(args)...);
+}
+
+template <typename PromotedType, typename... Args>
+inline auto deep_copy_vargs(Args&&... args) {
+  return conditional_copy_and_promote<is_any_var_scalar, PromotedType,
+                                      COPY_TYPE::DEEP>(
+      std::forward<Args>(args)...);
+}
+
+template <typename PromotedType, typename... Args>
+inline auto shallow_copy_vargs(Args&&... args) {
+  return conditional_copy_and_promote<is_any_var_scalar, PromotedType,
+                                      COPY_TYPE::SHALLOW>(
+      std::forward<Args>(args)...);
+}
+
+/**
+ * Computes theta gradient and negative block diagonal Hessian of `f` wrt
+ * `theta` and `args...`
+ * @note If `Args` contains \ref var types then their adjoints will be
+ * calculated as a side effect.
+ * @tparam F A functor with `opertor()(Args&&...)` returning a scalar
+ * @tparam Theta A class assignable to an Eigen vector type
+ * @tparam Stream Type of stream for messages.
+ * @tparam Args Type of variadic arguments.
+ * @param f Log likelihood function.
+ * @param theta Latent Gaussian model.
+ * @param hessian_block_size If the Hessian of the log likelihood function w.r.t
+ *                           the latent Gaussian variable is block-diagonal,
+ *                           size of each block.
+ * @param msgs Stream for messages.
+ * @param args Variadic arguments for the likelihood function.
+ */
+template <typename F, typename Theta, typename Stream, typename... Args,
+          require_eigen_vector_vt<std::is_arithmetic, Theta>* = nullptr>
+inline auto diff(F&& f, Theta&& theta, const Eigen::Index hessian_block_size,
+                 Stream* msgs, Args&&... args) {
+  using Eigen::Dynamic;
+  using Eigen::Matrix;
+  const Eigen::Index theta_size = theta.size();
+  auto theta_gradient = [&theta, &f, &msgs](auto&&... args) {
+    nested_rev_autodiff nested;
+    Matrix<var, Dynamic, 1> theta_var = theta;
+    var f_var = f(theta_var, args..., msgs);
+    grad(f_var.vi_);
+    return theta_var.adj().eval();
+  }(args...);
+  if (hessian_block_size == 1) {
+    auto v = Eigen::VectorXd::Ones(theta_size);
+    Eigen::VectorXd hessian_v = Eigen::VectorXd::Zero(theta_size);
+    hessian_times_vector(f, hessian_v, std::forward<Theta>(theta), std::move(v),
+                         value_of(args)..., msgs);
+    Eigen::SparseMatrix<double> hessian_theta(theta_size, theta_size);
+    hessian_theta.reserve(Eigen::VectorXi::Constant(theta_size, 1));
+    for (Eigen::Index i = 0; i < theta_size; i++) {
+      hessian_theta.insert(i, i) = hessian_v(i);
+    }
+    return std::make_pair(std::move(theta_gradient), (-hessian_theta).eval());
+  } else {
+    return std::make_pair(
+        std::move(theta_gradient),
+        (-hessian_block_diag(f, std::forward<Theta>(theta), hessian_block_size,
+                             value_of(args)..., msgs))
+            .eval());
+  }
+}
+
+/**
+ * Compute third order derivative of `f` wrt `theta` and `args...`
+ * @note If `Args` contains \ref var types then their adjoints will be
+ * calculated as a side effect.
+ * @tparam F A functor with `opertor()(Args&&...)` returning a scalar
+ * @tparam Theta A class assignable to an Eigen vector type
+ * @tparam Stream Type of stream for messages.
+ * @tparam Args Type of variadic arguments for likelihood function.
+ * @param f Log likelihood function.
+ * @param theta Latent Gaussian variable.
+ * @param msgs Stream for messages.
+ * @param args Variadic arguments for likelihood function.
+ */
+template <typename F, typename Theta, typename Stream, typename... Args,
+          require_eigen_vector_t<Theta>* = nullptr>
+inline Eigen::VectorXd third_diff(F&& f, Theta&& theta, Stream&& msgs,
+                                  Args&&... args) {
+  nested_rev_autodiff nested;
+  const Eigen::Index theta_size = theta.size();
+  Eigen::Matrix<var, Eigen::Dynamic, 1> theta_var = std::forward<Theta>(theta);
+  Eigen::Matrix<fvar<fvar<var>>, Eigen::Dynamic, 1> theta_ffvar(theta_size);
+  for (Eigen::Index i = 0; i < theta_size; ++i) {
+    theta_ffvar(i) = fvar<fvar<var>>(fvar<var>(theta_var(i), 1.0), 1.0);
+  }
+  fvar<fvar<var>> ftheta_ffvar = f(theta_ffvar, args..., msgs);
+  grad(ftheta_ffvar.d_.d_.vi_);
+  return theta_var.adj().eval();
+}
+
+/**
+ * The derivative of the log likelihood wrt `theta` evaluated at the mode.
+ * @brief Compute $s_2 = \Delta_{\theta} log \pi_G(y|\phi,\eta) = -\frac{1}{2}
+ * trace((K^{-1}+W)^{-1})$
+ * @note Equation 15 in https://arxiv.org/pdf/2306.14976
+ * @note If `Args` contains \ref var types then their adjoints will be
+ * calculated as a side effect.
+ * @tparam F A functor with `opertor()(Args&&...)` returning a scalar
+ * @tparam Theta An Eigen Matrix
+ * @tparam AMat An Eigen Matrix
+ * @tparam Stream Type of stream for messages.
+ * @tparam Args Type of variadic arguments for likelihood function.
+ * @param f Log likelihood function.
+ * @param theta Latent Gaussian variable.
+ * @param A Matrix storing initial tangents for higher-order differentiation
+ *        (line 21 in Algorithm 4, https://arxiv.org/pdf/2306.14976)
+ * @param hessian_block_size If the Hessian of the log likelihood w.r.t theta
+ *                           is block diagonal, size of each block.
+ * @param msgs Stream for messages.
+ * @param args Variational arguments for likelihood function.
+ */
+template <typename F, typename Theta, typename AMat, typename Stream,
+          typename... Args, require_eigen_vector_t<Theta>* = nullptr>
+inline auto compute_s2(F&& f, Theta&& theta, AMat&& A,
+                       const int hessian_block_size, Stream* msgs,
+                       Args&&... args) {
+  using Eigen::Dynamic;
+  using Eigen::Matrix;
+  using Eigen::MatrixXd;
+  using Eigen::VectorXd;
+
+  nested_rev_autodiff nested;
+  const Eigen::Index theta_size = theta.size();
+  Matrix<var, Dynamic, 1> theta_var = std::forward<Theta>(theta);
+  int n_blocks = theta_size / hessian_block_size;
+  VectorXd v(theta_size);
+  VectorXd w(theta_size);
+  Matrix<fvar<fvar<var>>, Dynamic, 1> theta_ffvar(theta_size);
+  auto shallow_copy_args
+      = shallow_copy_vargs<fvar<fvar<var>>>(std::forward_as_tuple(args...));
+  // build a “row” index 0,1,2,…,total-1
+  Eigen::Index total = n_blocks * hessian_block_size;
+  for (Eigen::Index i = 0; i < hessian_block_size; ++i) {
+    nested_rev_autodiff nested;
+    v.setZero();
+    for (int j = i; j < theta_size; j += hessian_block_size) {
+      v(j) = 1;
+    }
+    w.setZero();
+    for (int j = 0; j < n_blocks; ++j) {
+      for (int k = 0; k < hessian_block_size; ++k) {
+        w(k + j * hessian_block_size)
+            = A(k + j * hessian_block_size, i + j * hessian_block_size);
+      }
+    }
+    for (int j = 0; j < theta_size; ++j) {
+      theta_ffvar(j) = fvar<fvar<var>>(fvar<var>(theta_var(j), v(j)), w(j));
+    }
+    fvar<fvar<var>> target_ffvar = stan::math::apply(
+        [](auto&& f, auto&& theta_ffvar, auto&& msgs, auto&&... inner_args) {
+          return f(theta_ffvar, inner_args..., msgs);
+        },
+        shallow_copy_args, f, theta_ffvar, msgs);
+    grad(target_ffvar.d_.d_.vi_);
+  }
+  return (0.5 * theta_var.adj()).eval();
+}
+
+/**
+ * Compute second order gradient of `f` wrt `theta` and `args...`
+ * @note See proposition 2 in https://arxiv.org/pdf/2306.14976
+ * See lines 31-37 in Algorithm 4
+ * If `Args` contains \ref var types then their adjoints will be
+ * calculated as a side effect.
+ * @tparam F A functor with `opertor()(Args&&...)` returning a scalar
+ * @tparam V_t A type assignable to an Eigen vector type
+ * @tparam Theta A type assignable to an Eigen vector type
+ * @tparam Stream Type of stream for messages.
+ * @tparam Args Parameter pack of arguments to `F`'s `operator()`
+ * @param f Log likelihood function.
+ * @param v Initial tangent.
+ * @param theta Latent Gaussian variable.
+ * @param msgs Stream for messages.
+ * @param args Variadic arguments for likelhood function.
+ * @return `args` which are var types will have their adjoints set as a side
+ * effect of this function.
+ */
+template <typename F, typename V_t, typename Theta, typename Stream,
+          typename... Args, require_eigen_vector_t<Theta>* = nullptr>
+inline auto diff_eta_implicit(F&& f, V_t&& v, Theta&& theta, Stream* msgs,
+                              Args&&... args) {
+  using Eigen::Dynamic;
+  using Eigen::Matrix;
+  using Eigen::VectorXd;
+  constexpr bool contains_var = is_any_var_scalar<Args...>::value;
+  if constexpr (!contains_var) {
+    return;
+  }
+  nested_rev_autodiff nested;
+  const Eigen::Index theta_size = theta.size();
+  Matrix<var, Dynamic, 1> theta_var = std::forward<Theta>(theta);
+  Matrix<fvar<var>, Dynamic, 1> theta_fvar(theta_size);
+  for (Eigen::Index i = 0; i < theta_size; i++) {
+    theta_fvar(i) = fvar<var>(theta_var(i), v(i));
+  }
+  auto shallow_copy_args
+      = shallow_copy_vargs<fvar<var>>(std::forward_as_tuple(args...));
+  fvar<var> f_sum = stan::math::apply(
+      [](auto&& f, auto&& theta_fvar, auto&& msgs, auto&&... inner_args) {
+        return f(theta_fvar, inner_args..., msgs);
+      },
+      shallow_copy_args, f, theta_fvar, msgs);
+  grad(f_sum.d_.vi_);
+}
+
+}  // namespace internal
+
+/**
+ * A wrapper that accepts a tuple as arguments.
+ * @tparam F A functor with `opertor()(Args&&...)` returning a scalar
+ * @tparam Theta A class assignable to an Eigen vector type
+ * @tparam TupleArgs Type of arguments for covariance function.
+ * @tparam Stream Type of stream for messages.
+ * @param f Log likelihood function.
+ * @param theta Latent Gaussian model.
+ * @param ll_tup Arguments for likelihood function
+ * @param msgs stream messages.
+ */
+template <typename F, typename Theta, typename TupleArgs, typename Stream,
+          require_eigen_vector_t<Theta>* = nullptr,
+          require_tuple_t<TupleArgs>* = nullptr>
+inline auto log_likelihood(F&& f, Theta&& theta, TupleArgs&& ll_tup,
+                           Stream* msgs) {
+  return apply(
+      [](auto&& f, auto&& theta, auto&& msgs, auto&&... args) {
+        return internal::log_likelihood(
+            std::forward<decltype(f)>(f), std::forward<decltype(theta)>(theta),
+            msgs, std::forward<decltype(args)>(args)...);
+      },
+      std::forward<TupleArgs>(ll_tup), std::forward<F>(f),
+      std::forward<Theta>(theta), msgs);
+}
+
+/**
+ * A wrapper that accepts a tuple as arguments.
+ * @tparam F A functor with `opertor()(Args&&...)` returning a scalar
+ * @tparam Theta A class assignable to an Eigen vector type
+ * @tparam TupleArgs Type of arguments for covariance function.
+ * @tparam Stream Type of stream for messages.
+ * @param f Log likelihood function.
+ * @param theta Latent Gaussian model.
+ * @param hessian_block_size If Hessian of log likelihood w.r.t theta is
+ *                           block diagonal, size of block.
+ * @param ll_tuple Arguments for likelihood function
+ * @param msgs Stream messages.
+ */
+template <typename F, typename Theta, typename TupleArgs, typename Stream,
+          require_eigen_vector_t<Theta>* = nullptr,
+          require_tuple_t<TupleArgs>* = nullptr>
+inline auto diff(F&& f, Theta&& theta, const Eigen::Index hessian_block_size,
+                 TupleArgs&& ll_tuple, Stream* msgs) {
+  return apply(
+      [](auto&& f, auto&& theta, auto hessian_block_size, auto* msgs,
+         auto&&... args) {
+        return internal::diff(
+            std::forward<decltype(f)>(f), std::forward<decltype(theta)>(theta),
+            hessian_block_size, msgs, std::forward<decltype(args)>(args)...);
+      },
+      std::forward<TupleArgs>(ll_tuple), std::forward<F>(f),
+      std::forward<Theta>(theta), hessian_block_size, msgs);
+}
+
+/**
+ * A wrapper that accepts a tuple as arguments.
+ * @tparam F Type of log likelhood function.
+ * @tparam Theta A class assignable to an Eigen vector type
+ * @tparam TupleArgs Type of arguments for covariance function.
+ * @tparam Stream Type of stream for messages.
+ * @param f Log likelihood function.
+ * @param theta Latent Gaussian variable.
+ * @param ll_args Variadic arguments for likelihood function.
+ * @param msgs Streaming message.
+ */
+template <typename F, typename Theta, typename TupleArgs, typename Stream,
+          require_eigen_vector_t<Theta>* = nullptr,
+          require_tuple_t<TupleArgs>* = nullptr>
+inline Eigen::VectorXd third_diff(F&& f, Theta&& theta, TupleArgs&& ll_args,
+                                  Stream* msgs) {
+  return apply(
+      [](auto&& f, auto&& theta, auto&& msgs, auto&&... args) {
+        return internal::third_diff(std::forward<decltype(f)>(f),
+                                    std::forward<decltype(theta)>(theta), msgs,
+                                    std::forward<decltype(args)>(args)...);
+      },
+      std::forward<TupleArgs>(ll_args), std::forward<F>(f),
+      std::forward<Theta>(theta), msgs);
+}
+
+/**
+ * A wrapper that accepts a tuple as arguments.
+ * @tparam F Type of log likelhood function.
+ * @tparam Theta Type of latent Gaussian ba
+ * @tparam TupleArgs Type of arguments for covariance function.
+ * @tparam Stream Type of stream for messages.
+ * @param f Log likelihood function.
+ * @param theta Latent Gaussian variable.
+ * @param A Matrix storing initial tangents for higher-order differentiation
+ *        (line 21 in Algorithm 4, https://arxiv.org/pdf/2306.14976)
+ * @param hessian_block_size If Hessian of log likelihood w.r.t theta is
+ *                           block diagonal, size of block.
+ * @param ll_args Variadic arguments for likelihood function.
+ * @param msgs Streaming messages.
+ */
+template <typename F, typename Theta, typename AMat, typename TupleArgs,
+          typename Stream, require_eigen_vector_t<Theta>* = nullptr,
+          require_tuple_t<TupleArgs>* = nullptr>
+inline auto compute_s2(F&& f, Theta&& theta, AMat&& A, int hessian_block_size,
+                       TupleArgs&& ll_args, Stream* msgs) {
+  return apply(
+      [](auto&& f, auto&& theta, auto&& A, auto hessian_block_size, auto* msgs,
+         auto&&... args) {
+        return internal::compute_s2(
+            std::forward<decltype(f)>(f), std::forward<decltype(theta)>(theta),
+            std::forward<decltype(A)>(A), hessian_block_size, msgs,
+            std::forward<decltype(args)>(args)...);
+      },
+      std::forward<TupleArgs>(ll_args), std::forward<F>(f),
+      std::forward<Theta>(theta), std::forward<AMat>(A), hessian_block_size,
+      msgs);
+}
+
+/**
+ * A wrapper that accepts a tuple as arguments.
+ * @tparam F A functor with `opertor()(Args&&...)` returning a scalar
+ * @tparam V_t Type of initial tangent.
+ * @tparam Theta A class assignable to an Eigen vector type
+ * @tparam TupleArgs Type of variadic arguments for likelihood function.
+ * @tparam Stream Type of stream for messages.
+ * @param f Log likelihood function.
+ * @param v Initial tangent.
+ * @param theta Latent Gaussian variable.
+ * @param ll_args Variadic arguments for likelihood function.
+ * @param msgs Streaming messages.
+ */
+template <typename F, typename V_t, typename Theta, typename TupleArgs,
+          typename Stream, require_tuple_t<TupleArgs>* = nullptr,
+          require_eigen_vector_t<Theta>* = nullptr>
+inline auto diff_eta_implicit(F&& f, V_t&& v, Theta&& theta,
+                              TupleArgs&& ll_args, Stream* msgs) {
+  return apply(
+      [](auto&& f, auto&& v, auto&& theta, auto&& msgs, auto&&... args) {
+        return internal::diff_eta_implicit(
+            std::forward<decltype(f)>(f), std::forward<decltype(v)>(v),
+            std::forward<decltype(theta)>(theta), msgs,
+            std::forward<decltype(args)>(args)...);
+      },
+      std::forward<TupleArgs>(ll_args), std::forward<F>(f),
+      std::forward<V_t>(v), std::forward<Theta>(theta), msgs);
+}
+
+}  // namespace laplace_likelihood
+
+}  // namespace math
+}  // namespace stan
+
+#endif
diff --git a/stan/math/mix/functor/laplace_marginal_density.hpp b/stan/math/mix/functor/laplace_marginal_density.hpp
new file mode 100644
index 00000000000..2e889947271
--- /dev/null
+++ b/stan/math/mix/functor/laplace_marginal_density.hpp
@@ -0,0 +1,1182 @@
+#ifndef STAN_MATH_MIX_FUNCTOR_LAPLACE_MARGINAL_DENSITY_HPP
+#define STAN_MATH_MIX_FUNCTOR_LAPLACE_MARGINAL_DENSITY_HPP
+#include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/mix/functor/laplace_likelihood.hpp>
+#include <test/unit/pretty_print_types.hpp>
+#include <stan/math/rev/meta.hpp>
+#include <stan/math/rev/core.hpp>
+#include <stan/math/rev/fun.hpp>
+#include <stan/math/rev/fun/value_of.hpp>
+#include <stan/math/rev/functor.hpp>
+#include <stan/math/prim/fun/to_ref.hpp>
+#include <stan/math/prim/fun/quad_form_diag.hpp>
+#include <stan/math/prim/functor/iter_tuple_nested.hpp>
+#include <unsupported/Eigen/MatrixFunctions>
+#include <cmath>
+
+/**
+ * @file
+ * Reference for calculations of marginal and its gradients:
+ * Margossian et al (2020), https://arxiv.org/abs/2004.12550
+ * and Margossian (2023), https://arxiv.org/pdf/2306.14976
+ */
+
+namespace stan {
+namespace math {
+
+/**
+ * Options for the laplace sampler
+ */
+struct laplace_options {
+  /* Size of the blocks in block diagonal hessian*/
+  int hessian_block_size{1};
+  /**
+   * Which Newton solver to use: (B matrix in equation 1 of
+   * https://arxiv.org/pdf/2306.14976) (1) method using the cholesky
+   * decomposition of `W` (the negative Hessian of log likelihood) (2) method
+   * using the cholesky decomposition of `K` (the covariance matrix) (3) method
+   * using an LU decomposition (more general, but slower)
+   */
+  int solver{1};
+  /* Maximum number of steps in line search */
+  int max_steps_line_search{0};
+  /* iterations end when difference in objective function is less than tolerance
+   */
+  double tolerance{1e-6};
+  /* Maximum number of steps*/
+  int max_num_steps{100};
+};
+
+namespace internal {
+
+template <typename Covar, typename ThetaVec, typename WR, typename L_t,
+          typename A_vec, typename ThetaGrad, typename LU_t, typename KRoot>
+struct laplace_density_estimates {
+  /* log marginal density */
+  double lmd{std::numeric_limits<double>::infinity()};
+  /* Evaluated covariance function for the latent gaussian variable */
+  Covar covariance;
+  /* ThetaVec at the mode */
+  ThetaVec theta;
+  /* negative hessian or sqrt of negative hessian */
+  WR W_r;
+  /* Lower left of cholesky decomposition of stabilized inverse covariance */
+  L_t L;
+  /* inverse covariance times theta at the mode */
+  A_vec a;
+  /* the gradient of the log density with respect to theta */
+  ThetaGrad theta_grad;
+  /* LU matrix from solver 3 */
+  LU_t LU;
+  /* Cholesky of the covariance matrix */
+  KRoot K_root;
+  laplace_density_estimates(double lmd_, Covar&& covariance_, ThetaVec&& theta_,
+                            WR&& W_r_, L_t&& L_, A_vec&& a_,
+                            ThetaGrad&& theta_grad_, LU_t&& LU_,
+                            KRoot&& K_root_)
+      : lmd(lmd_),
+        covariance(std::move(covariance_)),
+        theta(std::move(theta_)),
+        W_r(std::move(W_r_)),
+        L(std::move(L_)),
+        a(std::move(a_)),
+        theta_grad(std::move(theta_grad_)),
+        LU(std::move(LU_)),
+        K_root(std::move(K_root_)) {}
+};
+
+/**
+ * Returns the principal square root of a block diagonal matrix.
+ * @tparam WRootMat A type inheriting from `Eigen::EigenBase`.
+ * @param W_root The output matrix to store the square root.
+ * @param W The input block diagonal matrix.
+ * @param block_size The size of each block in the block diagonal matrix.
+ */
+template <typename WRootMat>
+inline void block_matrix_sqrt(WRootMat& W_root,
+                              const Eigen::SparseMatrix<double>& W,
+                              const Eigen::Index block_size) {
+  int n_block = W.cols() / block_size;
+  Eigen::MatrixXd local_block(block_size, block_size);
+  Eigen::MatrixXd local_block_sqrt(block_size, block_size);
+  Eigen::MatrixXd sqrt_t_mat = Eigen::MatrixXd::Zero(block_size, block_size);
+  // No block operation available for sparse matrices, so we have to loop
+  // See https://eigen.tuxfamily.org/dox/group__TutorialSparse.html#title7
+  for (int i = 0; i < n_block; i++) {
+    sqrt_t_mat.setZero();
+    local_block
+        = W.block(i * block_size, i * block_size, block_size, block_size);
+    if (Eigen::isnan(local_block.array()).any()) {
+      throw std::domain_error(
+          std::string("Error in block_matrix_sqrt: "
+                      "NaNs detected in block diagonal starting at (")
+          + std::to_string(i) + ", " + std::to_string(i) + ")");
+    }
+    // Issue here, sqrt is done over T of the complex schur
+    Eigen::RealSchur<Eigen::MatrixXd> schurOfA(local_block);
+    // Compute Schur decomposition of arg
+    const auto& t_mat = schurOfA.matrixT();
+    const auto& u_mat = schurOfA.matrixU();
+    // Check if diagonal of schur is not positive
+    if ((t_mat.diagonal().array() < 0).any()) {
+      throw std::domain_error(
+          std::string("Error in block_matrix_sqrt: "
+                      "values less than 0 detected in block diagonal's schur "
+                      "decomposition starting at (")
+          + std::to_string(i) + ", " + std::to_string(i) + ")");
+    }
+    try {
+      // Compute square root of T
+      Eigen::matrix_sqrt_quasi_triangular(t_mat, sqrt_t_mat);
+      // Compute square root of arg
+      local_block_sqrt = u_mat * sqrt_t_mat * u_mat.adjoint();
+    } catch (const std::exception& e) {
+      throw std::domain_error(
+          "Error in block_matrix_sqrt: "
+          "The matrix is not positive definite");
+    }
+    for (int k = 0; k < block_size; k++) {
+      for (int j = 0; j < block_size; j++) {
+        W_root.coeffRef(i * block_size + j, i * block_size + k)
+            = local_block_sqrt(j, k);
+      }
+    }
+  }
+}
+
+/**
+ * @brief Performs a Cholesky decomposition on a block diagonal matrix.
+ * @tparam WRootMat A type inheriting from `Eigen::EigenBase`.
+ * @param W_root The output matrix to store the square root.
+ * @param W The input block diagonal matrix.
+ * @param block_size The size of each block in the block diagonal matrix.
+ */
+template <typename WRootMat>
+inline void block_matrix_chol_L(WRootMat& W_root,
+                                const Eigen::SparseMatrix<double>& W,
+                                const Eigen::Index block_size) {
+  int n_block = W.cols() / block_size;
+  Eigen::MatrixXd local_block(block_size, block_size);
+  Eigen::MatrixXd local_block_sqrt(block_size, block_size);
+  Eigen::MatrixXd sqrt_t_mat = Eigen::MatrixXd::Zero(block_size, block_size);
+  // No block operation available for sparse matrices, so we have to loop
+  // See https://eigen.tuxfamily.org/dox/group__TutorialSparse.html#title7
+  for (int i = 0; i < n_block; i++) {
+    sqrt_t_mat.setZero();
+    local_block
+        = W.block(i * block_size, i * block_size, block_size, block_size);
+    if (Eigen::isnan(local_block.array()).any()) {
+      throw std::domain_error(
+          std::string("Error in block_matrix_sqrt: "
+                      "NaNs detected in block diagonal starting at (")
+          + std::to_string(i) + ", " + std::to_string(i) + ")");
+    }
+    try {
+      // Compute square root of T
+      Eigen::LLT<Eigen::Ref<Eigen::MatrixXd>> llt(local_block);
+      if (llt.info() != Eigen::Success) {
+        throw std::runtime_error("Cholesky failed on block "
+                                 + std::to_string(i));
+      }
+      const auto Lb = llt.matrixL();
+      for (int k = 0; k < block_size; k++) {
+        for (int j = k; j < block_size; j++) {
+          W_root.coeffRef(i * block_size + j, i * block_size + k) = Lb(j, k);
+        }
+      }
+    } catch (const std::exception& e) {
+      // As a backup do the schur decomposition for this block diagonal
+      local_block
+          = W.block(i * block_size, i * block_size, block_size, block_size);
+      // Issue here, sqrt is done over T of the complex schur
+      Eigen::RealSchur<Eigen::MatrixXd> schurOfA(local_block);
+      // Compute Schur decomposition of arg
+      const auto& t_mat = schurOfA.matrixT();
+      const auto& u_mat = schurOfA.matrixU();
+      // Check if diagonal of schur is not positive
+      if ((t_mat.diagonal().array() < 0).any()) {
+        throw std::domain_error(
+            std::string("Error in block_matrix_sqrt: "
+                        "values less than 0 detected in block diagonal's schur "
+                        "decomposition starting at (")
+            + std::to_string(i) + ", " + std::to_string(i) + ")");
+      }
+      try {
+        // Compute square root of T
+        Eigen::matrix_sqrt_quasi_triangular(t_mat, sqrt_t_mat);
+        // Compute square root of arg
+        local_block_sqrt.noalias() = u_mat * sqrt_t_mat * u_mat.adjoint();
+      } catch (const std::exception& e) {
+        throw std::domain_error(
+            "Error in block_matrix_sqrt: "
+            "The matrix is not positive definite");
+      }
+      for (int k = 0; k < block_size; k++) {
+        for (int j = 0; j < block_size; j++) {
+          W_root.coeffRef(i * block_size + j, i * block_size + k)
+              = local_block_sqrt(j, k);
+        }
+      }
+      throw std::domain_error(
+          "Error in block_matrix_sqrt: "
+          "The matrix is not positive definite");
+    }
+  }
+}
+
+/**
+ * @brief Performs a simple line search
+ *
+ * @tparam AVec   Type of the parameter update vector (`a`), e.g.
+ * Eigen::VectorXd.
+ * @tparam APrev  Type of the previous parameter vector (`a_prev`), same shape
+ * as AVec.
+ * @tparam ThetaVec Type of the transformed vector (`theta`), e.g. Σ·a.
+ * @tparam LLFun  Functor type for computing the log‐likelihood.
+ * @tparam LLArgs Tuple or pack type forwarded to `ll_fun`.
+ * @tparam Covar  Matrix type for the covariance Σ, e.g. Eigen::MatrixXd.
+ * @tparam Msgs   Diagnostics container type for capturing warnings/errors.
+ *
+ * @param[in,out] objective_new On entry: objective at the full‐step `a` (must
+ * satisfy objective_new < objective_old). On exit:  best objective found.
+ * @param[in,out] a On entry: candidate parameter vector. On exit:  updated to
+ * the step achieving the lowest objective.
+ * @param[in,out] theta On entry: Σ·a for the initial candidate. On exit:  Σ·a
+ * for the accepted best step.
+ * @param[in,out] a_prev On entry: previous parameter vector, with objective
+ * `objective_old`. On exit: rolled forward to each newly accepted step.
+ * @param[in] ll_fun Callable that computes the log‐likelihood given `(theta,
+ * ll_args, msgs)`.
+ * @param[in] ll_args Arguments forwarded to `ll_fun` at each evaluation.
+ * @param[in] covariance Covariance matrix Σ used to compute `theta = Σ·a`.
+ * @param[in] max_steps_line_search Maximum number of iterations.
+ * @param[in] objective_old Objective value at the initial `a_prev` (used as f₀
+ * for the first pass).
+ * @param[in] tolerance Minimum tolerance to accept a step
+ * @param[in,out] msgs Pointer to a diagnostics container; may be used by
+ * `ll_fun` to record warnings.
+ */
+template <typename AVec, typename APrev, typename ThetaVec, typename LLFun,
+          typename LLArgs, typename Covar, typename Msgs>
+inline void line_search(double& objective_new, AVec& a, ThetaVec& theta,
+                        APrev& a_prev, LLFun&& ll_fun, LLArgs&& ll_args,
+                        Covar&& covariance, const int max_steps_line_search,
+                        const double objective_old, double tolerance,
+                        Msgs* msgs) {
+  Eigen::VectorXd a_tmp(a.size());
+  double objective_new_tmp = 0.0;
+  double objective_old_tmp = objective_old;
+  Eigen::VectorXd theta_tmp(covariance.rows());
+  for (int j = 0;
+       j < max_steps_line_search && (objective_new < objective_old_tmp); ++j) {
+    a_tmp.noalias() = a_prev + 0.5 * (a - a_prev);
+    theta_tmp.noalias() = covariance * a_tmp;
+    if (!theta_tmp.allFinite()) {
+      break;
+    } else {
+      objective_new_tmp = -0.5 * a_tmp.dot(theta_tmp)
+                          + laplace_likelihood::log_likelihood(
+                              ll_fun, theta_tmp, ll_args, msgs);
+      if (objective_new_tmp < objective_new) {
+        a_prev.swap(a);
+        a.swap(a_tmp);
+        theta.swap(theta_tmp);
+        objective_old_tmp = objective_new;
+        objective_new = objective_new_tmp;
+      } else {
+        break;
+      }
+    }
+  }
+}
+
+/**
+ * Set all adjoints of the output to zero.
+ */
+template <typename Output>
+inline void set_zero_adjoint(Output&& output) {
+  if constexpr (is_all_arithmetic_scalar_v<Output>) {
+    return;
+  } else {
+    return iter_tuple_nested(
+        [](auto&& output_i) {
+          using output_i_t = std::decay_t<decltype(output_i)>;
+          if constexpr (is_all_arithmetic_scalar_v<output_i_t>) {
+            return;
+          } else if constexpr (is_std_vector<output_i_t>::value) {
+            for (Eigen::Index i = 0; i < output_i.size(); ++i) {
+              output_i[i].adj() = 0;
+            }
+          } else if constexpr (is_eigen_v<output_i_t>) {
+            output_i.adj().setZero();
+          } else if constexpr (is_stan_scalar_v<output_i_t>) {
+            output_i.adj() = 0;
+          } else {
+            static_assert(
+                sizeof(std::decay_t<output_i_t>*) == 0,
+                "INTERNAL ERROR:(laplace_marginal_lpdf) set_zero_adjoints was "
+                "not able to deduce the actions needed for the given type.");
+          }
+        },
+        std::forward<Output>(output));
+  }
+}
+
+/**
+ * Collect the adjoints from the input and add them to the output.
+ * @tparam ZeroInput If true, the adjoints of the input will be set to zero
+ * @tparam Output A tuple or type where all scalar types are `arithmetic` types
+ * @tparam Input A tuple or type where all scalar types are `var` types
+ * @param output The output to which the adjoints will be added
+ * @param input The input from which the adjoints will be collected
+ */
+template <bool ZeroInput = false, typename Output, typename Input,
+          require_t<is_all_arithmetic_scalar<Output>>* = nullptr,
+          require_t<is_all_var_scalar<Input>>* = nullptr>
+inline void collect_adjoints(Output& output, Input&& input) {
+  return iter_tuple_nested(
+      [](auto&& output_i, auto&& input_i) {
+        using output_i_t = std::decay_t<decltype(output_i)>;
+        if constexpr (is_std_vector_v<output_i_t>) {
+          Eigen::Map<Eigen::Matrix<double, -1, 1>> output_map(output_i.data(),
+                                                              output_i.size());
+          Eigen::Map<Eigen::Matrix<var, -1, 1>> input_map(input_i.data(),
+                                                          input_i.size());
+          output_map.array() += input_map.adj().array();
+          if constexpr (ZeroInput) {
+            input_map.adj().setZero();
+          }
+        } else if constexpr (is_eigen_v<output_i_t>) {
+          output_i.array() += input_i.adj().array();
+          if constexpr (ZeroInput) {
+            input_i.adj().setZero();
+          }
+        } else if constexpr (is_stan_scalar_v<output_i_t>) {
+          output_i += input_i.adj();
+          if constexpr (ZeroInput) {
+            input_i.adj() = 0;
+          }
+        } else {
+          static_assert(
+              sizeof(std::decay_t<output_i_t>*) == 0,
+              "INTERNAL ERROR:(laplace_marginal_lpdf) set_zero_adjoints was "
+              "not able to deduce the actions needed for the given type.");
+        }
+      },
+      std::forward<Output>(output), std::forward<Input>(input));
+}
+
+/**
+ * Throws an error if the parameter contains NaN or Inf values.
+ * @tparam NameStr Type of the name string, e.g. `std::string` or `char*`.
+ * @tparam ParamStr Type of the parameter string, e.g. `std::string` or `char*`.
+ * @tparam Param Type of the parameter such as a vector, matrix, or scalar.
+ * @param name_str Name of the function or context where the error occurred.
+ * @param param_str Name of the parameter that contains NaN or Inf values.
+ * @param param The parameter to check for NaN or Inf values.
+ */
+template <typename NameStr, typename ParamStr, typename Param>
+inline STAN_COLD_PATH void throw_nan(NameStr&& name_str, ParamStr&& param_str,
+                                     Param&& param) {
+  std::string msg = std::string("Error in ") + name_str + ": "
+                    + std::string(param_str) + " contains NaN values";
+  if ((Eigen::isnan(param.array()) || Eigen::isinf(param.array())).all()) {
+    msg += " for all values.";
+    throw std::domain_error(msg);
+  }
+  msg += " at indices [";
+  for (int i = 0; i < param.size(); ++i) {
+    if (std::isnan(param(i) || std::isinf(param(i)))) {
+      msg += std::to_string(i) + ", ";
+    }
+  }
+  msg.pop_back();
+  msg.pop_back();
+  msg += "].";
+  throw std::domain_error(msg);
+}
+
+/**
+ * For a latent Gaussian model with hyperparameters phi and
+ * latent variables theta, and observations y, this function computes
+ * an approximation of the log marginal density, p(y | phi).
+ * This is done by marginalizing out theta, using a Laplace
+ * approxmation. The latter is obtained by finding the mode,
+ * via Newton's method, and computing the Hessian of the likelihood.
+ *
+ * The convergence criterion for the Newton is a small change in
+ * log marginal density. The user controls the tolerance (i.e.
+ * threshold under which change is deemed small enough) and
+ * maximum number of steps.
+ *
+ * A description of this algorithm can be found in:
+ *  - (2023) Margossian, "General Adjoint-Differentiated Laplace approximation",
+ *    https://arxiv.org/pdf/2306.14976.
+ * Additional references include:
+ *  - (2020) Margossian et al, "HMC using an adjoint-differentiated Laplace...",
+ *    NeurIPS, https://arxiv.org/abs/2004.12550.
+ *  - (2006) Rasmussen and Williams, "Gaussian Processes for Machine Learning",
+ *    second edition, MIT Press, algorithm 3.1.
+ *
+ * Variables needed for the gradient or generating quantities
+ * are stored by reference.
+ *
+ * @tparam LLFun Type with a valid `operator(ThetaVec,  InnerLLTupleArgs)`
+ * where `InnerLLTupleArgs` are the elements of `LLTupleArgs`
+ * @tparam LLTupleArgs A tuple whose elements follow the types required for
+ * `LLFun`
+ * \laplace_common_template_args
+ * @param[in] ll_fun A log likelihood functor
+ * @param[in] ll_args Tuple containing parameters for `LLFun`
+ * \laplace_common_args
+ * @param[in] options A set of options for tuning the solver
+ * \msg_arg
+ *
+ * @return A struct containing
+ * 1. lmd the log marginal density, p(y | phi)
+ * 2. covariance the evaluated covariance function for the latent gaussian
+ * variable
+ * 3. theta a vector to store the mode
+ * 4. W_r A sparse matrix containing the square root of the negative
+ *    hessian, if solver 1 or 2 are used.
+ * 5. L cholesky decomposition of stabilized inverse covariance
+ * 6. a element in the Newton step
+ * 7. l_grad the log density of the likelihood, evaluated at the mode
+ *
+ */
+template <typename LLFun, typename LLTupleArgs, typename CovarFun,
+          typename ThetaVec, typename CovarArgs,
+          require_t<is_all_arithmetic_scalar<ThetaVec, CovarArgs>>* = nullptr,
+          require_eigen_vector_t<ThetaVec>* = nullptr>
+inline auto laplace_marginal_density_est(LLFun&& ll_fun, LLTupleArgs&& ll_args,
+                                         ThetaVec&& theta_0,
+                                         CovarFun&& covariance_function,
+                                         CovarArgs&& covar_args,
+                                         const laplace_options& options,
+                                         std::ostream* msgs) {
+  using Eigen::MatrixXd;
+  using Eigen::SparseMatrix;
+  using Eigen::VectorXd;
+  check_nonzero_size("laplace_marginal", "initial guess", theta_0);
+  check_finite("laplace_marginal", "initial guess", theta_0);
+  check_nonnegative("laplace_marginal", "tolerance", options.tolerance);
+  check_positive("laplace_marginal", "max_num_steps", options.max_num_steps);
+  check_positive("laplace_marginal", "hessian_block_size",
+                 options.hessian_block_size);
+  check_nonnegative("laplace_marginal", "max_steps_line_search",
+                    options.max_steps_line_search);
+  if (unlikely(theta_0.size() % options.hessian_block_size != 0)) {
+    [&]() STAN_COLD_PATH {
+      std::stringstream msg;
+      msg << "laplace_marginal_density: The hessian size (" << theta_0.size()
+          << ", " << theta_0.size()
+          << ") is not divisible by the hessian block size ("
+          << options.hessian_block_size
+          << ")"
+             ". Try a hessian block size such as [1, ";
+      for (int i = 2; i < 12; ++i) {
+        if (theta_0.size() % i == 0) {
+          msg << i << ", ";
+        }
+      }
+      msg.str().pop_back();
+      msg.str().pop_back();
+      msg << "].";
+      throw std::domain_error(msg.str());
+    }();
+  }
+  Eigen::MatrixXd covariance = stan::math::apply(
+      [msgs, &covariance_function](auto&&... args) {
+        return covariance_function(args..., msgs);
+      },
+      covar_args);
+  auto throw_overstep = [](const auto max_num_steps) STAN_COLD_PATH {
+    throw std::domain_error(
+        std::string("laplace_marginal_density: max number of iterations: ")
+        + std::to_string(max_num_steps) + " exceeded.");
+  };
+  auto ll_args_vals = value_of(ll_args);
+  const Eigen::Index theta_size = theta_0.size();
+  std::decay_t<ThetaVec> theta = theta_0;
+  double objective_old = std::numeric_limits<double>::lowest();
+  double objective_new = std::numeric_limits<double>::lowest() + 1;
+  Eigen::VectorXd a_prev = Eigen::VectorXd::Zero(theta_size);
+  Eigen::MatrixXd B(theta_size, theta_size);
+  Eigen::VectorXd a(theta_size);
+  Eigen::VectorXd b(theta_size);
+  if (options.solver == 1) {
+    if (options.hessian_block_size == 1) {
+      for (Eigen::Index i = 0; i <= options.max_num_steps; i++) {
+        auto [theta_grad, W] = laplace_likelihood::diff(
+            ll_fun, theta, options.hessian_block_size, ll_args, msgs);
+        Eigen::VectorXd W_r(W.rows());
+        // Compute matrix square-root of W. If all elements of W are positive,
+        // do an element wise square-root. Else try a matrix square-root
+        for (Eigen::Index i = 0; i < W.rows(); i++) {
+          if (W.coeff(i, i) < 0) {
+            throw std::domain_error(
+                "laplace_marginal_density: Hessian matrix is not positive "
+                "definite");
+          } else {
+            W_r.coeffRef(i) = std::sqrt(W.coeff(i, i));
+          }
+        }
+        B.noalias() = MatrixXd::Identity(theta_size, theta_size)
+                      + W_r.asDiagonal() * covariance * W_r.asDiagonal();
+        Eigen::LLT<Eigen::Ref<Eigen::MatrixXd>> llt_B(B);
+        auto L = llt_B.matrixL();
+        auto LT = llt_B.matrixU();
+        b.noalias() = W.diagonal().cwiseProduct(theta) + theta_grad;
+        a.noalias()
+            = b
+              - W_r.asDiagonal()
+                    * LT.solve(L.solve(W_r.cwiseProduct(covariance * b)));
+        // Simple Newton step
+        theta.noalias() = covariance * a;
+        objective_old = objective_new;
+        if (unlikely(
+                (Eigen::isinf(theta.array()) || Eigen::isnan(theta.array()))
+                    .any())) {
+          throw_nan("laplace_marginal_density", "theta", theta);
+        }
+        objective_new = -0.5 * a.dot(theta)
+                        + laplace_likelihood::log_likelihood(
+                            ll_fun, theta, ll_args_vals, msgs);
+        if (options.max_steps_line_search) {
+          line_search(objective_new, a, theta, a_prev, ll_fun, ll_args_vals,
+                      covariance, options.max_steps_line_search, objective_old,
+                      options.tolerance, msgs);
+        }
+        // Check for convergence
+        if (abs(objective_new - objective_old) < options.tolerance) {
+          const double B_log_determinant
+              = 2.0 * llt_B.matrixLLT().diagonal().array().log().sum();
+          // Overwrite W instead of making a new sparse matrix
+          W.diagonal() = W_r;
+          return laplace_density_estimates{
+              objective_new - 0.5 * B_log_determinant,
+              std::move(covariance),
+              std::move(theta),
+              std::move(W),
+              Eigen::MatrixXd(L),
+              std::move(a),
+              std::move(theta_grad),
+              Eigen::PartialPivLU<Eigen::MatrixXd>{},
+              Eigen::MatrixXd(0, 0)};
+        } else {
+          a_prev = std::move(a);
+          set_zero_adjoint(ll_args);
+        }
+      }
+    } else {
+      Eigen::SparseMatrix<double> W_r(theta.rows(), theta.rows());
+      Eigen::Index block_size = options.hessian_block_size;
+      W_r.reserve(Eigen::VectorXi::Constant(W_r.cols(), block_size));
+      const Eigen::Index n_block = W_r.cols() / block_size;
+      // Prefill W_r so we only make space once
+      for (Eigen::Index i = 0; i < n_block; i++) {
+        for (Eigen::Index k = 0; k < block_size; k++) {
+          for (Eigen::Index j = 0; j < block_size; j++) {
+            W_r.insert(i * block_size + j, i * block_size + k) = 1.0;
+          }
+        }
+      }
+      W_r.makeCompressed();
+      for (Eigen::Index i = 0; i <= options.max_num_steps; i++) {
+        auto [theta_grad, W] = laplace_likelihood::diff(
+            ll_fun, theta, options.hessian_block_size, ll_args, msgs);
+        for (Eigen::Index i = 0; i < W.rows(); i++) {
+          if (W.coeff(i, i) < 0) {
+            throw std::domain_error(
+                "laplace_marginal_density: Hessian matrix is not positive "
+                "definite");
+          }
+        }
+        block_matrix_chol_L(W_r, W, options.hessian_block_size);
+        B.noalias() = MatrixXd::Identity(theta_size, theta_size)
+                      + W_r * (covariance * W_r);
+        Eigen::LLT<Eigen::Ref<Eigen::MatrixXd>> llt_B(B);
+        auto L = llt_B.matrixL();
+        auto LT = llt_B.matrixU();
+        b.noalias() = W * theta + theta_grad;
+        a.noalias() = b - W_r * LT.solve(L.solve(W_r * (covariance * b)));
+        // Simple Newton step
+        theta.noalias() = covariance * a;
+        objective_old = objective_new;
+        if (unlikely(
+                (Eigen::isinf(theta.array()) || Eigen::isnan(theta.array()))
+                    .any())) {
+          throw_nan("laplace_marginal_density", "theta", theta);
+        }
+        objective_new = -0.5 * a.dot(value_of(theta))
+                        + laplace_likelihood::log_likelihood(
+                            ll_fun, value_of(theta), ll_args_vals, msgs);
+        if (options.max_steps_line_search > 0) {
+          line_search(objective_new, a, theta, a_prev, ll_fun, ll_args_vals,
+                      covariance, options.max_steps_line_search, objective_old,
+                      options.tolerance, msgs);
+        }
+        // Check for convergence
+        if (abs(objective_new - objective_old) < options.tolerance) {
+          const double B_log_determinant
+              = 2.0 * llt_B.matrixLLT().diagonal().array().log().sum();
+          return laplace_density_estimates{
+              objective_new - 0.5 * B_log_determinant,
+              std::move(covariance),
+              std::move(theta),
+              std::move(W_r),
+              Eigen::MatrixXd(L),
+              std::move(a),
+              std::move(theta_grad),
+              Eigen::PartialPivLU<Eigen::MatrixXd>{},
+              Eigen::MatrixXd(0, 0)};
+        } else {
+          a_prev = a;
+          set_zero_adjoint(ll_args);
+        }
+      }
+    }
+    throw_overstep(options.max_num_steps);
+  } else if (options.solver == 2) {
+    Eigen::MatrixXd K_root
+        = covariance.template selfadjointView<Eigen::Lower>().llt().matrixL();
+    for (Eigen::Index i = 0; i <= options.max_num_steps; i++) {
+      auto [theta_grad, W] = laplace_likelihood::diff(
+          ll_fun, theta, options.hessian_block_size, ll_args, msgs);
+      B.noalias() = MatrixXd::Identity(theta_size, theta_size)
+                    + K_root.transpose() * W * K_root;
+      Eigen::LLT<Eigen::Ref<Eigen::MatrixXd>> llt_B(B);
+      auto L = llt_B.matrixL();
+      auto LT = llt_B.matrixU();
+      b.noalias() = W * theta + theta_grad;
+      a.noalias()
+          = K_root.transpose().template triangularView<Eigen::Upper>().solve(
+              LT.solve(L.solve(K_root.transpose() * b)));
+      // Simple Newton step
+      theta.noalias() = covariance * a;
+      objective_old = objective_new;
+      if (unlikely((Eigen::isinf(theta.array()) || Eigen::isnan(theta.array()))
+                       .any())) {
+        throw_nan("laplace_marginal_density", "theta", theta);
+      }
+      objective_new = -0.5 * a.dot(theta)
+                      + laplace_likelihood::log_likelihood(ll_fun, theta,
+                                                           ll_args_vals, msgs);
+      // linesearch
+      if (options.max_steps_line_search > 0) {
+        line_search(objective_new, a, theta, a_prev, ll_fun, ll_args_vals,
+                    covariance, options.max_steps_line_search, objective_old,
+                    options.tolerance, msgs);
+      }
+      // Check for convergence
+      if (abs(objective_new - objective_old) < options.tolerance) {
+        const double B_log_determinant
+            = 2.0 * llt_B.matrixLLT().diagonal().array().log().sum();
+        return laplace_density_estimates{
+            objective_new - 0.5 * B_log_determinant,
+            std::move(covariance),
+            std::move(theta),
+            std::move(W),
+            std::move(Eigen::MatrixXd(L)),
+            std::move(a),
+            std::move(theta_grad),
+            Eigen::PartialPivLU<Eigen::MatrixXd>{},
+            std::move(K_root)};
+      } else {
+        a_prev = a;
+        set_zero_adjoint(ll_args);
+      }
+    }
+    throw_overstep(options.max_num_steps);
+  } else if (options.solver == 3) {
+    for (Eigen::Index i = 0; i <= options.max_num_steps; i++) {
+      auto [theta_grad, W] = laplace_likelihood::diff(
+          ll_fun, theta, options.hessian_block_size, ll_args, msgs);
+      Eigen::PartialPivLU<Eigen::MatrixXd> LU(
+          MatrixXd::Identity(theta_size, theta_size) + covariance * W);
+      // L on upper and U on lower triangular
+      b.noalias() = W * theta + theta_grad;
+      a.noalias() = b - W * LU.solve(covariance * b);
+      // Simple Newton step
+      theta.noalias() = covariance * a;
+      objective_old = objective_new;
+      if (((Eigen::isinf(theta.array()) || Eigen::isnan(theta.array()))
+               .any())) {
+        throw_nan("laplace_marginal_density", "theta", theta);
+      }
+      objective_new = -0.5 * a.dot(value_of(theta))
+                      + laplace_likelihood::log_likelihood(
+                          ll_fun, value_of(theta), ll_args_vals, msgs);
+
+      if (options.max_steps_line_search > 0) {
+        line_search(objective_new, a, theta, a_prev, ll_fun, ll_args_vals,
+                    covariance, options.max_steps_line_search, objective_old,
+                    options.tolerance, msgs);
+      }
+      if (abs(objective_new - objective_old) < options.tolerance) {
+        // TODO(Charles): There has to be a simple trick for this
+        const double B_log_determinant = log(LU.determinant());
+        return laplace_density_estimates{
+            objective_new - 0.5 * B_log_determinant,
+            std::move(covariance),
+            std::move(theta),
+            std::move(W),
+            Eigen::MatrixXd(0, 0),
+            std::move(a),
+            std::move(theta_grad),
+            std::move(LU),
+            Eigen::MatrixXd(0, 0)};
+      } else {
+        a_prev = a;
+        set_zero_adjoint(ll_args);
+      }
+    }
+    throw_overstep(options.max_num_steps);
+  }
+  throw std::domain_error(
+      std::string("You chose a solver (") + std::to_string(options.solver)
+      + ") that is not valid. Please choose either 1, 2, or 3.");
+}
+}  // namespace internal
+/**
+ * For a latent Gaussian model with global parameters phi, latent
+ * variables theta, and observations y, this function computes
+ * an approximation of the log marginal density, p(y | phi).
+ * This is done by marginalizing out theta, using a Laplace
+ * approxmation. The latter is obtained by finding the mode,
+ * using a custom Newton method, and the Hessian of the likelihood.
+ *
+ * The convergence criterion for the Newton is a small change in
+ * log marginal density. The user controls the tolerance (i.e.
+ * threshold under which change is deemed small enough) and
+ * maximum number of steps.
+ *
+ * Wrapper for when the hyperparameters are passed as a double.
+ *
+ * @tparam LLFun Type with a valid `operator(ThetaVec, InnerLLTupleArgs)`
+ * where `InnerLLTupleArgs` are the elements of `LLTupleArgs`
+ * @tparam LLTupleArgs A tuple whose elements follow the types required for
+ * `LLFun`
+ * \laplace_common_template_args
+ * @param[in] ll_fun A log likelihood functor
+ * @param[in] ll_args Tuple containing parameters for `LLFun`
+ * \laplace_common_args
+ * @param[in] options A set of options for tuning the solver
+ * \msg_arg
+ * @return the log maginal density, p(y | phi)
+ */
+template <typename LLFun, typename LLTupleArgs, typename CovarFun,
+          typename ThetaVec, typename CovarArgs,
+          require_t<is_all_arithmetic_scalar<ThetaVec, CovarArgs,
+                                             LLTupleArgs>>* = nullptr,
+          require_eigen_vector_t<ThetaVec>* = nullptr>
+inline double laplace_marginal_density(LLFun&& ll_fun, LLTupleArgs&& ll_args,
+                                       ThetaVec&& theta_0,
+                                       CovarFun&& covariance_function,
+                                       CovarArgs&& covar_args,
+                                       const laplace_options& options,
+                                       std::ostream* msgs) {
+  return internal::laplace_marginal_density_est(
+             std::forward<LLFun>(ll_fun), std::forward<LLTupleArgs>(ll_args),
+             std::forward<ThetaVec>(theta_0),
+             std::forward<CovarFun>(covariance_function),
+             std::forward<CovarArgs>(covar_args), options, msgs)
+      .lmd;
+}
+
+namespace internal {
+
+/**
+ * Collects the adjoints from the input and adds them to the output.
+ * @tparam Output A tuple or type where all scalar types are `arithmetic` types
+ * @tparam Input A tuple or type where all scalar types are `arithmetic` types
+ * @param output The output to which the adjoints will be added
+ * @param input The input from which the adjoints will be collected
+ */
+template <typename Output, typename Input,
+          require_t<is_all_arithmetic_scalar<Output>>* = nullptr,
+          require_t<is_all_arithmetic_scalar<Input>>* = nullptr>
+inline void collect_adjoints(Output&& output, Input&& input) {
+  return iter_tuple_nested(
+      [](auto&& output_i, auto&& input_i) {
+        using output_i_t = std::decay_t<decltype(output_i)>;
+        if constexpr (is_std_vector_v<output_i_t>) {
+          Eigen::Map<Eigen::Matrix<double, -1, 1>> output_map(output_i.data(),
+                                                              output_i.size());
+          Eigen::Map<Eigen::Matrix<double, -1, 1>> input_map(input_i.data(),
+                                                             input_i.size());
+          output_map.array() += input_map.array();
+        } else if constexpr (is_eigen_v<output_i_t>) {
+          output_i.array() += input_i.array();
+        } else if constexpr (is_stan_scalar_v<output_i_t>) {
+          output_i += input_i;
+        } else {
+          static_assert(
+              sizeof(std::decay_t<output_i_t>*) == 0,
+              "INTERNAL ERROR:(laplace_marginal_lpdf) set_zero_adjoints was "
+              "not able to deduce the actions needed for the given type.");
+        }
+      },
+      std::forward<Output>(output), std::forward<Input>(input));
+}
+/**
+ * Base case for zero sized tuples
+ */
+template <bool ZeroInput = false>
+inline void constexpr copy_compute_s2(const std::tuple<>& output,
+                                      const std::tuple<>& input) noexcept {}
+
+/**
+ * Copies the adjoints from the input to the output, scaling them by 0.5.
+ * @tparam ZeroInput If true, the adjoints of the input will be set to zero
+ * @tparam Output A tuple or type where all scalar types are `arithmetic` types
+ * @tparam Input A tuple or type where all scalar types are `var` types
+ * @param output The output to which the adjoints will be added
+ * @param input The input from which the adjoints will be collected
+ */
+template <bool ZeroInput = false, typename Output, typename Input,
+          require_t<is_all_arithmetic_scalar<Output>>* = nullptr,
+          require_t<is_any_var_scalar<Input>>* = nullptr>
+inline void copy_compute_s2(Output&& output, Input&& input) {
+  return iter_tuple_nested(
+      [](auto&& output_i, auto&& input_i) {
+        using output_i_t = std::decay_t<decltype(output_i)>;
+        if constexpr (is_std_vector_v<output_i_t>) {
+          Eigen::Map<Eigen::Matrix<double, -1, 1>> output_map(output_i.data(),
+                                                              output_i.size());
+          Eigen::Map<Eigen::Matrix<var, -1, 1>> input_map(input_i.data(),
+                                                          input_i.size());
+          output_map.array() += 0.5 * input_map.adj().array();
+          if constexpr (ZeroInput) {
+            input_map.adj().setZero();
+          }
+        } else if constexpr (is_eigen_v<output_i_t>) {
+          output_i.array() += 0.5 * input_i.adj().array();
+          if constexpr (ZeroInput) {
+            input_i.adj().setZero();
+          }
+        } else if constexpr (is_stan_scalar_v<output_i_t>) {
+          output_i += (0.5 * input_i.adj());
+          if constexpr (ZeroInput) {
+            input_i.adj() = 0;
+          }
+        } else {
+          static_assert(
+              sizeof(std::decay_t<output_i_t>*) == 0,
+              "INTERNAL ERROR:(laplace_marginal_lpdf) set_zero_adjoints was "
+              "not able to deduce the actions needed for the given type.");
+        }
+      },
+      std::forward<Output>(output), std::forward<Input>(input));
+}
+
+template <typename T>
+inline constexpr decltype(auto) filter_var_scalar_types(T&& t) {
+  return stan::math::filter_map<is_any_var_scalar>(
+      [](auto&& arg) -> decltype(auto) {
+        return std::forward<decltype(arg)>(arg);
+      },
+      std::forward<T>(t));
+}
+/**
+ * Creates an arena type from the input with initialized with zeros
+ * @tparam Input Possibly a tuple, std::vector, Eigen type, or scalar
+ * @param input The input to be converted to an arena type
+ */
+template <typename Input>
+inline constexpr auto make_zeroed_arena(Input&& input) {
+  if constexpr (is_tuple_v<Input>) {
+    return stan::math::filter_map<is_any_var_scalar>(
+        [](auto&& output_i) { return make_zeroed_arena(output_i); }, input);
+  } else if constexpr (is_std_vector_v<Input>) {
+    if constexpr (!is_var_v<value_type_t<Input>>) {
+      const auto output_size = input.size();
+      arena_t<std::vector<decltype(make_zeroed_arena(input[0]))>> ret;
+      ret.reserve(output_size);
+      for (Eigen::Index i = 0; i < output_size; ++i) {
+        ret.push_back(make_zeroed_arena(input[i]));
+      }
+      return ret;
+    } else {
+      return arena_t<std::vector<double>>(input.size(), 0.0);
+    }
+  } else if constexpr (is_eigen_v<Input>) {
+    return arena_t<promote_scalar_t<double, Input>>(
+        plain_type_t<promote_scalar_t<double, Input>>::Zero(input.rows(),
+                                                            input.cols()));
+  } else if constexpr (is_var<Input>::value) {
+    return static_cast<double>(0.0);
+  }
+}
+
+/**
+ * Used in reverse pass to collect adjoints to the output
+ * @tparam Output A tuple or type where all scalar types are `var` types
+ * @tparam Input A tuple or type where all scalar types are `arithmetic` types
+ * @param output The output to which the adjoints will be added
+ * @param ret The vari object containing the adjoint to be added
+ * @param input The input from which the adjoints will be collected
+ */
+template <typename Output, typename Input>
+inline void collect_adjoints(Output&& output, const vari* ret, Input&& input) {
+  if constexpr (is_tuple_v<Output>) {
+    static_assert(sizeof(std::decay_t<Output>*) == 0,
+                  "INTERNAL ERROR:(laplace_marginal_lpdf)"
+                  "Accumulate Adjoints called on a tuple, but tuples cannot be "
+                  "on the reverse mode stack!"
+                  "This is an internal error, please report it to the stan "
+                  "github as an issue.");
+  } else if constexpr (is_std_vector_v<Output>) {
+    if constexpr (!is_var_v<value_type_t<Output>>) {
+      const auto output_size = output.size();
+      for (std::size_t i = 0; i < output_size; ++i) {
+        collect_adjoints(output[i], ret, input[i]);
+      }
+    } else {
+      Eigen::Map<Eigen::Matrix<var, -1, 1>> output_map(output.data(),
+                                                       output.size());
+      Eigen::Map<const Eigen::Matrix<double, -1, 1>> input_map(input.data(),
+                                                               input.size());
+      output_map.array().adj() += ret->adj_ * input_map.array();
+    }
+  } else if constexpr (is_eigen_v<Output>) {
+    output.adj().array() += ret->adj_ * input.array();
+  } else if constexpr (is_var_v<Output>) {
+    output.adj() += ret->adj_ * input;
+  }
+}
+
+/**
+ * Collects adjoints from a tuple or std::vector of tuples
+ * @tparam Output A tuple or std::vector of tuples where all scalar types are
+ * `var` types
+ * @tparam Input A tuple or std::vector of tuples where all scalar types are
+ * `arithmetic` types
+ * @param ret The vari object containing the adjoint to be added
+ * @param output The output to which the adjoints will be added
+ * @param input The input from which the adjoints will be collected
+ */
+template <typename Output, typename Input>
+inline void reverse_pass_collect_adjoints(var ret, Output&& output,
+                                          Input&& input) {
+  if constexpr (is_tuple_v<Output>) {
+    stan::math::for_each(
+        [ret](auto&& inner_arg, auto&& inner_input) mutable {
+          reverse_pass_collect_adjoints(
+              ret, std::forward<decltype(inner_arg)>(inner_arg),
+              std::forward<decltype(inner_input)>(inner_input));
+        },
+        std::forward<Output>(output), std::forward<Input>(input));
+  } else if constexpr (is_std_vector_containing_tuple_v<Output>) {
+    for (std::size_t i = 0; i < output.size(); ++i) {
+      reverse_pass_collect_adjoints(ret, output[i], input[i]);
+    }
+  } else {
+    reverse_pass_callback(
+        [vi = ret.vi_, arg_arena = to_arena(std::forward<Output>(output)),
+         input_arena = to_arena(std::forward<Input>(input))]() mutable {
+          collect_adjoints(arg_arena, vi, input_arena);
+        });
+  }
+}
+}  // namespace internal
+/**
+ * For a latent Gaussian model with global parameters phi, latent
+ * variables theta, and observations y, this function computes
+ * an approximation of the log marginal density, p(y | phi).
+ * This is done by marginalizing out theta, using a Laplace
+ * approxmation. The latter is obtained by finding the mode,
+ * using a custom Newton method, and the Hessian of the likelihood.
+ *
+ * The convergence criterion for the Newton is a small change in
+ * the log marginal density. The user controls the tolerance (i.e.
+ * threshold under which change is deemed small enough) and
+ * maximum number of steps.
+ *
+ * Wrapper for when the global parameter is passed as a double.
+ *
+ * @tparam LLFun Type with a valid `operator(ThetaVec,  InnerLLTupleArgs)`
+ * where `InnerLLTupleArgs` are the elements of `LLTupleArgs`
+ * @tparam LLTupleArgs A tuple whose elements follow the types required for
+ * `LLFun`
+ * \laplace_common_template_args
+ * @param[in] ll_fun A log likelihood functor
+ * @param[in] ll_args Tuple containing parameters for `LLFun`
+ * \laplace_common_args
+ * @param[in] options A set of options for tuning the solver
+ * \msg_arg
+ * @return the log maginal density, p(y | phi)
+ */
+template <
+    typename LLFun, typename LLTupleArgs, typename CovarFun, typename ThetaVec,
+    typename CovarArgs,
+    require_t<is_any_var_scalar<ThetaVec, LLTupleArgs, CovarArgs>>* = nullptr,
+    require_eigen_vector_t<ThetaVec>* = nullptr>
+inline auto laplace_marginal_density(const LLFun& ll_fun, LLTupleArgs&& ll_args,
+                                     ThetaVec&& theta_0,
+                                     CovarFun&& covariance_function,
+                                     CovarArgs&& covar_args,
+                                     const laplace_options& options,
+                                     std::ostream* msgs) {
+  auto covar_args_refs = to_ref(std::forward<CovarArgs>(covar_args));
+  auto ll_args_refs = to_ref(std::forward<LLTupleArgs>(ll_args));
+  // Solver 1, 2, 3
+  constexpr bool ll_args_contain_var = is_any_var_scalar<LLTupleArgs>::value;
+  auto partial_parm = internal::make_zeroed_arena(ll_args_refs);
+  auto covar_args_adj = internal::make_zeroed_arena(covar_args_refs);
+  double lmd = 0.0;
+  {
+    nested_rev_autodiff nested;
+    // Solver 1, 2
+    arena_t<Eigen::MatrixXd> R(theta_0.size(), theta_0.size());
+    // Solver 3
+    arena_t<Eigen::MatrixXd> LU_solve_covariance;
+    // Solver 1, 2, 3
+    arena_t<promote_scalar_t<double, std::decay_t<ThetaVec>>> s2(
+        theta_0.size());
+    // Make one hard copy here
+    using laplace_likelihood::internal::conditional_copy_and_promote;
+    using laplace_likelihood::internal::COPY_TYPE;
+    auto ll_args_copy
+        = conditional_copy_and_promote<is_any_var_scalar, var, COPY_TYPE::DEEP>(
+            ll_args_refs);
+
+    auto md_est = internal::laplace_marginal_density_est(
+        ll_fun, ll_args_copy, value_of(theta_0), covariance_function,
+        value_of(covar_args_refs), options, msgs);
+    // Return references to var types
+    auto ll_args_filter = internal::filter_var_scalar_types(ll_args_copy);
+    stan::math::for_each(
+        [](auto&& output_i, auto&& ll_arg_i) {
+          if (is_any_var_scalar_v<decltype(ll_arg_i)>) {
+            internal::collect_adjoints<true>(output_i, ll_arg_i);
+          }
+        },
+        partial_parm, ll_args_filter);
+    if (options.solver == 1) {
+      if (options.hessian_block_size == 1) {
+        // TODO(Steve): Solve without casting from sparse to dense
+        Eigen::MatrixXd tmp
+            = md_est.L.template triangularView<Eigen::Lower>().solve(
+                md_est.W_r.toDense());
+        R = tmp.transpose() * tmp;
+        arena_t<Eigen::MatrixXd> C
+            = md_est.L.template triangularView<Eigen::Lower>().solve(
+                md_est.W_r * md_est.covariance);
+        if constexpr (!ll_args_contain_var) {
+          s2.deep_copy(
+              (0.5
+               * (md_est.covariance.diagonal() - (C.transpose() * C).diagonal())
+                     .cwiseProduct(laplace_likelihood::third_diff(
+                         ll_fun, md_est.theta, value_of(ll_args_copy), msgs))));
+        } else {
+          arena_t<Eigen::MatrixXd> A = md_est.covariance - C.transpose() * C;
+          auto s2_tmp = laplace_likelihood::compute_s2(
+              ll_fun, md_est.theta, A, options.hessian_block_size, ll_args_copy,
+              msgs);
+          s2.deep_copy(s2_tmp);
+          internal::copy_compute_s2<true>(partial_parm, ll_args_filter);
+        }
+
+      } else {
+        Eigen::MatrixXd tmp
+            = md_est.L.template triangularView<Eigen::Lower>().solve(
+                md_est.W_r.toDense());
+        R = tmp.transpose() * tmp;
+        arena_t<Eigen::MatrixXd> C
+            = md_est.L.template triangularView<Eigen::Lower>().solve(
+                md_est.W_r * md_est.covariance);
+        arena_t<Eigen::MatrixXd> A = md_est.covariance - C.transpose() * C;
+        auto s2_tmp = laplace_likelihood::compute_s2(ll_fun, md_est.theta, A,
+                                                     options.hessian_block_size,
+                                                     ll_args_copy, msgs);
+        s2.deep_copy(s2_tmp);
+        internal::copy_compute_s2<true>(partial_parm, ll_args_filter);
+      }
+    } else if (options.solver == 2) {
+      R = md_est.W_r
+          - md_est.W_r * md_est.K_root
+                * md_est.L.transpose()
+                      .template triangularView<Eigen::Upper>()
+                      .solve(
+                          md_est.L.template triangularView<Eigen::Lower>()
+                              .solve(md_est.K_root.transpose() * md_est.W_r));
+
+      arena_t<Eigen::MatrixXd> C
+          = md_est.L.template triangularView<Eigen::Lower>().solve(
+              md_est.K_root.transpose());
+      auto s2_tmp = laplace_likelihood::compute_s2(
+          ll_fun, md_est.theta, (C.transpose() * C).eval(),
+          options.hessian_block_size, ll_args_copy, msgs);
+      s2.deep_copy(s2_tmp);
+      internal::copy_compute_s2<true>(partial_parm, ll_args_filter);
+    } else {  // options.solver with LU decomposition
+      LU_solve_covariance = md_est.LU.solve(md_est.covariance);
+      R = md_est.W_r - md_est.W_r * LU_solve_covariance * md_est.W_r;
+      arena_t<Eigen::MatrixXd> A
+          = md_est.covariance
+            - md_est.covariance * md_est.W_r * LU_solve_covariance;
+      auto s2_tmp = laplace_likelihood::compute_s2(ll_fun, md_est.theta, A,
+                                                   options.hessian_block_size,
+                                                   ll_args_copy, msgs);
+      s2.deep_copy(s2_tmp);
+      internal::copy_compute_s2<true>(partial_parm, ll_args_filter);
+    }
+    lmd = md_est.lmd;
+    if constexpr (is_any_var_scalar_v<scalar_type_t<CovarArgs>>) {
+      [&covar_args_refs, &covar_args_adj, &md_est, &R, &s2,
+       &covariance_function, &msgs]() mutable {
+        const nested_rev_autodiff nested;
+        auto covar_args_copy
+            = laplace_likelihood::internal::conditional_copy_and_promote<
+                is_any_var_scalar, var,
+                laplace_likelihood::internal::COPY_TYPE::DEEP>(covar_args_refs);
+
+        var_value<Eigen::MatrixXd> K_var = to_var_value(stan::math::apply(
+            [&covariance_function, &msgs](auto&&... args) {
+              return covariance_function(args..., msgs);
+            },
+            covar_args_copy));
+        arena_t<Eigen::MatrixXd> K_adj_arena
+            = 0.5 * md_est.a * md_est.a.transpose() - 0.5 * R
+              + s2 * md_est.theta_grad.transpose()
+              - (R * (K_var.val() * s2)) * md_est.theta_grad.transpose();
+        var Z = make_callback_var(0.0, [K_var, K_adj_arena](auto&& vi) mutable {
+          K_var.adj().array() += vi.adj() * K_adj_arena.array();
+        });
+        grad(Z.vi_);
+        auto covar_args_filter
+            = internal::filter_var_scalar_types(covar_args_copy);
+        internal::collect_adjoints(covar_args_adj, covar_args_filter);
+      }();
+    }
+    if constexpr (ll_args_contain_var) {
+      arena_t<Eigen::VectorXd> v;
+      if (options.solver == 1 || options.solver == 2) {
+        v = md_est.covariance * s2
+            - md_est.covariance * R * md_est.covariance * s2;
+      } else {
+        v = LU_solve_covariance * s2;
+      }
+      laplace_likelihood::diff_eta_implicit(ll_fun, v, md_est.theta,
+                                            ll_args_copy, msgs);
+      internal::collect_adjoints<true>(partial_parm, ll_args_filter);
+    }
+  }
+  var ret(lmd);
+  if constexpr (is_any_var_scalar_v<CovarArgs>) {
+    auto covar_args_filter = internal::filter_var_scalar_types(covar_args_refs);
+    internal::reverse_pass_collect_adjoints(ret, covar_args_filter,
+                                            covar_args_adj);
+  }
+  if constexpr (ll_args_contain_var) {
+    auto ll_args_filter = internal::filter_var_scalar_types(ll_args_refs);
+    internal::reverse_pass_collect_adjoints(ret, ll_args_filter, partial_parm);
+  }
+  return ret;
+}
+
+}  // namespace math
+}  // namespace stan
+
+#endif
diff --git a/stan/math/mix/prob.hpp b/stan/math/mix/prob.hpp
new file mode 100644
index 00000000000..99babe99e3f
--- /dev/null
+++ b/stan/math/mix/prob.hpp
@@ -0,0 +1,15 @@
+#ifndef STAN_MATH_MIX_PROB_HPP
+#define STAN_MATH_MIX_PROB_HPP
+
+#include <stan/math/mix/prob/laplace_latent_bernoulli_logit_rng.hpp>
+#include <stan/math/mix/prob/laplace_latent_poisson_log_rng.hpp>
+#include <stan/math/mix/prob/laplace_latent_poisson_log_2_rng.hpp>
+#include <stan/math/mix/prob/laplace_latent_neg_binomial_2_log_rng.hpp>
+#include <stan/math/mix/prob/laplace_latent_rng.hpp>
+#include <stan/math/mix/prob/laplace_marginal.hpp>
+#include <stan/math/mix/prob/laplace_marginal_neg_binomial_2_log_lpmf.hpp>
+#include <stan/math/mix/prob/laplace_marginal_bernoulli_logit_lpmf.hpp>
+#include <stan/math/mix/prob/laplace_marginal_poisson_log_2_lpmf.hpp>
+#include <stan/math/mix/prob/laplace_marginal_poisson_log_lpmf.hpp>
+
+#endif
diff --git a/stan/math/mix/prob/laplace_latent_bernoulli_logit_rng.hpp b/stan/math/mix/prob/laplace_latent_bernoulli_logit_rng.hpp
new file mode 100644
index 00000000000..342225e2c8e
--- /dev/null
+++ b/stan/math/mix/prob/laplace_latent_bernoulli_logit_rng.hpp
@@ -0,0 +1,80 @@
+#ifndef STAN_MATH_MIX_PROB_LAPLACE_LATENT_BERNOULLI_LOGIT_RNG_HPP
+#define STAN_MATH_MIX_PROB_LAPLACE_LATENT_BERNOULLI_LOGIT_RNG_HPP
+
+#include <stan/math/mix/functor/laplace_base_rng.hpp>
+#include <stan/math/mix/functor/laplace_likelihood.hpp>
+#include <stan/math/mix/prob/laplace_marginal_bernoulli_logit_lpmf.hpp>
+
+namespace stan {
+namespace math {
+
+/**
+ * In a latent gaussian model,
+ *
+ *   theta ~ Normal(theta|0, Sigma(phi))
+ *   y ~ pi(y|theta)
+ *
+ * return a multivariate normal random variate sampled
+ * from the gaussian approximation of p(theta | y, phi),
+ * where the likelihood is a Bernoulli with logit link.
+ * \laplace_common_template_args
+ * @tparam RNG A valid boost rng type
+ * @param[in] y Vector Vector of total number of trials with a positive outcome.
+ * @param[in] n_samples Vector of number of trials.
+ * \laplace_common_args
+ * \laplace_options
+ * \rng_arg
+ * \msg_arg
+ */
+template <typename ThetaVec, typename CovarFun, typename CovarArgs,
+          typename RNG, require_eigen_t<ThetaVec>* = nullptr>
+inline Eigen::VectorXd laplace_latent_tol_bernoulli_logit_rng(
+    const std::vector<int>& y, const std::vector<int>& n_samples,
+    ThetaVec&& theta_0, CovarFun&& covariance_function, CovarArgs&& covar_args,
+    const double tolerance, const int max_num_steps,
+    const int hessian_block_size, const int solver,
+    const int max_steps_line_search, RNG& rng, std::ostream* msgs) {
+  laplace_options ops{hessian_block_size, solver, max_steps_line_search,
+                      tolerance, max_num_steps};
+  return laplace_base_rng(bernoulli_logit_likelihood{},
+                          std::forward_as_tuple(to_vector(y), n_samples),
+                          std::forward<ThetaVec>(theta_0),
+                          std::forward<CovarFun>(covariance_function),
+                          std::forward<CovarArgs>(covar_args), ops, rng, msgs);
+}
+
+/**
+ * In a latent gaussian model,
+ *
+ *   theta ~ Normal(theta|0, Sigma(phi))
+ *   y ~ pi(y|theta)
+ *
+ * return a multivariate normal random variate sampled
+ * from the gaussian approximation of p(theta | y, phi),
+ * where the likelihood is a Bernoulli with logit link.
+ * \laplace_common_template_args
+ * @tparam RNG A valid boost rng type
+ * @param[in] y Vector Vector of total number of trials with a positive outcome.
+ * @param[in] n_samples Vector of number of trials.
+ * \laplace_common_args
+ * \rng_arg
+ * \msg_arg
+ */
+template <typename CovarFun, typename ThetaVec, typename CovarArgs,
+          typename RNG, require_eigen_t<ThetaVec>* = nullptr>
+inline Eigen::VectorXd laplace_latent_bernoulli_logit_rng(
+    const std::vector<int>& y, const std::vector<int>& n_samples,
+    ThetaVec&& theta_0, CovarFun&& covariance_function, CovarArgs&& covar_args,
+    RNG& rng, std::ostream* msgs) {
+  constexpr laplace_options ops{1, 1, 0, 1e-6, 100};
+  return laplace_base_rng(bernoulli_logit_likelihood{},
+                          std::forward_as_tuple(to_vector(y), n_samples),
+                          std::forward<ThetaVec>(theta_0),
+                          std::forward<CovarFun>(covariance_function),
+                          std::forward<CovarArgs>(covar_args), ops, rng, msgs);
+}
+
+}  // namespace math
+}  // namespace stan
+
+#endif
diff --git a/stan/math/mix/prob/laplace_latent_neg_binomial_2_log_rng.hpp b/stan/math/mix/prob/laplace_latent_neg_binomial_2_log_rng.hpp
new file mode 100644
index 00000000000..38242b7a524
--- /dev/null
+++ b/stan/math/mix/prob/laplace_latent_neg_binomial_2_log_rng.hpp
@@ -0,0 +1,94 @@
+#ifndef STAN_MATH_MIX_PROB_LAPLACE_LATENT_NEG_BINOMIAL_2_LOG_RNG_HPP
+#define STAN_MATH_MIX_PROB_LAPLACE_LATENT_NEG_BINOMIAL_2_LOG_RNG_HPP
+
+#include <stan/math/mix/functor/laplace_base_rng.hpp>
+#include <stan/math/mix/functor/laplace_likelihood.hpp>
+#include <stan/math/mix/prob/laplace_marginal_neg_binomial_2_log_lpmf.hpp>
+
+namespace stan {
+namespace math {
+
+/**
+ * In a latent gaussian model,
+ *
+ *   theta ~ Normal(0, Sigma(phi))
+ *   y ~ p(y|theta,phi)
+ *
+ * return a sample from the Laplace approximation to p(theta|y,phi).
+ * The Laplace approximation is computed using a Newton solver.
+ * In this specialized function, the likelihood p(y|theta) is a
+ * Negative Binomial with a log link. This function uses the second
+ * parameterization of the Negative Binomial.
+ *
+ * @tparam Eta A type for the overdispersion parameter.
+ * \laplace_common_template_args
+ * @tparam RNG A valid boost rng type
+ * @param[in] y Observed counts.
+ * @param[in] y_index Index indicating which group each observation belongs to.
+ * @param[in] eta Overdisperison parameter.
+ * \laplace_common_args
+ * \laplace_options
+ * \rng_arg
+ * \msg_arg
+ */
+template <typename Eta, typename ThetaVec, typename CovarFun,
+          typename CovarArgs, typename RNG,
+          require_eigen_t<ThetaVec>* = nullptr>
+inline Eigen::VectorXd laplace_latent_tol_neg_binomial_2_log_rng(
+    const std::vector<int>& y, const std::vector<int>& y_index, Eta&& eta,
+    ThetaVec&& theta_0, CovarFun&& covariance_function, CovarArgs&& covar_args,
+    const double tolerance, const int max_num_steps,
+    const int hessian_block_size, const int solver,
+    const int max_steps_line_search, RNG& rng, std::ostream* msgs) {
+  laplace_options ops{hessian_block_size, solver, max_steps_line_search,
+                      tolerance, max_num_steps};
+  return laplace_base_rng(
+      neg_binomial_2_log_likelihood{},
+      std::forward_as_tuple(std::forward<Eta>(eta), y, y_index),
+      std::forward<ThetaVec>(theta_0),
+      std::forward<CovarFun>(covariance_function),
+      std::forward<CovarArgs>(covar_args), ops, rng, msgs);
+}
+
+/**
+ * In a latent gaussian model,
+ *
+ *   theta ~ Normal(0, Sigma(phi))
+ *   y ~ p(y|theta,phi)
+ *
+ * return a sample from the Laplace approximation to p(theta|y,phi).
+ * The Laplace approximation is computed using a Newton solver.
+ * In this specialized function, the likelihood p(y|theta) is a
+ * Negative Binomial with a log link. This function uses the second
+ * parameterization of the Negative Binomial.
+ *
+ * @tparam Eta A type for the overdispersion parameter.
+ * \laplace_common_template_args
+ * @tparam RNG A valid boost rng type
+ * @param[in] y Observed counts.
+ * @param[in] y_index Index indicating which group each observation belongs to.
+ * @param[in] eta Overdisperison parameter.
+ * \laplace_common_args
+ * \rng_arg
+ * \msg_arg
+ */
+template <typename Eta, typename ThetaVec, typename CovarFun,
+          typename CovarArgs, typename RNG,
+          require_eigen_t<ThetaVec>* = nullptr>
+inline Eigen::VectorXd laplace_latent_neg_binomial_2_log_rng(
+    const std::vector<int>& y, const std::vector<int>& y_index, Eta&& eta,
+    ThetaVec&& theta_0, CovarFun&& covariance_function, CovarArgs&& covar_args,
+    RNG& rng, std::ostream* msgs) {
+  constexpr laplace_options ops{1, 1, 0, 1e-6, 100};
+  return laplace_base_rng(
+      neg_binomial_2_log_likelihood{},
+      std::forward_as_tuple(std::forward<Eta>(eta), y, y_index),
+      std::forward<ThetaVec>(theta_0),
+      std::forward<CovarFun>(covariance_function),
+      std::forward<CovarArgs>(covar_args), ops, rng, msgs);
+}
+
+}  // namespace math
+}  // namespace stan
+
+#endif
diff --git a/stan/math/mix/prob/laplace_latent_poisson_log_2_rng.hpp b/stan/math/mix/prob/laplace_latent_poisson_log_2_rng.hpp
new file mode 100644
index 00000000000..8b22f6b14bf
--- /dev/null
+++ b/stan/math/mix/prob/laplace_latent_poisson_log_2_rng.hpp
@@ -0,0 +1,84 @@
+#ifndef STAN_MATH_MIX_PROB_LAPLACE_LATENT_POISSON_LOG_2_RNG_HPP
+#define STAN_MATH_MIX_PROB_LAPLACE_LATENT_POISSON_LOG_2_RNG_HPP
+
+#include <stan/math/mix/functor/laplace_base_rng.hpp>
+#include <stan/math/mix/functor/laplace_likelihood.hpp>
+#include <stan/math/mix/prob/laplace_marginal_poisson_log_2_lpmf.hpp>
+
+namespace stan {
+namespace math {
+
+/**
+ * Wrapper function around the laplace_marginal function for
+ * a log poisson likelihood with exposure. Returns the marginal density
+ * p(y | phi) by marginalizing out the latent gaussian variable,
+ * with a Laplace approximation. See the laplace_marginal function
+ * for more details.
+ *
+ * @tparam YeVec A type inheriting from `Eigen::EigenBase` with dynamic
+ *  sized rows and 1 column.
+ * \laplace_common_template_args
+ * @tparam RNG A valid boost rng type
+ * @param[in] y total counts per group. Second sufficient statistics.
+ * @param[in] y_index group to which each observation belongs.
+ * @param[in] ye the exposure for each group.
+ * \laplace_common_args
+ * \laplace_options
+ * \rng_arg
+ * \msg_arg
+ */
+template <typename YeVec, typename ThetaVec, typename CovarFun,
+          typename CovarArgs, typename RNG,
+          require_eigen_t<ThetaVec>* = nullptr>
+inline auto laplace_latent_tol_poisson_2_log_rng(
+    const std::vector<int>& y, const std::vector<int>& y_index, const YeVec& ye,
+    ThetaVec&& theta_0, CovarFun&& covariance_function, CovarArgs&& covar_args,
+    const double tolerance, const int max_num_steps,
+    const int hessian_block_size, const int solver,
+    const int max_steps_line_search, RNG& rng, std::ostream* msgs) {
+  laplace_options ops{hessian_block_size, solver, max_steps_line_search,
+                      tolerance, max_num_steps};
+  return laplace_base_rng(poisson_log_2_likelihood{},
+                          std::forward_as_tuple(y, y_index, ye),
+                          std::forward<ThetaVec>(theta_0),
+                          std::forward<CovarFun>(covariance_function),
+                          std::forward<CovarArgs>(covar_args), ops, rng, msgs);
+}
+
+/**
+ * Wrapper function around the laplace_marginal function for
+ * a log poisson likelihood with exposure. Returns the marginal density
+ * p(y | phi) by marginalizing out the latent gaussian variable,
+ * with a Laplace approximation. See the laplace_marginal function
+ * for more details.
+ *
+ * @tparam YeVec A type inheriting from `Eigen::EigenBase` with dynamic
+ *  sized rows and 1 column.
+ * \laplace_common_template_args
+ * @tparam RNG A valid boost rng type
+ * @param[in] y total counts per group. Second sufficient statistics.
+ * @param[in] y_index group to which each observation belongs.
+ * @param[in] ye the exposure for each group.
+ * \laplace_common_args
+ * \rng_arg
+ * \msg_arg
+ */
+template <typename YeVec, typename ThetaVec, typename CovarFun,
+          typename CovarArgs, typename RNG,
+          require_eigen_t<ThetaVec>* = nullptr>
+inline auto laplace_latent_poisson_2_log_rng(
+    const std::vector<int>& y, const std::vector<int>& y_index, const YeVec& ye,
+    ThetaVec&& theta_0, CovarFun&& covariance_function, CovarArgs&& covar_args,
+    RNG& rng, std::ostream* msgs) {
+  constexpr laplace_options ops{1, 1, 0, 1e-6, 100};
+  return laplace_base_rng(poisson_log_2_likelihood{},
+                          std::forward_as_tuple(y, y_index, ye),
+                          std::forward<ThetaVec>(theta_0),
+                          std::forward<CovarFun>(covariance_function),
+                          std::forward<CovarArgs>(covar_args), ops, rng, msgs);
+}
+
+}  // namespace math
+}  // namespace stan
+
+#endif
diff --git a/stan/math/mix/prob/laplace_latent_poisson_log_rng.hpp b/stan/math/mix/prob/laplace_latent_poisson_log_rng.hpp
new file mode 100644
index 00000000000..2dcafcc99e0
--- /dev/null
+++ b/stan/math/mix/prob/laplace_latent_poisson_log_rng.hpp
@@ -0,0 +1,80 @@
+#ifndef STAN_MATH_MIX_PROB_LAPLACE_LATENT_POISSON_LOG_RNG_HPP
+#define STAN_MATH_MIX_PROB_LAPLACE_LATENT_POISSON_LOG_RNG_HPP
+
+#include <stan/math/mix/functor/laplace_base_rng.hpp>
+#include <stan/math/mix/functor/laplace_likelihood.hpp>
+#include <stan/math/mix/prob/laplace_marginal_poisson_log_lpmf.hpp>
+
+namespace stan {
+namespace math {
+
+/**
+ * In a latent gaussian model,
+ *
+ *   theta ~ Normal(0, Sigma(phi))
+ *   y ~ p(y|theta,phi)
+ *
+ * return a sample from the Laplace approximation to p(theta|y,phi).
+ * The Laplace approximation is computed using a Newton solver.
+ * In this specialized function, the likelihood p(y|theta) is a
+ * \laplace_common_template_args
+ * @tparam RNG A valid boost rng type
+ * @param[in] y Observed counts.
+ * @param[in] y_index Index indicating which group each observation belongs to.
+ * \laplace_common_args
+ * \laplace_options
+ * \rng_arg
+ * \msg_arg
+ */
+template <typename ThetaVec, typename CovarFun, typename CovarArgs,
+          typename RNG, require_eigen_t<ThetaVec>* = nullptr>
+inline Eigen::VectorXd laplace_latent_tol_poisson_log_rng(
+    const std::vector<int>& y, const std::vector<int>& y_index,
+    ThetaVec&& theta_0, CovarFun&& covariance_function, CovarArgs&& covar_args,
+    const double tolerance, const int max_num_steps,
+    const int hessian_block_size, const int solver,
+    const int max_steps_line_search, RNG& rng, std::ostream* msgs) {
+  laplace_options ops{hessian_block_size, solver, max_steps_line_search,
+                      tolerance, max_num_steps};
+  return laplace_base_rng(poisson_log_likelihood{},
+                          std::forward_as_tuple(y, y_index),
+                          std::forward<ThetaVec>(theta_0),
+                          std::forward<CovarFun>(covariance_function),
+                          std::forward<CovarArgs>(covar_args), ops, rng, msgs);
+}
+
+/**
+ * In a latent gaussian model,
+ *
+ *   theta ~ Normal(0, Sigma(phi))
+ *   y ~ p(y|theta,phi)
+ *
+ * return a sample from the Laplace approximation to p(theta|y,phi).
+ * The Laplace approximation is computed using a Newton solver.
+ * In this specialized function, the likelihood p(y|theta) is a
+ * Poisson with a log link.
+ * \laplace_common_template_args
+ * @tparam RNG A valid boost rng type
+ * @param[in] y Observed counts.
+ * @param[in] y_index Index indicating which group each observation belongs to.
+ * \laplace_common_args
+ * \rng_arg
+ * \msg_arg
+ */
+template <typename ThetaVec, typename CovarFun, typename CovarArgs,
+          typename RNG, require_eigen_t<ThetaVec>* = nullptr>
+inline Eigen::VectorXd laplace_latent_poisson_log_rng(
+    const std::vector<int>& y, const std::vector<int>& y_index,
+    const ThetaVec& theta_0, CovarFun&& covariance_function,
+    CovarArgs&& covar_args, RNG& rng, std::ostream* msgs) {
+  constexpr laplace_options ops{1, 1, 0, 1e-6, 100};
+  return laplace_base_rng(poisson_log_likelihood{},
+                          std::forward_as_tuple(y, y_index), theta_0,
+                          std::forward<CovarFun>(covariance_function),
+                          std::forward<CovarArgs>(covar_args), ops, rng, msgs);
+}
+
+}  // namespace math
+}  // namespace stan
+
+#endif
diff --git a/stan/math/mix/prob/laplace_latent_rng.hpp b/stan/math/mix/prob/laplace_latent_rng.hpp
new file mode 100644
index 00000000000..b2be965e14c
--- /dev/null
+++ b/stan/math/mix/prob/laplace_latent_rng.hpp
@@ -0,0 +1,83 @@
+#ifndef STAN_MATH_MIX_PROB_LAPLACE_LATENT_RNG_HPP
+#define STAN_MATH_MIX_PROB_LAPLACE_LATENT_RNG_HPP
+
+#include <stan/math/mix/functor/laplace_base_rng.hpp>
+#include <stan/math/mix/functor/laplace_likelihood.hpp>
+#include <stan/math/prim/fun/to_ref.hpp>
+
+namespace stan {
+namespace math {
+
+/**
+ * In a latent gaussian model,
+ *
+ *   theta ~ Normal(0, Sigma(phi))
+ *   y ~ p(y|theta,phi)
+ *
+ * return a sample from the Laplace approximation to p(theta|y,phi),
+ * where the log likelihood is given by L_f.
+ * @tparam LLFunc Type of likelihood function.
+ * @tparam LLArgs Type of arguments of likelihood function.
+ * \laplace_common_template_args
+ * @tparam RNG A valid boost rng type
+ * @param[in] L_f Function that returns log likelihood.
+ * @param[in] ll_args Arguments for likelihood function.
+ * \laplace_common_args
+ * \laplace_options
+ * \rng_arg
+ * \msg_arg
+ */
+template <typename LLFunc, typename LLArgs, typename ThetaVec,
+          typename CovarFun, typename CovarArgs, typename RNG>
+inline auto laplace_latent_tol_rng(
+    LLFunc&& L_f, LLArgs&& ll_args, ThetaVec&& theta_0,
+    CovarFun&& covariance_function, CovarArgs&& covar_args,
+    const double tolerance, const int max_num_steps,
+    const int hessian_block_size, const int solver,
+    const int max_steps_line_search, RNG& rng, std::ostream* msgs) {
+  const laplace_options ops{hessian_block_size, solver, max_steps_line_search,
+                            tolerance, max_num_steps};
+  return laplace_base_rng(std::forward<LLFunc>(L_f),
+                          std::forward<LLArgs>(ll_args),
+                          std::forward<ThetaVec>(theta_0),
+                          std::forward<CovarFun>(covariance_function),
+                          std::forward<CovarArgs>(covar_args), ops, rng, msgs);
+}
+
+/**
+ * In a latent gaussian model,
+ *
+ *   theta ~ Normal(0, Sigma(phi))
+ *   y ~ p(y|theta,phi)
+ *
+ * return a sample from the Laplace approximation to p(theta|y,phi),
+ * where the log likelihood is given by L_f.
+ * @tparam LLFunc Type of likelihood function.
+ * @tparam LLArgs Type of arguments of likelihood function.
+ * \laplace_common_template_args
+ * @tparam RNG A valid boost rng type
+ * @param[in] L_f Function that returns log likelihood.
+ * @param[in] ll_args Arguments for likelihood function.
+ * \laplace_common_args
+ * \rng_arg
+ * \msg_arg
+ */
+template <typename LLFunc, typename LLArgs, typename ThetaVec,
+          typename CovarFun, typename CovarArgs, typename RNG>
+inline auto laplace_latent_rng(LLFunc&& L_f, LLArgs&& ll_args,
+                               ThetaVec&& theta_0,
+                               CovarFun&& covariance_function,
+                               CovarArgs&& covar_args, RNG& rng,
+                               std::ostream* msgs) {
+  constexpr laplace_options ops{1, 1, 0, 1e-6, 100};
+  return laplace_base_rng(std::forward<LLFunc>(L_f),
+                          std::forward<LLArgs>(ll_args),
+                          std::forward<ThetaVec>(theta_0),
+                          std::forward<CovarFun>(covariance_function),
+                          std::forward<CovarArgs>(covar_args), ops, rng, msgs);
+}
+
+}  // namespace math
+}  // namespace stan
+
+#endif
diff --git a/stan/math/mix/prob/laplace_marginal.hpp b/stan/math/mix/prob/laplace_marginal.hpp
new file mode 100644
index 00000000000..a7698d41d73
--- /dev/null
+++ b/stan/math/mix/prob/laplace_marginal.hpp
@@ -0,0 +1,78 @@
+#ifndef STAN_MATH_MIX_PROB_LAPLACE_MARGINAL_HPP
+#define STAN_MATH_MIX_PROB_LAPLACE_MARGINAL_HPP
+
+#include <stan/math/mix/functor/laplace_likelihood.hpp>
+#include <stan/math/mix/functor/laplace_marginal_density.hpp>
+
+namespace stan {
+namespace math {
+/**
+ * Wrapper function around the laplace_marginal_density function.
+ * Returns the marginal density p(y|phi) by marginalizing out
+ * the latent gaussian variable theta, with a Laplace approximation.
+ * See the laplace_marginal function for more details.
+ * The data y is assumed to be real.
+ * The function is "overloaded" below for the int y and lpmf case.
+ *
+ * @tparam propto If FALSE, log density is computed up to an additive const.
+ * @tparam LFun The function which returns the log likelihood.
+ * @tparam LArgs A tuple of arguments to the log likelihood.
+ * @tparam EtaVec The type of the parameter arguments for the likelihood fn.
+ * \laplace_common_template_args
+ * @param[in] L_f a function which returns the log likelihood.
+ * @param[in] l_args A tuple of arguments to pass to the log likelihood.
+ * \laplace_common_args
+ * \laplace_options
+ * \msg_arg
+ */
+template <bool propto = false, typename LFun, typename LArgs, typename CovarFun,
+          typename ThetaVec, typename CovarArgs,
+          require_all_eigen_vector_t<ThetaVec>* = nullptr>
+inline auto laplace_marginal_tol(
+    LFun&& L_f, LArgs&& l_args, const ThetaVec& theta_0,
+    CovarFun&& covariance_function, CovarArgs&& covar_args, double tolerance,
+    int max_num_steps, const int hessian_block_size, const int solver,
+    const int max_steps_line_search, std::ostream* msgs) {
+  laplace_options ops{hessian_block_size, solver, max_steps_line_search,
+                      tolerance, max_num_steps};
+  return laplace_marginal_density(
+      std::forward<LFun>(L_f), std::forward<LArgs>(l_args), theta_0,
+      std::forward<CovarFun>(covariance_function),
+      std::forward<CovarArgs>(covar_args), ops, msgs);
+}
+
+/**
+ * Wrapper function around the laplace_marginal function.
+ * Returns the marginal density p(y | phi) by marginalizing out
+ * the latent gaussian variable, with a Laplace approximation.
+ * See the laplace_marginal function for more details.
+ * The data y is assumed to be real.
+ * The function is "overloaded" below for the int y and lpmf case.
+ *
+ * @tparam propto If FALSE, log density is computed up to an additive const.
+ * @tparam LFun The function which returns the log likelihood.
+ * @tparam LArgs A tuple of arguments to the log likelihood.
+ * \laplace_common_template_args
+ * @param[in] L_f a function which returns the log likelihood.
+ * @param[in] l_args A tuple of arguments to pass to the log likelihood
+ * \laplace_common_args
+ * \msg_arg
+ */
+template <bool propto = false, typename LFun, typename LArgs, typename CovarFun,
+          typename ThetaVec, typename CovarArgs,
+          require_all_eigen_vector_t<ThetaVec>* = nullptr>
+inline auto laplace_marginal(LFun&& L_f, LArgs&& l_args,
+                             const ThetaVec& theta_0,
+                             CovarFun&& covariance_function,
+                             CovarArgs&& covar_args, std::ostream* msgs) {
+  constexpr laplace_options ops{1, 1, 0, 1e-6, 100};
+  return laplace_marginal_density(
+      std::forward<LFun>(L_f), std::forward<LArgs>(l_args), theta_0,
+      std::forward<CovarFun>(covariance_function),
+      std::forward<CovarArgs>(covar_args), ops, msgs);
+}
+
+}  // namespace math
+}  // namespace stan
+
+#endif
diff --git a/stan/math/mix/prob/laplace_marginal_bernoulli_logit_lpmf.hpp b/stan/math/mix/prob/laplace_marginal_bernoulli_logit_lpmf.hpp
new file mode 100644
index 00000000000..a0780e91511
--- /dev/null
+++ b/stan/math/mix/prob/laplace_marginal_bernoulli_logit_lpmf.hpp
@@ -0,0 +1,97 @@
+#ifndef STAN_MATH_MIX_PROB_LAPLACE_MARGINAL_BERNOULLI_LOGIT_LPMF_HPP
+#define STAN_MATH_MIX_PROB_LAPLACE_MARGINAL_BERNOULLI_LOGIT_LPMF_HPP
+
+#include <stan/math/mix/functor/laplace_likelihood.hpp>
+#include <stan/math/mix/functor/laplace_marginal_density.hpp>
+#include <stan/math/rev/core/operator_addition.hpp>
+#include <stan/math/rev/core/operator_subtraction.hpp>
+#include <stan/math/rev/fun/elt_multiply.hpp>
+#include <stan/math/rev/fun/exp.hpp>
+#include <stan/math/rev/fun/log.hpp>
+#include <stan/math/rev/fun/multiply.hpp>
+#include <stan/math/rev/fun/sum.hpp>
+#include <stan/math/fwd/fun/exp.hpp>
+#include <stan/math/fwd/fun/lgamma.hpp>
+#include <stan/math/fwd/fun/log.hpp>
+#include <stan/math/fwd/fun/sum.hpp>
+#include <stan/math/prim/fun/binomial_coefficient_log.hpp>
+
+namespace stan {
+namespace math {
+
+struct bernoulli_logit_likelihood {
+  template <typename T_theta, typename YVec>
+  inline auto operator()(const T_theta& theta, const YVec& y,
+                         const std::vector<int>& delta_int,
+                         std::ostream* pstream) const {
+    return sum(elt_multiply(theta, y)
+               - elt_multiply(to_vector(delta_int), log(add(1.0, exp(theta)))));
+  }
+};
+
+/**
+ * Wrapper function around the laplace_marginal function for
+ * a logistic Bernoulli likelihood. Returns the marginal density
+ * p(y | phi) by marginalizing out the latent gaussian variable,
+ * with a Laplace approximation. See the laplace_marginal function
+ * for more details.
+ *
+ * @tparam propto boolean ignored
+ * \laplace_common_template_args
+ * @param[in] y total counts per group. Second sufficient statistics.
+ * @param[in] n_samples number of samples per group. First sufficient
+ *            statistics.
+ * \laplace_common_args
+ * \laplace_options
+ * \msg_arg
+ */
+template <bool propto = false, typename ThetaVec, typename CovarFun,
+          typename CovarArgs, require_eigen_t<ThetaVec>* = nullptr>
+inline auto laplace_marginal_tol_bernoulli_logit_lpmf(
+    const std::vector<int>& y, const std::vector<int>& n_samples,
+    const ThetaVec& theta_0, CovarFun&& covariance_function,
+    CovarArgs&& covar_args, double tolerance, int max_num_steps,
+    const int hessian_block_size, const int solver,
+    const int max_steps_line_search, std::ostream* msgs) {
+  laplace_options ops{hessian_block_size, solver, max_steps_line_search,
+                      tolerance, max_num_steps};
+  return laplace_marginal_density(
+      bernoulli_logit_likelihood{},
+      std::forward_as_tuple(to_vector(y), n_samples), theta_0,
+      std::forward<CovarFun>(covariance_function),
+      std::forward<CovarArgs>(covar_args), ops, msgs);
+}
+
+/**
+ * Wrapper function around the laplace_marginal function for
+ * a logistic Bernoulli likelihood. Returns the marginal density
+ * p(y | phi) by marginalizing out the latent gaussian variable,
+ * with a Laplace approximation. See the laplace_marginal function
+ * for more details.
+ *
+ * @tparam propto boolean ignored
+ * \laplace_common_template_args
+ * @param[in] y total counts per group. Second sufficient statistics.
+ * @param[in] n_samples number of samples per group. First sufficient
+ *            statistics.
+ * \laplace_common_args
+ * \msg_arg
+ */
+template <bool propto = false, typename CovarFun, typename ThetaVec,
+          typename CovarArgs, require_eigen_t<ThetaVec>* = nullptr>
+inline auto laplace_marginal_bernoulli_logit_lpmf(
+    const std::vector<int>& y, const std::vector<int>& n_samples,
+    const ThetaVec& theta_0, CovarFun&& covariance_function,
+    CovarArgs&& covar_args, std::ostream* msgs) {
+  constexpr laplace_options ops{1, 1, 0, 1e-6, 100};
+  return laplace_marginal_density(
+      bernoulli_logit_likelihood{},
+      std::forward_as_tuple(to_vector(y), n_samples), theta_0,
+      std::forward<CovarFun>(covariance_function),
+      std::forward<CovarArgs>(covar_args), ops, msgs);
+}
+
+}  // namespace math
+}  // namespace stan
+
+#endif
diff --git a/stan/math/mix/prob/laplace_marginal_neg_binomial_2_log_lpmf.hpp b/stan/math/mix/prob/laplace_marginal_neg_binomial_2_log_lpmf.hpp
new file mode 100644
index 00000000000..e87dba5c605
--- /dev/null
+++ b/stan/math/mix/prob/laplace_marginal_neg_binomial_2_log_lpmf.hpp
@@ -0,0 +1,202 @@
+#ifndef STAN_MATH_MIX_PROB_LAPLACE_MARGINAL_NEG_BINOMIAL_2_LOG_LPMF_HPP
+#define STAN_MATH_MIX_PROB_LAPLACE_MARGINAL_NEG_BINOMIAL_2_LOG_LPMF_HPP
+
+#include <stan/math/mix/functor/laplace_likelihood.hpp>
+#include <stan/math/mix/functor/laplace_marginal_density.hpp>
+
+#include <stan/math/rev/core/operator_addition.hpp>
+#include <stan/math/rev/core/operator_multiplication.hpp>
+#include <stan/math/rev/core/operator_subtraction.hpp>
+#include <stan/math/rev/fun/dot_product.hpp>
+#include <stan/math/rev/fun/elt_multiply.hpp>
+#include <stan/math/rev/fun/lgamma.hpp>
+#include <stan/math/rev/fun/log.hpp>
+#include <stan/math/rev/fun/exp.hpp>
+#include <stan/math/rev/fun/multiply.hpp>
+#include <stan/math/rev/fun/sum.hpp>
+#include <stan/math/fwd/fun/exp.hpp>
+#include <stan/math/fwd/fun/lgamma.hpp>
+#include <stan/math/fwd/fun/log.hpp>
+#include <stan/math/fwd/fun/sum.hpp>
+#include <stan/math/prim/fun/binomial_coefficient_log.hpp>
+
+namespace stan {
+namespace math {
+
+struct neg_binomial_2_log_likelihood {
+  template <typename T_theta, typename T_eta>
+  inline return_type_t<T_theta, T_eta> operator()(
+      const T_theta& theta, const T_eta& eta, const std::vector<int>& y,
+      const std::vector<int>& y_index, std::ostream* pstream) const {
+    Eigen::VectorXi n_per_group = Eigen::VectorXi::Zero(theta.size());
+    Eigen::VectorXi counts_per_group = Eigen::VectorXi::Zero(theta.size());
+
+    for (int i = 0; i < y.size(); i++) {
+      n_per_group[y_index[i]]++;
+      counts_per_group[y_index[i]] += y[i];
+    }
+    Eigen::Map<const Eigen::VectorXi> y_map(y.data(), y.size());
+    auto log_eta_plus_exp_theta = eval(log(add(eta, exp(theta))));
+    return sum(binomial_coefficient_log(subtract(add(y_map, eta), 1), y_map))
+           + sum(add(elt_multiply(counts_per_group,
+                                  subtract(theta, log_eta_plus_exp_theta)),
+                     elt_multiply(multiply(n_per_group, eta),
+                                  subtract(log(eta), log_eta_plus_exp_theta))));
+  }
+};
+
+/**
+ * Wrapper function around the laplace_marginal function for
+ * a negative binomial likelihood. Uses the 2nd parameterization.
+ * Returns the marginal density p(y|phi) by marginalizing
+ * out the latent gaussian variable, with a Laplace approximation.
+ * See the laplace_marginal function for more details.
+ *
+ * @tparam Eta The type of parameter arguments for the likelihood function.
+ * \laplace_common_template_args
+ * @param[in] y observed counts.
+ * @param[in] y_index group to which each observation belongs. Each group
+ *            is parameterized by one element of theta.
+ * @param[in] eta non-marginalized model parameters for the likelihood.
+ * \laplace_common_args
+ * \laplace_options
+ * \msg_arg
+ */
+template <bool propto = false, typename Eta, typename ThetaVec,
+          typename CovarFun, typename CovarArgs,
+          require_all_eigen_vector_t<ThetaVec>* = nullptr>
+inline auto laplace_marginal_tol_neg_binomial_2_log_lpmf(
+    const std::vector<int>& y, const std::vector<int>& y_index, const Eta& eta,
+    const ThetaVec& theta_0, CovarFun&& covariance_function,
+    CovarArgs&& covar_args, double tolerance, int max_num_steps,
+    const int hessian_block_size, const int solver,
+    const int max_steps_line_search, std::ostream* msgs) {
+  laplace_options ops{hessian_block_size, solver, max_steps_line_search,
+                      tolerance, max_num_steps};
+  return laplace_marginal_density(
+      neg_binomial_2_log_likelihood{}, std::forward_as_tuple(eta, y, y_index),
+      theta_0, std::forward<CovarFun>(covariance_function),
+      std::forward<CovarArgs>(covar_args), ops, msgs);
+}
+
+/**
+ * Wrapper function around the laplace_marginal function for
+ * a negative binomial likelihood. Uses the 2nd parameterization.
+ * Returns the marginal density p(y | phi) by marginalizing
+ * out the latent gaussian variable, with a Laplace approximation.
+ * See the laplace_marginal function for more details.
+ *
+ * @tparam Eta The type of parameter arguments for the likelihood function.
+ * \laplace_common_template_args
+ * @param[in] y observed counts.
+ * @param[in] y_index group to which each observation belongs. Each group
+ *            is parameterized by one element of theta.
+ * @param[in] eta Parameter argument for likelihood function.
+ * \laplace_common_args
+ * \msg_arg
+ */
+template <bool propto = false, typename Eta, typename ThetaVec,
+          typename CovarFun, typename CovarArgs>
+inline auto laplace_marginal_neg_binomial_2_log_lpmf(
+    const std::vector<int>& y, const std::vector<int>& y_index, const Eta& eta,
+    const ThetaVec& theta_0, CovarFun&& covariance_function,
+    CovarArgs&& covar_args, std::ostream* msgs) {
+  constexpr laplace_options ops{1, 1, 0, 1e-6, 100};
+  return laplace_marginal_density(
+      neg_binomial_2_log_likelihood{}, std::forward_as_tuple(eta, y, y_index),
+      theta_0, std::forward<CovarFun>(covariance_function),
+      std::forward<CovarArgs>(covar_args), ops, msgs);
+}
+
+struct neg_binomial_2_log_likelihood_summary {
+  template <typename T_theta, typename T_eta>
+  inline return_type_t<T_theta, T_eta> operator()(
+      const T_theta& theta, const T_eta& eta, const std::vector<int>& y,
+      const std::vector<int>& n_per_group,
+      const std::vector<int>& counts_per_group, std::ostream* pstream) const {
+    Eigen::Map<const Eigen::VectorXi> y_map(y.data(), y.size());
+    Eigen::Map<const Eigen::VectorXi> n_per_group_map(n_per_group.data(),
+                                                      n_per_group.size());
+    Eigen::Map<const Eigen::VectorXi> counts_per_group_map(
+        counts_per_group.data(), counts_per_group.size());
+    auto log_eta_plus_exp_theta = eval(log(add(eta, exp(theta))));
+    return sum(binomial_coefficient_log(subtract(add(y_map, eta), 1.0), y_map))
+           + sum(add(elt_multiply(counts_per_group_map,
+                                  subtract(theta, log_eta_plus_exp_theta)),
+                     elt_multiply(multiply(n_per_group_map, eta),
+                                  subtract(log(eta), log_eta_plus_exp_theta))));
+  }
+};
+
+/**
+ * Wrapper function around the laplace_marginal function for
+ * a negative binomial likelihood. Uses the 2nd parameterization.
+ * Returns the marginal density p(y|phi) by marginalizing
+ * out the latent gaussian variable, with a Laplace approximation.
+ * See the laplace_marginal function for more details.
+ *
+ * @tparam Eta The type of parameter arguments for the likelihood function.
+ * \laplace_common_template_args
+ * @param[in] y observations.
+ * @param[in] n_per_group number of samples per group
+ * @param[in] counts_per_group total counts per group
+ * @param[in] eta non-marginalized model parameters for the likelihood.
+ * \laplace_common_args
+ * \laplace_options
+ * \msg_arg
+ */
+template <bool propto = false, typename Eta, typename ThetaVec,
+          typename CovarFun, typename CovarArgs,
+          require_all_eigen_vector_t<ThetaVec>* = nullptr>
+inline auto laplace_marginal_tol_neg_binomial_2_log_summary_lpmf(
+    const std::vector<int>& y, const std::vector<int>& n_per_group,
+    const std::vector<int>& counts_per_group, const Eta& eta,
+    const ThetaVec& theta_0, CovarFun&& covariance_function,
+    CovarArgs&& covar_args, double tolerance, int max_num_steps,
+    const int hessian_block_size, const int solver,
+    const int max_steps_line_search, std::ostream* msgs) {
+  laplace_options ops{hessian_block_size, solver, max_steps_line_search,
+                      tolerance, max_num_steps};
+  return laplace_marginal_density(
+      neg_binomial_2_log_likelihood_summary{},
+      std::forward_as_tuple(eta, y, n_per_group, counts_per_group), theta_0,
+      std::forward<CovarFun>(covariance_function),
+      std::forward<CovarArgs>(covar_args), ops, msgs);
+}
+
+/**
+ * Wrapper function around the laplace_marginal function for
+ * a negative binomial likelihood. Uses the 2nd parameterization.
+ * Returns the marginal density p(y|phi) by marginalizing
+ * out the latent gaussian variable, with a Laplace approximation.
+ * See the laplace_marginal function for more details.
+ *
+ * @tparam Eta The type of parameter arguments for the likelihood function.
+ * \laplace_common_template_args
+ * @param[in] y observations.
+ * @param[in] n_per_group number of samples per group
+ * @param[in] counts_per_group total counts per group
+ * @param[in] eta non-marginalized model parameters for the likelihood.
+ * \laplace_common_args
+ * \msg_arg
+ */
+template <bool propto = false, typename Eta, typename ThetaVec,
+          typename CovarFun, typename CovarArgs,
+          require_all_eigen_vector_t<ThetaVec>* = nullptr>
+inline auto laplace_marginal_neg_binomial_2_log_summary_lpmf(
+    const std::vector<int>& y, const std::vector<int>& n_per_group,
+    const std::vector<int>& counts_per_group, const Eta& eta,
+    const ThetaVec& theta_0, CovarFun&& covariance_function,
+    CovarArgs&& covar_args, std::ostream* msgs) {
+  constexpr laplace_options ops{1, 1, 0, 1e-6, 100};
+  return laplace_marginal_density(
+      neg_binomial_2_log_likelihood_summary{},
+      std::forward_as_tuple(eta, y, n_per_group, counts_per_group), theta_0,
+      std::forward<CovarFun>(covariance_function),
+      std::forward<CovarArgs>(covar_args), ops, msgs);
+}
+
+}  // namespace math
+}  // namespace stan
+
+#endif
diff --git a/stan/math/mix/prob/laplace_marginal_poisson_log_2_lpmf.hpp b/stan/math/mix/prob/laplace_marginal_poisson_log_2_lpmf.hpp
new file mode 100644
index 00000000000..fc71f5d7f32
--- /dev/null
+++ b/stan/math/mix/prob/laplace_marginal_poisson_log_2_lpmf.hpp
@@ -0,0 +1,122 @@
+#ifndef STAN_MATH_MIX_PROB_LAPLACE_MARGINAL_POISSON_LOG_2_LPMF_HPP
+#define STAN_MATH_MIX_PROB_LAPLACE_MARGINAL_POISSON_LOG_2_LPMF_HPP
+
+#include <stan/math/mix/functor/laplace_marginal_density.hpp>
+#include <stan/math/mix/functor/laplace_likelihood.hpp>
+#include <stan/math/rev/core/operator_addition.hpp>
+#include <stan/math/rev/core/operator_multiplication.hpp>
+#include <stan/math/rev/core/operator_subtraction.hpp>
+#include <stan/math/rev/fun/dot_product.hpp>
+#include <stan/math/rev/fun/exp.hpp>
+#include <stan/math/rev/fun/lgamma.hpp>
+#include <stan/math/rev/fun/log.hpp>
+#include <stan/math/rev/fun/sum.hpp>
+#include <stan/math/fwd/fun/exp.hpp>
+#include <stan/math/fwd/fun/lgamma.hpp>
+#include <stan/math/fwd/fun/sum.hpp>
+
+namespace stan {
+namespace math {
+
+struct poisson_log_2_likelihood {
+  /**
+   * Returns the lpmf for a Poisson with a log link across
+   * multiple groups. No need to compute the log normalizing constant.
+   * Same as above, but includes a exposure term to correct the
+   * log rate for each group.
+   * @tparam Theta Type of the log Poisson rate.
+   * @tparam Eta Type of the auxiliary parameter (not used here).
+   * @param[in] theta log Poisson rate for each group.
+   * @param[in] y First n elements contain the sum of counts in each group
+   * @param[in] y_index group to which each observation belongs.
+   * @param[in] ye next n elements the exposure in each group, where n is the
+   * number of groups.
+   * @param[in, out] pstream msgs that are not used here
+   */
+  template <typename Theta, typename YVec, typename YIndexVec, typename YeVec>
+  inline auto operator()(const Theta& theta, const YVec& y,
+                         const YIndexVec& y_index, const YeVec& ye,
+                         std::ostream* /*pstream*/) const {
+    Eigen::VectorXd y_vec = to_vector(y);
+    Eigen::VectorXd counts_per_group = Eigen::VectorXd::Zero(theta.size());
+    Eigen::VectorXd n_per_group = Eigen::VectorXd::Zero(theta.size());
+    for (int i = 0; i < theta.size(); i++) {
+      counts_per_group(y_index[i]) += y[i];
+      n_per_group(y_index[i]) += 1;
+    }
+    // auto n_samples = to_vector(delta_int);
+    auto shifted_mean = to_ref(add(theta, log(ye)));
+    return -sum(lgamma(add(y_vec, 1))) + dot_product(shifted_mean, y_vec)
+           - dot_product(n_per_group, exp(shifted_mean));
+  }
+};
+
+/**
+ * Wrapper function around the laplace_marginal function for
+ * a log poisson likelihood. Returns the marginal density
+ * p(y | phi) by marginalizing out the latent gaussian variable,
+ * with a Laplace approximation. See the laplace_marginal function
+ * for more details.
+ *
+ * @tparam propto boolean ignored
+ * @tparam YeVec A type inheriting from `Eigen::EigenBase` with dynamic
+ * sized rows and 1 column.
+ * \laplace_common_template_args
+ * @param[in] y total counts per group. Second sufficient statistics.
+ * @param[in] y_index group to which each observation belongs.
+ * @param[in] ye the exposure for each group.
+ * \laplace_common_args
+ * \laplace_options
+ * \msg_arg
+ */
+template <bool propto = false, typename YeVec, typename ThetaVec,
+          typename CovarFun, typename CovarArgs,
+          require_all_eigen_vector_t<YeVec, ThetaVec>* = nullptr>
+inline auto laplace_marginal_tol_poisson_2_log_lpmf(
+    const std::vector<int>& y, const std::vector<int>& y_index, const YeVec& ye,
+    const ThetaVec& theta_0, CovarFun&& covariance_function,
+    CovarArgs&& covar_args, double tolerance, int max_num_steps,
+    const int hessian_block_size, const int solver,
+    const int max_steps_line_search, std::ostream* msgs) {
+  laplace_options ops{hessian_block_size, solver, max_steps_line_search,
+                      tolerance, max_num_steps};
+  return laplace_marginal_density(
+      poisson_log_2_likelihood{}, std::forward_as_tuple(y, y_index, ye),
+      theta_0, std::forward<CovarFun>(covariance_function),
+      std::forward<CovarArgs>(covar_args), ops, msgs);
+}
+
+/**
+ * Wrapper function around the laplace_marginal function for
+ * a log poisson likelihood. Returns the marginal density
+ * p(y | phi) by marginalizing out the latent gaussian variable,
+ * with a Laplace approximation. See the laplace_marginal function
+ * for more details.
+ *
+ * @tparam propto boolean ignored
+ * @tparam YeVec The type for the global parameter, phi.
+ * \laplace_common_template_args
+ * @param[in] y total counts per group. Second sufficient statistics.
+ * @param[in] y_index group to which each observation belongs.
+ * @param[in] ye the exposure for each group.
+ * \laplace_common_args
+ * \msg_arg
+ */
+template <bool propto = false, typename YeVec, typename ThetaVec,
+          typename CovarFun, typename CovarArgs,
+          require_all_eigen_vector_t<YeVec, ThetaVec>* = nullptr>
+inline auto laplace_marginal_poisson_2_log_lpmf(
+    const std::vector<int>& y, const std::vector<int>& y_index, const YeVec& ye,
+    const ThetaVec& theta_0, CovarFun&& covariance_function,
+    CovarArgs&& covar_args, std::ostream* msgs) {
+  constexpr laplace_options ops{1, 1, 0, 1e-6, 100};
+  return laplace_marginal_density(
+      poisson_log_2_likelihood{}, std::forward_as_tuple(y, y_index, ye),
+      theta_0, std::forward<CovarFun>(covariance_function),
+      std::forward<CovarArgs>(covar_args), ops, msgs);
+}
+
+}  // namespace math
+}  // namespace stan
+
+#endif
diff --git a/stan/math/mix/prob/laplace_marginal_poisson_log_lpmf.hpp b/stan/math/mix/prob/laplace_marginal_poisson_log_lpmf.hpp
new file mode 100644
index 00000000000..d64002c903b
--- /dev/null
+++ b/stan/math/mix/prob/laplace_marginal_poisson_log_lpmf.hpp
@@ -0,0 +1,108 @@
+#ifndef STAN_MATH_MIX_PROB_LAPLACE_MARGINAL_POISSON_LOG_LPMF_HPP
+#define STAN_MATH_MIX_PROB_LAPLACE_MARGINAL_POISSON_LOG_LPMF_HPP
+
+#include <stan/math/mix/functor/laplace_likelihood.hpp>
+#include <stan/math/mix/functor/laplace_marginal_density.hpp>
+#include <stan/math/rev/fun/dot_product.hpp>
+#include <stan/math/rev/fun/exp.hpp>
+#include <stan/math/rev/fun/lgamma.hpp>
+#include <stan/math/rev/fun/sum.hpp>
+#include <stan/math/fwd/fun/exp.hpp>
+#include <stan/math/fwd/fun/lgamma.hpp>
+
+namespace stan {
+namespace math {
+
+struct poisson_log_likelihood {
+  /**
+   * Returns the lpmf for a Poisson with a log link across
+   * multiple groups. No need to compute the log normalizing constant.
+   * @tparam T_theta Type of the log Poisson rate.
+   * @tparam T_eta Type of the auxiliary parameter (not used here).
+   * @param[in] theta log Poisson rate for each group.
+   * @param[in] y observed counts
+   * @param[in] y_index group to which each observation belongs
+   * return lpmf for a Poisson with a log link.
+   * @param[in] pstream
+   */
+  template <typename Theta, typename YVec,
+            require_eigen_vector_t<Theta>* = nullptr>
+  inline auto operator()(const Theta& theta, const YVec& y,
+                         const std::vector<int>& y_index,
+                         std::ostream* pstream) const {
+    Eigen::VectorXd counts_per_group = Eigen::VectorXd::Zero(theta.size());
+    Eigen::VectorXd n_per_group = Eigen::VectorXd::Zero(theta.size());
+
+    for (int i = 0; i < theta.size(); i++) {
+      counts_per_group(y_index[i]) += y[i];
+      n_per_group(y_index[i]) += 1;
+    }
+
+    return -sum(lgamma(add(counts_per_group, 1)))
+           + dot_product(theta, counts_per_group)
+           - dot_product(n_per_group, exp(theta));
+  }
+};
+
+/**
+ * Wrapper function around the laplace_marginal function for
+ * a log poisson likelihood. Returns the marginal density
+ * p(y | phi) by marginalizing out the latent gaussian variable,
+ * with a Laplace approximation. See the laplace_marginal function
+ * for more details.
+ *
+ * @tparam propto ignored
+ * \laplace_common_template_args
+ * @param[in] y observed counts
+ * @param[in] y_index group to which each observation belongs
+ * \laplace_common_args
+ * \laplace_options
+ * \msg_arg
+ */
+template <bool propto = false, typename ThetaVec, typename CovarFun,
+          typename CovarArgs, require_all_eigen_vector_t<ThetaVec>* = nullptr>
+inline auto laplace_marginal_tol_poisson_log_lpmf(
+    const std::vector<int>& y, const std::vector<int>& y_index,
+    const ThetaVec& theta_0, CovarFun&& covariance_function,
+    CovarArgs&& covar_args, double tolerance, int max_num_steps,
+    const int hessian_block_size, const int solver,
+    const int max_steps_line_search, std::ostream* msgs) {
+  laplace_options ops{hessian_block_size, solver, max_steps_line_search,
+                      tolerance, max_num_steps};
+  return laplace_marginal_density(
+      poisson_log_likelihood{}, std::forward_as_tuple(y, y_index), theta_0,
+      covariance_function, std::forward<CovarArgs>(covar_args), ops, msgs);
+}
+
+/**
+ * Wrapper function around the laplace_marginal function for
+ * a log poisson likelihood. Returns the marginal density
+ * p(y | phi) by marginalizing out the latent gaussian variable,
+ * with a Laplace approximation. See the laplace_marginal function
+ * for more details.
+ *
+ * @tparam propto ignored
+ * \laplace_common_template_args
+ * @param[in] y observed counts
+ * @param[in] y_index group to which each observation belongs
+ * \laplace_common_args
+ * \msg_arg
+ */
+template <bool propto = false, typename ThetaVec, typename CovarFun,
+          typename CovarArgs, require_eigen_vector_t<ThetaVec>* = nullptr>
+inline auto laplace_marginal_poisson_log_lpmf(const std::vector<int>& y,
+                                              const std::vector<int>& y_index,
+                                              const ThetaVec& theta_0,
+                                              CovarFun&& covariance_function,
+                                              CovarArgs&& covar_args,
+                                              std::ostream* msgs) {
+  constexpr laplace_options ops{1, 1, 0, 1e-6, 100};
+  return laplace_marginal_density(
+      poisson_log_likelihood{}, std::forward_as_tuple(y, y_index), theta_0,
+      covariance_function, std::forward<CovarArgs>(covar_args), ops, msgs);
+}
+
+}  // namespace math
+}  // namespace stan
+
+#endif
diff --git a/stan/math/opencl/prim/constraint/lb_constrain.hpp b/stan/math/opencl/prim/constraint/lb_constrain.hpp
index e94f6ead13f..a80ad3cb783 100644
--- a/stan/math/opencl/prim/constraint/lb_constrain.hpp
+++ b/stan/math/opencl/prim/constraint/lb_constrain.hpp
@@ -31,7 +31,7 @@ template <typename T, typename L,
           require_all_kernel_expressions_t<L>* = nullptr>
 inline auto lb_constrain(T&& x, L&& lb) {
   return make_holder_cl(
-      [](auto& x_, auto& lb_) {
+      [](auto&& x_, auto& lb_) {
         return select(lb_ == NEGATIVE_INFTY, x_, lb_ + exp(x_));
       },
       std::forward<T>(x), std::forward<L>(lb));
diff --git a/stan/math/opencl/prim/constraint/ub_constrain.hpp b/stan/math/opencl/prim/constraint/ub_constrain.hpp
index fd158ee93c8..846ef298cfd 100644
--- a/stan/math/opencl/prim/constraint/ub_constrain.hpp
+++ b/stan/math/opencl/prim/constraint/ub_constrain.hpp
@@ -31,7 +31,7 @@ template <typename T, typename U,
           require_all_kernel_expressions_t<U>* = nullptr>
 inline auto ub_constrain(T&& x, U&& ub) {
   return make_holder_cl(
-      [](auto& x_, auto& ub_) {
+      [](auto&& x_, auto&& ub_) {
         return select(ub_ == INFTY, x_, ub_ - exp(x_));
       },
       std::forward<T>(x), std::forward<U>(ub));
diff --git a/stan/math/opencl/prim/symmetrize_from_lower_tri.hpp b/stan/math/opencl/prim/symmetrize_from_lower_tri.hpp
index 210089a838d..158203aa5e8 100644
--- a/stan/math/opencl/prim/symmetrize_from_lower_tri.hpp
+++ b/stan/math/opencl/prim/symmetrize_from_lower_tri.hpp
@@ -21,7 +21,7 @@ template <typename T_x,
 inline auto symmetrize_from_lower_tri(T_x&& x) {
   check_square("symmetrize_from_lower_tri", "x", x);
   return make_holder_cl(
-      [](auto& arg) {
+      [](auto&& arg) {
         return select(row_index() < col_index(), transpose(arg), arg);
       },
       std::forward<T_x>(x));
diff --git a/stan/math/opencl/prim/symmetrize_from_upper_tri.hpp b/stan/math/opencl/prim/symmetrize_from_upper_tri.hpp
index 7d2b1d02204..9acf9f435cb 100644
--- a/stan/math/opencl/prim/symmetrize_from_upper_tri.hpp
+++ b/stan/math/opencl/prim/symmetrize_from_upper_tri.hpp
@@ -21,7 +21,7 @@ template <typename T_x,
 inline auto symmetrize_from_upper_tri(T_x&& x) {
   check_square("symmetrize_from_upper_tri", "x", x);
   return make_holder_cl(
-      [](auto& arg) {
+      [](auto&& arg) {
         return select(col_index() < row_index(), transpose(arg), arg);
       },
       std::forward<T_x>(x));
diff --git a/stan/math/opencl/value_type.hpp b/stan/math/opencl/value_type.hpp
index 0aea7260905..7c8e19b3840 100644
--- a/stan/math/opencl/value_type.hpp
+++ b/stan/math/opencl/value_type.hpp
@@ -14,6 +14,11 @@ template <typename T>
 struct value_type<T, require_all_kernel_expressions_and_none_scalar_t<T>> {
   using type = typename std::decay_t<T>::Scalar;
 };
+
+template <typename T>
+struct base_type<T, require_all_kernel_expressions_and_none_scalar_t<T>> {
+  using type = typename base_type<typename std::decay_t<T>::Scalar>::type;
+};
 }  // namespace stan
 #endif
 #endif
diff --git a/stan/math/prim/fun/Eigen.hpp b/stan/math/prim/fun/Eigen.hpp
index 6efb32cbdea..c012d225d1b 100644
--- a/stan/math/prim/fun/Eigen.hpp
+++ b/stan/math/prim/fun/Eigen.hpp
@@ -1,6 +1,15 @@
 #ifndef STAN_MATH_PRIM_FUN_EIGEN_HPP
 #define STAN_MATH_PRIM_FUN_EIGEN_HPP
-
+#include <stdexcept>
+#ifdef STAN_OVERRIDE_EIGEN_ASSERT
+#ifdef eigen_assert
+#undef eigen_assert
+#endif
+#define eigen_assert(x)                               \
+  if (!(x)) {                                         \
+    throw(std::domain_error("Internal Eigen Error")); \
+  }
+#endif
 #ifdef EIGEN_MATRIXBASE_PLUGIN
 #ifndef EIGEN_STAN_MATRIXBASE_PLUGIN
 #error "Stan uses Eigen's EIGEN_MATRIXBASE_PLUGIN macro. To use your own "
diff --git a/stan/math/prim/fun/as_array_or_scalar.hpp b/stan/math/prim/fun/as_array_or_scalar.hpp
index 02380ab5dfa..2105058c587 100644
--- a/stan/math/prim/fun/as_array_or_scalar.hpp
+++ b/stan/math/prim/fun/as_array_or_scalar.hpp
@@ -54,7 +54,7 @@ inline T as_array_or_scalar(T&& v) {
 template <typename T, typename = require_eigen_t<T>,
           require_not_eigen_array_t<T>* = nullptr>
 inline auto as_array_or_scalar(T&& v) {
-  return make_holder([](auto& x) { return x.array(); }, std::forward<T>(v));
+  return make_holder([](auto&& x) { return x.array(); }, std::forward<T>(v));
 }
 
 /**
@@ -69,7 +69,7 @@ template <typename T, require_std_vector_t<T>* = nullptr,
 inline auto as_array_or_scalar(T&& v) {
   using T_map
       = Eigen::Map<const Eigen::Array<value_type_t<T>, Eigen::Dynamic, 1>>;
-  return make_holder([](auto& x) { return T_map(x.data(), x.size()); },
+  return make_holder([](auto&& x) { return T_map(x.data(), x.size()); },
                      std::forward<T>(v));
 }
 
diff --git a/stan/math/prim/fun/as_column_vector_or_scalar.hpp b/stan/math/prim/fun/as_column_vector_or_scalar.hpp
index 0c999c63582..d7c8055a00c 100644
--- a/stan/math/prim/fun/as_column_vector_or_scalar.hpp
+++ b/stan/math/prim/fun/as_column_vector_or_scalar.hpp
@@ -57,7 +57,8 @@ inline T&& as_column_vector_or_scalar(T&& a) {
 template <typename T, require_eigen_row_vector_t<T>* = nullptr,
           require_not_eigen_col_vector_t<T>* = nullptr>
 inline auto as_column_vector_or_scalar(T&& a) {
-  return make_holder([](auto& x) { return x.transpose(); }, std::forward<T>(a));
+  return make_holder([](auto&& x) { return x.transpose(); },
+                     std::forward<T>(a));
 }
 
 /**
@@ -74,7 +75,7 @@ inline auto as_column_vector_or_scalar(T&& a) {
       = std::conditional_t<std::is_const<std::remove_reference_t<T>>::value,
                            const plain_vector, plain_vector>;
   using T_map = Eigen::Map<optionally_const_vector>;
-  return make_holder([](auto& x) { return T_map(x.data(), x.size()); },
+  return make_holder([](auto&& x) { return T_map(x.data(), x.size()); },
                      std::forward<T>(a));
 }
 
diff --git a/stan/math/prim/fun/gp_exp_quad_cov.hpp b/stan/math/prim/fun/gp_exp_quad_cov.hpp
index 6bdc2a9c14e..438cd8c47c0 100644
--- a/stan/math/prim/fun/gp_exp_quad_cov.hpp
+++ b/stan/math/prim/fun/gp_exp_quad_cov.hpp
@@ -30,10 +30,10 @@ namespace internal {
  * @param neg_half_inv_l_sq The half negative inverse of the length scale
  * @return squared distance
  */
-template <typename T_x, typename T_sigma, typename T_l>
+template <typename T_x, typename T_x_alloc, typename T_sigma, typename T_l>
 inline typename Eigen::Matrix<return_type_t<T_x, T_sigma, T_l>, Eigen::Dynamic,
                               Eigen::Dynamic>
-gp_exp_quad_cov(const std::vector<T_x> &x, const T_sigma &sigma_sq,
+gp_exp_quad_cov(const std::vector<T_x, T_x_alloc> &x, const T_sigma &sigma_sq,
                 const T_l &neg_half_inv_l_sq) {
   using std::exp;
   const size_t x_size = x.size();
@@ -77,11 +77,13 @@ gp_exp_quad_cov(const std::vector<T_x> &x, const T_sigma &sigma_sq,
  * @param neg_half_inv_l_sq The half negative inverse of the length scale
  * @return squared distance
  */
-template <typename T_x1, typename T_x2, typename T_sigma, typename T_l>
+template <typename T_x1, typename T_x1_alloc, typename T_x2, typename T_sigma,
+          typename T_l>
 inline typename Eigen::Matrix<return_type_t<T_x1, T_x2, T_sigma, T_l>,
                               Eigen::Dynamic, Eigen::Dynamic>
-gp_exp_quad_cov(const std::vector<T_x1> &x1, const std::vector<T_x2> &x2,
-                const T_sigma &sigma_sq, const T_l &neg_half_inv_l_sq) {
+gp_exp_quad_cov(const std::vector<T_x1, T_x1_alloc> &x1,
+                const std::vector<T_x2> &x2, const T_sigma &sigma_sq,
+                const T_l &neg_half_inv_l_sq) {
   using std::exp;
   Eigen::Matrix<return_type_t<T_x1, T_x2, T_sigma, T_l>, Eigen::Dynamic,
                 Eigen::Dynamic>
@@ -120,10 +122,10 @@ gp_exp_quad_cov(const std::vector<T_x1> &x1, const std::vector<T_x2> &x2,
  * @throw std::domain_error if sigma <= 0, l <= 0, or
  *   x is nan or infinite
  */
-template <typename T_x, typename T_sigma, typename T_l>
+template <typename T_x, typename T_x_alloc, typename T_sigma, typename T_l>
 inline typename Eigen::Matrix<return_type_t<T_x, T_sigma, T_l>, Eigen::Dynamic,
                               Eigen::Dynamic>
-gp_exp_quad_cov(const std::vector<T_x> &x, const T_sigma &sigma,
+gp_exp_quad_cov(const std::vector<T_x, T_x_alloc> &x, const T_sigma &sigma,
                 const T_l &length_scale) {
   check_positive("gp_exp_quad_cov", "magnitude", sigma);
   check_positive("gp_exp_quad_cov", "length scale", length_scale);
@@ -160,11 +162,13 @@ gp_exp_quad_cov(const std::vector<T_x> &x, const T_sigma &sigma,
  * @throw std::domain_error if sigma <= 0, l <= 0, or
  *   x is nan or infinite
  */
-template <typename T_x, typename T_sigma, typename T_l>
+template <typename T_x, typename T_x_alloc, typename T_sigma, typename T_l,
+          typename T_l_alloc>
 inline typename Eigen::Matrix<return_type_t<T_x, T_sigma, T_l>, Eigen::Dynamic,
                               Eigen::Dynamic>
-gp_exp_quad_cov(const std::vector<Eigen::Matrix<T_x, -1, 1>> &x,
-                const T_sigma &sigma, const std::vector<T_l> &length_scale) {
+gp_exp_quad_cov(const std::vector<Eigen::Matrix<T_x, -1, 1>, T_x_alloc> &x,
+                const T_sigma &sigma,
+                const std::vector<T_l, T_l_alloc> &length_scale) {
   check_positive_finite("gp_exp_quad_cov", "magnitude", sigma);
   check_positive_finite("gp_exp_quad_cov", "length scale", length_scale);
 
@@ -203,11 +207,13 @@ gp_exp_quad_cov(const std::vector<Eigen::Matrix<T_x, -1, 1>> &x,
  * @throw std::domain_error if sigma <= 0, l <= 0, or
  *   x is nan or infinite
  */
-template <typename T_x1, typename T_x2, typename T_sigma, typename T_l>
+template <typename T_x1, typename T_x1_alloc, typename T_x2,
+          typename T_x2_alloc, typename T_sigma, typename T_l>
 inline typename Eigen::Matrix<return_type_t<T_x1, T_x2, T_sigma, T_l>,
                               Eigen::Dynamic, Eigen::Dynamic>
-gp_exp_quad_cov(const std::vector<T_x1> &x1, const std::vector<T_x2> &x2,
-                const T_sigma &sigma, const T_l &length_scale) {
+gp_exp_quad_cov(const std::vector<T_x1, T_x1_alloc> &x1,
+                const std::vector<T_x2, T_x2_alloc> &x2, const T_sigma &sigma,
+                const T_l &length_scale) {
   const char *function_name = "gp_exp_quad_cov";
   check_positive(function_name, "magnitude", sigma);
   check_positive(function_name, "length scale", length_scale);
@@ -252,12 +258,14 @@ gp_exp_quad_cov(const std::vector<T_x1> &x1, const std::vector<T_x2> &x2,
  * @throw std::domain_error if sigma <= 0, l <= 0, or
  *   x is nan or infinite
  */
-template <typename T_x1, typename T_x2, typename T_s, typename T_l>
+template <typename T_x1, typename T_x1_alloc, typename T_x2,
+          typename T_x2_alloc, typename T_s, typename T_l, typename T_l_alloc>
 inline typename Eigen::Matrix<return_type_t<T_x1, T_x2, T_s, T_l>,
                               Eigen::Dynamic, Eigen::Dynamic>
-gp_exp_quad_cov(const std::vector<Eigen::Matrix<T_x1, -1, 1>> &x1,
-                const std::vector<Eigen::Matrix<T_x2, -1, 1>> &x2,
-                const T_s &sigma, const std::vector<T_l> &length_scale) {
+gp_exp_quad_cov(const std::vector<Eigen::Matrix<T_x1, -1, 1>, T_x1_alloc> &x1,
+                const std::vector<Eigen::Matrix<T_x2, -1, 1>, T_x2_alloc> &x2,
+                const T_s &sigma,
+                const std::vector<T_l, T_l_alloc> &length_scale) {
   size_t x1_size = x1.size();
   size_t x2_size = x2.size();
   size_t l_size = length_scale.size();
diff --git a/stan/math/prim/fun/promote_scalar.hpp b/stan/math/prim/fun/promote_scalar.hpp
index ee7ab2abc2d..8872be4f91f 100644
--- a/stan/math/prim/fun/promote_scalar.hpp
+++ b/stan/math/prim/fun/promote_scalar.hpp
@@ -2,6 +2,8 @@
 #define STAN_MATH_PRIM_FUN_PROMOTE_SCALAR_HPP
 
 #include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/prim/functor/apply.hpp>
+#include <test/unit/pretty_print_types.hpp>
 #include <stan/math/prim/meta.hpp>
 #include <vector>
 #include <tuple>
@@ -10,101 +12,43 @@
 namespace stan {
 namespace math {
 
-/**
- * Promote a scalar to another scalar type
- *
- * @tparam PromotionScalar scalar type of output.
- * @tparam UnPromotedType input type. `UnPromotedType` must be constructible
- * from `PromotionScalar`
- * @param x input scalar to be promoted to `PromotionScalar` type
- */
-template <typename PromotionScalar, typename UnPromotedType,
-          require_constructible_t<PromotionScalar, UnPromotedType>* = nullptr,
-          require_not_same_t<PromotionScalar, UnPromotedType>* = nullptr,
-          require_all_not_tuple_t<PromotionScalar, UnPromotedType>* = nullptr>
-inline constexpr auto promote_scalar(UnPromotedType&& x) {
-  return PromotionScalar(std::forward<UnPromotedType>(x));
-}
-
-/**
- * No-op overload when promoting a type's scalar to the type it already has.
- *
- * @tparam PromotionScalar scalar type of output.
- * @tparam UnPromotedType input type. `UnPromotedType`'s `scalar_type` must be
- * equal to `PromotionScalar`
- * @param x input
- */
-template <
-    typename PromotionScalar, typename UnPromotedType,
-    require_same_t<PromotionScalar, scalar_type_t<UnPromotedType>>* = nullptr>
-inline constexpr auto promote_scalar(UnPromotedType&& x) noexcept {
-  return std::forward<UnPromotedType>(x);
-}
-
-/**
- * Promote the scalar type of an eigen matrix to the requested type.
- *
- * @tparam PromotionScalar scalar type of output.
- * @tparam UnPromotedType input type. The `PromotionScalar` type must be
- * constructible from `UnPromotedType`'s `scalar_type`
- * @param x input
- */
-template <typename PromotionScalar, typename UnPromotedType,
-          require_eigen_t<UnPromotedType>* = nullptr,
-          require_not_same_t<PromotionScalar,
-                             value_type_t<UnPromotedType>>* = nullptr>
-inline auto promote_scalar(UnPromotedType&& x) {
-  return x.template cast<PromotionScalar>();
-}
-
-// Forward decl for iterating over tuples used in std::vector<tuple>
-template <typename PromotionScalars, typename UnPromotedTypes,
-          require_all_tuple_t<PromotionScalars, UnPromotedTypes>* = nullptr,
-          require_not_same_t<PromotionScalars, UnPromotedTypes>* = nullptr>
-inline constexpr promote_scalar_t<PromotionScalars, UnPromotedTypes>
-promote_scalar(UnPromotedTypes&& x);
-
-/**
- * Promote the scalar type of an standard vector to the requested type.
- *
- * @tparam PromotionScalar scalar type of output.
- * @tparam UnPromotedType input type. The `PromotionScalar` type must be
- * constructible from `UnPromotedType`'s `scalar_type`
- * @param x input
- */
-template <typename PromotionScalar, typename UnPromotedType,
-          require_std_vector_t<UnPromotedType>* = nullptr,
-          require_not_same_t<PromotionScalar,
-                             scalar_type_t<UnPromotedType>>* = nullptr>
-inline auto promote_scalar(UnPromotedType&& x) {
-  const auto x_size = x.size();
-  promote_scalar_t<PromotionScalar, UnPromotedType> ret(x_size);
-  for (size_t i = 0; i < x_size; ++i) {
-    ret[i] = promote_scalar<PromotionScalar>(x[i]);
+template <typename PromotionScalars, typename UnPromotedTypes>
+inline constexpr auto promote_scalar(UnPromotedTypes&& x) {
+  using unpromoted_scalar_t = scalar_type_t<UnPromotedTypes>;
+  constexpr bool both_tuples
+      = is_tuple_v<PromotionScalars> && is_tuple_v<UnPromotedTypes>;
+  if constexpr (std::is_same_v<PromotionScalars, unpromoted_scalar_t>) {
+    return std::forward<UnPromotedTypes>(x);
+  } else if constexpr (both_tuples) {
+    return index_apply<std::tuple_size<std::decay_t<UnPromotedTypes>>::value>(
+        [&x](auto... Is) {
+          return std::make_tuple(
+              promote_scalar<std::decay_t<decltype(std::get<Is>(
+                  std::declval<PromotionScalars>()))>>(std::get<Is>(x))...);
+        });
+  } else if constexpr (is_tuple_v<UnPromotedTypes>) {
+    return stan::math::apply(
+        [](auto&&... args) {
+          return std::make_tuple(promote_scalar<PromotionScalars>(
+              std::forward<decltype(args)>(args))...);
+        },
+        std::forward<UnPromotedTypes>(x));
+  } else if constexpr (is_std_vector_v<UnPromotedTypes>) {
+    const auto x_size = x.size();
+    promote_scalar_t<PromotionScalars, UnPromotedTypes> ret(x_size);
+    for (size_t i = 0; i < x_size; ++i) {
+      ret[i] = promote_scalar<PromotionScalars>(x[i]);
+    }
+    return ret;
+  } else if constexpr (is_eigen_v<UnPromotedTypes>) {
+    return std::forward<UnPromotedTypes>(x).template cast<PromotionScalars>();
+  } else if constexpr (is_stan_scalar_v<UnPromotedTypes>) {
+    return PromotionScalars(std::forward<UnPromotedTypes>(x));
+  } else {
+    throw std::domain_error(
+        "promote_scalar: "
+        "Unrecognized type for promotion");
   }
-  return ret;
-}
-
-/**
- * Promote the scalar type of a tuples elements to the requested types.
- *
- * @tparam PromotionScalars A tuple of scalar types that is the same size as the
- * tuple of `UnPromotedTypes`.
- * @tparam UnPromotedTypes tuple input. Each `PromotionScalars` element must be
- * constructible from it's associated element of `UnPromotedTypes` `scalar_type`
- * @param x input
- */
-template <typename PromotionScalars, typename UnPromotedTypes,
-          require_all_tuple_t<PromotionScalars, UnPromotedTypes>*,
-          require_not_same_t<PromotionScalars, UnPromotedTypes>*>
-inline constexpr promote_scalar_t<PromotionScalars, UnPromotedTypes>
-promote_scalar(UnPromotedTypes&& x) {
-  return index_apply<std::tuple_size<std::decay_t<UnPromotedTypes>>::value>(
-      [&x](auto... Is) {
-        return std::make_tuple(
-            promote_scalar<std::decay_t<decltype(std::get<Is>(
-                std::declval<PromotionScalars>()))>>(std::get<Is>(x))...);
-      });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/scalar_seq_view.hpp b/stan/math/prim/fun/scalar_seq_view.hpp
index 5e7a176b8fc..5aead8daa68 100644
--- a/stan/math/prim/fun/scalar_seq_view.hpp
+++ b/stan/math/prim/fun/scalar_seq_view.hpp
@@ -126,7 +126,8 @@ class scalar_seq_view<C, require_t<std::is_pointer<C>>> {
    */
   inline auto operator[](size_t i) const { return c_[i]; }
   inline auto size() const noexcept {
-    static_assert(1, "Cannot Return Size of scalar_seq_view with pointer type");
+    static_assert(sizeof(std::decay_t<C>*) == 0,
+                  "Cannot Return Size of scalar_seq_view with pointer type");
   }
   inline const auto* data() const noexcept { return &c_[0]; }
 
diff --git a/stan/math/prim/fun/to_ref.hpp b/stan/math/prim/fun/to_ref.hpp
index ceece5719eb..4bc9b04378c 100644
--- a/stan/math/prim/fun/to_ref.hpp
+++ b/stan/math/prim/fun/to_ref.hpp
@@ -2,6 +2,7 @@
 #define STAN_MATH_PRIM_FUN_TO_REF_HPP
 
 #include <stan/math/prim/meta.hpp>
+#include <stan/math/prim/functor/make_holder_tuple.hpp>
 
 namespace stan {
 namespace math {
@@ -13,11 +14,26 @@ namespace math {
  * @param a argument
  * @return optionally evaluated argument
  */
-template <typename T>
+template <typename T, require_not_tuple_t<T>* = nullptr>
 inline ref_type_t<T&&> to_ref(T&& a) {
   return std::forward<T>(a);
 }
 
+/**
+ * Overload that handles tuples.
+ * @tparam T A tuple
+ * @param a argument
+ * @return a tuple of optionally evaluated arguments
+ */
+template <typename T, require_tuple_t<T>* = nullptr>
+inline auto to_ref(T&& a) {
+  return apply(
+      [](auto&&... args) {
+        return make_holder_tuple(to_ref(std::forward<decltype(args)>(args))...);
+      },
+      std::forward<T>(a));
+}
+
 /**
  * No-op that should be optimized away.
  * @tparam Cond condition
diff --git a/stan/math/prim/fun/value_of.hpp b/stan/math/prim/fun/value_of.hpp
index 64286bbe0c3..9ace9bfd42d 100644
--- a/stan/math/prim/fun/value_of.hpp
+++ b/stan/math/prim/fun/value_of.hpp
@@ -1,25 +1,36 @@
 #ifndef STAN_MATH_PRIM_FUN_VALUE_OF_HPP
 #define STAN_MATH_PRIM_FUN_VALUE_OF_HPP
 
-#include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/prim/meta.hpp>
+#include <stan/math/prim/functor/apply.hpp>
+#include <stan/math/prim/functor/make_holder_tuple.hpp>
 #include <cstddef>
 #include <vector>
 
 namespace stan {
 namespace math {
-
+template <typename Tuple, require_tuple_t<Tuple>* = nullptr>
+inline auto value_of(Tuple&& tup);
+template <typename T, require_std_vector_t<T>* = nullptr,
+          require_not_st_arithmetic<T>* = nullptr>
+inline auto value_of(const T& x);
 /**
  * Inputs that are arithmetic types or containers of airthmetric types
  * are returned from value_of unchanged
  *
  * @tparam T Input type
  * @param[in] x Input argument
- * @return Forwarded input argument
+ * @return if T is an rvalue, use x's move constructor to return a new type.
+ *  else if x is an lvalue return x as a reference.
  **/
 template <typename T, require_st_arithmetic<T>* = nullptr>
-inline T value_of(T&& x) {
-  return std::forward<T>(x);
+inline decltype(auto) value_of(T&& x) {
+  if constexpr (std::is_rvalue_reference_v<T&&>) {
+    return std::decay_t<T>(std::forward<T>(x));
+  } else {
+    return std::forward<T>(x);
+  }
 }
 
 template <typename T, require_complex_t<T>* = nullptr,
@@ -45,8 +56,7 @@ inline auto value_of(T&& x) {
  * @param[in] x Input std::vector
  * @return std::vector of values
  **/
-template <typename T, require_std_vector_t<T>* = nullptr,
-          require_not_st_arithmetic<T>* = nullptr>
+template <typename T, require_std_vector_t<T>*, require_not_st_arithmetic<T>*>
 inline auto value_of(const T& x) {
   std::vector<plain_type_t<decltype(value_of(std::declval<value_type_t<T>>()))>>
       out;
@@ -71,7 +81,7 @@ template <typename EigMat, require_eigen_dense_base_t<EigMat>* = nullptr,
           require_not_st_arithmetic<EigMat>* = nullptr>
 inline auto value_of(EigMat&& M) {
   return make_holder(
-      [](auto& a) {
+      [](auto&& a) {
         return a.unaryExpr([](const auto& scal) { return value_of(scal); });
       },
       std::forward<EigMat>(M));
@@ -93,12 +103,38 @@ inline auto value_of(EigMat&& M) {
   ret.makeCompressed();
   return ret;
 }
+
+/*
+ * For Sparse Eigen matrices and expressions of non-arithmetic types, return an
+ *expression that represents the Eigen::Matrix resulting from applying value_of
+ *elementwise
+ *
+ * @tparam EigMat type of the matrix
+ *
+ * @param[in] M Matrix to be converted
+ * @return Matrix of values
+ */
 template <typename EigMat, require_eigen_sparse_base_t<EigMat>* = nullptr,
           require_st_arithmetic<EigMat>* = nullptr>
 inline auto value_of(EigMat&& M) {
   return std::forward<EigMat>(M);
 }
 
+/**
+ * Converts a tuples elements scalar types from ad to their child type.
+ * @tparam Tuple type of tuple
+ * @param[in] tup tuple to be converted
+ */
+template <typename Tuple, require_tuple_t<Tuple>*>
+inline auto value_of(Tuple&& tup) {
+  return stan::math::apply(
+      [](auto&&... args) {
+        return make_holder_tuple(
+            value_of(std::forward<decltype(args)>(args))...);
+      },
+      std::forward<Tuple>(tup));
+}
+
 }  // namespace math
 }  // namespace stan
 
diff --git a/stan/math/prim/fun/value_of_rec.hpp b/stan/math/prim/fun/value_of_rec.hpp
index fcba922ca30..32b81a3a5ca 100644
--- a/stan/math/prim/fun/value_of_rec.hpp
+++ b/stan/math/prim/fun/value_of_rec.hpp
@@ -1,8 +1,10 @@
 #ifndef STAN_MATH_PRIM_FUN_VALUE_OF_REC_HPP
 #define STAN_MATH_PRIM_FUN_VALUE_OF_REC_HPP
 
-#include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/prim/meta.hpp>
+#include <stan/math/prim/functor/apply.hpp>
+#include <stan/math/prim/functor/make_holder_tuple.hpp>
 #include <complex>
 #include <cstddef>
 #include <vector>
@@ -10,6 +12,13 @@
 namespace stan {
 namespace math {
 
+template <typename Tuple, require_tuple_t<Tuple>* = nullptr>
+inline auto value_of_rec(Tuple&& tup);
+
+template <typename T, require_not_same_t<double, T>* = nullptr>
+inline std::vector<promote_scalar_t<double, T>> value_of_rec(
+    const std::vector<T>& x);
+
 /**
  * Return the value of the specified scalar argument
  * converted to a double value.
@@ -25,8 +34,8 @@ namespace math {
  * @param x Scalar to convert to double.
  * @return Value of scalar cast to a double.
  */
-template <typename T, typename = require_stan_scalar_t<T>>
-inline double value_of_rec(const T x) {
+template <typename T, require_stan_scalar_t<T> = nullptr>
+inline double constexpr value_of_rec(const T x) noexcept {
   return static_cast<double>(x);
 }
 
@@ -41,7 +50,7 @@ inline double value_of_rec(const T x) {
  * @param x Specified value.
  * @return Specified value.
  */
-inline double value_of_rec(double x) { return x; }
+inline double constexpr value_of_rec(double x) noexcept { return x; }
 
 /**
  * Recursively apply value-of to the parts of the argument.
@@ -55,26 +64,6 @@ inline std::complex<double> value_of_rec(const std::complex<T>& x) {
   return {value_of_rec(x.real()), value_of_rec(x.imag())};
 }
 
-/**
- * Convert a std::vector of type T to a std::vector of doubles.
- *
- * T must implement value_of_rec. See
- * test/math/fwd/fun/value_of_rec.cpp for fvar and var usage.
- *
- * @tparam T Scalar type in std::vector
- * @param[in] x std::vector to be converted
- * @return std::vector of values
- **/
-template <typename T, require_not_same_t<double, T>* = nullptr>
-inline std::vector<double> value_of_rec(const std::vector<T>& x) {
-  size_t x_size = x.size();
-  std::vector<double> result(x_size);
-  for (size_t i = 0; i < x_size; i++) {
-    result[i] = value_of_rec(x[i]);
-  }
-  return result;
-}
-
 /**
  * Return the specified argument.
  *
@@ -102,11 +91,11 @@ inline T value_of_rec(T&& x) {
  * @param[in] M Matrix to be converted
  * @return Matrix of values
  **/
-template <typename T, typename = require_not_st_same<T, double>,
-          typename = require_eigen_t<T>>
+template <typename T, require_not_st_same<T, double>* = nullptr,
+          require_eigen_t<T>* = nullptr>
 inline auto value_of_rec(T&& M) {
   return make_holder(
-      [](auto& m) {
+      [](auto&& m) {
         return m.unaryExpr([](auto x) { return value_of_rec(x); });
       },
       std::forward<T>(M));
@@ -124,11 +113,56 @@ inline auto value_of_rec(T&& M) {
  * @param x Specified matrix.
  * @return Specified matrix.
  */
-template <typename T, typename = require_st_same<T, double>,
-          typename = require_eigen_t<T>>
-inline T value_of_rec(T&& x) {
-  return std::forward<T>(x);
+template <typename T, require_st_same<T, double>* = nullptr,
+          require_eigen_t<T>* = nullptr>
+inline decltype(auto) value_of_rec(T&& x) {
+  if constexpr (is_plain_type<T>::value || is_holder_v<T>) {
+    if constexpr (std::is_rvalue_reference_v<T&&>) {
+      return std::decay_t<T>(std::forward<T>(x));
+    } else {
+      return x;
+    }
+  } else {
+    return make_holder([](auto&& m) { return m; }, std::forward<T>(x));
+  }
+}
+
+/**
+ * Convert a std::vector of type T to a std::vector of doubles.
+ *
+ * T must implement value_of_rec. See
+ * test/math/fwd/fun/value_of_rec.cpp for fvar and var usage.
+ *
+ * @tparam T Scalar type in std::vector
+ * @param[in] x std::vector to be converted
+ * @return std::vector of values
+ **/
+template <typename T, require_not_same_t<double, T>*>
+inline std::vector<promote_scalar_t<double, T>> value_of_rec(
+    const std::vector<T>& x) {
+  size_t x_size = x.size();
+  std::vector<promote_scalar_t<double, plain_type_t<T>>> result(x_size);
+  for (size_t i = 0; i < x_size; i++) {
+    result[i] = value_of_rec(x[i]);
+  }
+  return result;
 }
+
+/**
+ * Converts a tuples elements scalar types from ad to double types
+ * @tparam Tuple type of tuple
+ * @param[in] tup tuple to be converted
+ */
+template <typename Tuple, require_tuple_t<Tuple>*>
+inline auto value_of_rec(Tuple&& tup) {
+  return stan::math::apply(
+      [](auto&&... args) {
+        return make_holder_tuple(
+            value_of_rec(std::forward<decltype(args)>(args))...);
+      },
+      std::forward<Tuple>(tup));
+}
+
 }  // namespace math
 }  // namespace stan
 
diff --git a/stan/math/prim/functor.hpp b/stan/math/prim/functor.hpp
index 0a6fd0299a6..d735a5143ea 100644
--- a/stan/math/prim/functor.hpp
+++ b/stan/math/prim/functor.hpp
@@ -7,6 +7,7 @@
 #include <stan/math/prim/functor/apply_scalar_ternary.hpp>
 #include <stan/math/prim/functor/apply_vector_unary.hpp>
 #include <stan/math/prim/functor/coupled_ode_system.hpp>
+#include <stan/math/prim/functor/filter_map.hpp>
 #include <stan/math/prim/functor/finite_diff_gradient.hpp>
 #include <stan/math/prim/functor/finite_diff_gradient_auto.hpp>
 #include <stan/math/prim/functor/for_each.hpp>
@@ -15,9 +16,11 @@
 #include <stan/math/prim/functor/integrate_1d_adapter.hpp>
 #include <stan/math/prim/functor/integrate_ode_rk45.hpp>
 #include <stan/math/prim/functor/integrate_ode_std_vector_interface_adapter.hpp>
+#include <stan/math/prim/functor/iter_tuple_nested.hpp>
 #include <stan/math/prim/functor/ode_ckrk.hpp>
 #include <stan/math/prim/functor/ode_rk45.hpp>
 #include <stan/math/prim/functor/ode_store_sensitivities.hpp>
+#include <stan/math/prim/functor/map_if.hpp>
 #include <stan/math/prim/functor/map_rect.hpp>
 #include <stan/math/prim/functor/map_rect_combine.hpp>
 #include <stan/math/prim/functor/map_rect_concurrent.hpp>
@@ -26,8 +29,10 @@
 #include <stan/math/prim/functor/mpi_command.hpp>
 #include <stan/math/prim/functor/mpi_distributed_apply.hpp>
 #include <stan/math/prim/functor/operands_and_partials.hpp>
+#include <stan/math/prim/functor/make_holder_tuple.hpp>
 #include <stan/math/prim/functor/partials_propagator.hpp>
 #include <stan/math/prim/functor/reduce_sum.hpp>
 #include <stan/math/prim/functor/reduce_sum_static.hpp>
+#include <stan/math/prim/functor/tuple_concat.hpp>
 
 #endif
diff --git a/stan/math/prim/functor/apply.hpp b/stan/math/prim/functor/apply.hpp
index e0c1c7c73bf..d0999872beb 100644
--- a/stan/math/prim/functor/apply.hpp
+++ b/stan/math/prim/functor/apply.hpp
@@ -4,10 +4,10 @@
 #include <functional>
 #include <tuple>
 #include <utility>
-
 namespace stan {
 namespace math {
 namespace internal {
+
 /*
  * Invoke the functor f with arguments given in t and indexed in the index
  * sequence I with other arguments possibly before or after
@@ -24,12 +24,11 @@ namespace internal {
  * tuple.
  */
 template <class F, class Tuple, typename... PreArgs, std::size_t... I>
-constexpr decltype(auto) apply_impl(F&& f, Tuple&& t,
-                                    std::index_sequence<I...> i,
-                                    PreArgs&&... pre_args) {
-  return std::forward<F>(f)(
-      std::forward<PreArgs>(pre_args)...,
-      std::forward<decltype(std::get<I>(t))>(std::get<I>(t))...);
+inline constexpr decltype(auto) apply_impl(F&& f, Tuple&& t,
+                                           std::index_sequence<I...> /* i */,
+                                           PreArgs&&... pre_args) {
+  return std::forward<F>(f)(std::forward<PreArgs>(pre_args)...,
+                            std::get<I>(std::forward<Tuple>(t))...);
 }
 }  // namespace internal
 
@@ -49,7 +48,7 @@ constexpr decltype(auto) apply_impl(F&& f, Tuple&& t,
  * tuple.
  */
 template <class F, class Tuple, typename... PreArgs>
-constexpr decltype(auto) apply(F&& f, Tuple&& t, PreArgs&&... pre_args) {
+inline constexpr decltype(auto) apply(F&& f, Tuple&& t, PreArgs&&... pre_args) {
   return internal::apply_impl(
       std::forward<F>(f), std::forward<Tuple>(t),
       std::make_index_sequence<
diff --git a/stan/math/prim/functor/apply_scalar_binary.hpp b/stan/math/prim/functor/apply_scalar_binary.hpp
index f3ebd81353d..a896df33914 100644
--- a/stan/math/prim/functor/apply_scalar_binary.hpp
+++ b/stan/math/prim/functor/apply_scalar_binary.hpp
@@ -56,7 +56,7 @@ template <typename F, typename T1, typename T2,
 inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
   check_matching_dims("Binary function", "x", x, "y", y);
   return make_holder(
-      [](auto& f_inner, auto& x_inner, auto& y_inner) {
+      [](auto&& f_inner, auto&& x_inner, auto&& y_inner) {
         return x_inner.binaryExpr(y_inner, f_inner);
       },
       std::forward<F>(f), std::forward<T1>(x), std::forward<T2>(y));
@@ -80,7 +80,7 @@ template <typename F, typename T1, typename T2,
 inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
   check_matching_sizes("Binary function", "x", x, "y", y);
   return make_holder(
-      [](auto& f_inner, auto& x_inner, auto& y_inner) {
+      [](auto&& f_inner, auto&& x_inner, auto&& y_inner) {
         using int_vec_t = promote_scalar_t<value_type_t<decltype(y_inner)>,
                                            plain_type_t<decltype(x_inner)>>;
         Eigen::Map<const int_vec_t> y_map(y_inner.data(), y_inner.size());
@@ -107,7 +107,7 @@ template <typename F, typename T1, typename T2,
 inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
   check_matching_sizes("Binary function", "x", x, "y", y);
   return make_holder(
-      [](auto& f_inner, auto& x_inner, auto& y_inner) {
+      [](auto&& f_inner, auto&& x_inner, auto&& y_inner) {
         using int_vec_t = promote_scalar_t<value_type_t<decltype(x_inner)>,
                                            plain_type_t<decltype(y_inner)>>;
         Eigen::Map<const int_vec_t> x_map(x_inner.data(), x_inner.size());
@@ -201,7 +201,7 @@ template <typename F, typename T1, typename T2, require_eigen_t<T1>* = nullptr,
           require_stan_scalar_t<T2>* = nullptr>
 inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
   return make_holder(
-      [](auto& f_inner, auto& x_inner, auto& y_inner) {
+      [](auto&& f_inner, auto&& x_inner, auto&& y_inner) {
         return x_inner.unaryExpr(
             [f_inner, y_inner](const auto& v) { return f_inner(v, y_inner); });
       },
@@ -227,7 +227,7 @@ template <typename F, typename T1, typename T2,
           require_stan_scalar_t<T1>* = nullptr, require_eigen_t<T2>* = nullptr>
 inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
   return make_holder(
-      [](auto& f_inner, auto& x_inner, auto& y_inner) {
+      [](auto&& f_inner, auto&& x_inner, auto&& y_inner) {
         return y_inner.unaryExpr(
             [f_inner, x_inner](const auto& v) { return f_inner(x_inner, v); });
       },
diff --git a/stan/math/prim/functor/coupled_ode_system.hpp b/stan/math/prim/functor/coupled_ode_system.hpp
index 5298b53a570..c88802d2ce9 100644
--- a/stan/math/prim/functor/coupled_ode_system.hpp
+++ b/stan/math/prim/functor/coupled_ode_system.hpp
@@ -4,6 +4,7 @@
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/size.hpp>
+#include <stan/math/prim/fun/value_of.hpp>
 #include <stan/math/prim/functor/apply.hpp>
 #include <ostream>
 #include <vector>
diff --git a/stan/math/prim/functor/filter_map.hpp b/stan/math/prim/functor/filter_map.hpp
new file mode 100644
index 00000000000..0458a4ef668
--- /dev/null
+++ b/stan/math/prim/functor/filter_map.hpp
@@ -0,0 +1,160 @@
+#ifndef STAN_MATH_PRIM_FUNCTOR_FILTER_MAP_HPP
+#define STAN_MATH_PRIM_FUNCTOR_FILTER_MAP_HPP
+
+#include <stan/math/prim/functor/apply.hpp>
+#include <stan/math/prim/functor/make_holder_tuple.hpp>
+#include <stan/math/prim/functor/tuple_concat.hpp>
+#include <stan/math/prim/meta.hpp>
+#include <functional>
+#include <tuple>
+#include <utility>
+
+namespace stan {
+namespace math {
+
+namespace internal {
+
+template <template <typename...> class Filter, typename T>
+struct inspect_tuple {
+  static constexpr bool value = Filter<T>::value;
+};
+
+template <template <typename...> class Filter, typename... Types>
+struct inspect_tuple<Filter, std::tuple<Types...>> {
+  static constexpr bool value = Filter<std::tuple<Types...>>::value
+                                || (inspect_tuple<Filter, Types>::value || ...);
+};
+
+template <template <typename...> class Filter, typename T, typename... VecArgs>
+struct inspect_tuple<Filter, std::vector<T, VecArgs...>> {
+  static constexpr bool value
+      = Filter<std::vector<T, VecArgs...>>::value
+        || inspect_tuple<Filter, std::decay_t<T>>::value;
+};
+
+/**
+ * Check if a tuple or type contains a tuple that passes the filter.
+ * @tparam Filter a struct that accepts one template parameter and has a static
+ *  constexpr bool member named value that is true if the type should be
+ *  included in the output tuple.
+ * @tparam T type to check
+ */
+template <template <typename...> class Filter, typename T>
+inline constexpr bool inspect_tuple_v
+    = internal::inspect_tuple<Filter, std::decay_t<T>>::value;
+
+/**
+ * Filter a tuple and apply a functor to each element that passes the filter.
+ * @note The `Filter` must have a static constexpr bool member named `value`
+ * that is true if the type should be included in the output tuple.
+ * Note that this function automatically inspects into tuples and
+ * `std::vector<T>::value_type`'s. The `filter_map` will recursively apply
+ * itself to inner containers as long as it sees a tuple in type type.
+ *  So for instance if your type is a
+ * `tuple<vector<tuple<vector<vector<double>>>>` your functor `f` must support
+ * operationg on `vector<vector<double>>` types.
+ * @tparam Filter a struct that accepts one template parameter and has a static
+ *  constexpr bool member named value that is true if the type should be
+ *  included in the output tuple.
+ * @tparam InVector For internal use. If true then we assume we are inside of a
+ *  `std::vector` and the return type should not be wrapped in a tuple.
+ * @tparam InTuple For internal use. If true then we assume we are inside of a
+ *  tuple and any subtuples should be double wrapped so that tuple_concat
+ *  produces a tuple for this element.
+ * @tparam F Type of functor
+ * @tparam T Any type
+ * @param f functor callable
+ * @param x Any type
+ * @return a tuple with the functor applied to each element which passed the
+ * filter.
+ */
+template <template <typename...> class Filter, bool InVector = false,
+          bool InTuple = false, typename F, typename T>
+inline constexpr decltype(auto) filter_map(F&& f, T&& x) {
+  if constexpr (inspect_tuple_v<Filter, T>) {
+    if constexpr (is_tuple_v<T>) {
+      auto ret = stan::math::apply(
+          [&f](auto&&... args) {
+            return stan::math::tuple_concat(filter_map<Filter, false, true>(
+                f, std::forward<decltype(args)>(args))...);
+          },
+          std::forward<T>(x));
+      /**
+       * If we are in at this stage, we want tuple_concat to return a tuple here
+       * So we return a tuple(tuple()) so that tuple_cat concats
+       * the first layer of tuple.
+       * For example, if our input is a tuple(double, tuple(double,
+       * vec<double>)) with an identity filter we want tuple_concat to return a
+       * tuple(double, tuple(double, vec<double>)).
+       * Without the double tuple we would get back a tuple(double, double,
+       * vec<double>).
+       */
+      if constexpr (InTuple) {
+        return make_holder_tuple(std::move(ret));
+      } else {
+        return ret;
+      }
+    } else if constexpr (is_std_vector_v<T>) {
+      /* 3 cases for vectors
+       * 1. value_type is a tuple
+       * 2. value_type is a scalar or Eigen matrix
+       * 3. value_type is a std::vector which can hold either (1) or (2)
+       */
+      if constexpr (contains_tuple<T>::value) {
+        std::vector<decltype(filter_map<Filter, true>(f, x[0]))> ret;
+        for (size_t i = 0; i < x.size(); ++i) {
+          ret.push_back(filter_map<Filter, true>(f, x[i]));
+        }
+        /*
+         * If we are in a vector, return the raw type, otherwise we are in
+         * a tuple and we want to return a tuple of the vector.
+         */
+        if constexpr (InVector) {
+          return ret;
+        } else {
+          return std::make_tuple(std::move(ret));
+        }
+      } else {
+        if constexpr (InVector) {
+          return std::forward<F>(f)(std::forward<T>(x));
+        } else {
+          return make_holder_tuple(std::forward<F>(f)(std::forward<T>(x)));
+        }
+      }
+    } else {
+      if constexpr (InVector) {
+        return std::forward<F>(f)(std::forward<T>(x));
+      } else {
+        return make_holder_tuple(std::forward<F>(f)(std::forward<T>(x)));
+      }
+    }
+  } else {
+    return std::make_tuple();
+  }
+}
+}  // namespace internal
+/**
+ * Filter a tuple and apply a functor to each element that passes the filter.
+ * @note The `Filter` will only check `T` and if `T` is a tuple, it will
+ * recursively check each element of the tuple. But it will not inspect into
+ * `std::vector` elements automatically. If you want to inspect the inner
+ * element of an `std::vector` your type trait must do that itself.
+ * @tparam Filter a struct that accepts one template parameter and has a static
+ *  constexpr bool member named value that is true if the type should be
+ *  included in the output tuple.
+ * @tparam F Type of functor
+ * @tparam T A tuple
+ * @param f functor callable
+ * @param x tuple of arguments
+ * @return a tuple with the functor applied to each element which passed the
+ * filter.
+ */
+template <template <typename...> class Filter, typename F, typename T,
+          require_tuple_t<T>* = nullptr>
+inline constexpr decltype(auto) filter_map(F&& f, T&& x) {
+  return internal::filter_map<Filter>(std::forward<F>(f), std::forward<T>(x));
+}
+}  // namespace math
+}  // namespace stan
+
+#endif
diff --git a/stan/math/prim/functor/for_each.hpp b/stan/math/prim/functor/for_each.hpp
index d821c47b874..4e617a83732 100644
--- a/stan/math/prim/functor/for_each.hpp
+++ b/stan/math/prim/functor/for_each.hpp
@@ -53,8 +53,34 @@ constexpr inline auto for_each(F&& f, T1&& t1, T2&& t2, T3&& t3,
                                            std::get<Is>(std::forward<T3>(t3)))),
       0)...});
 }
+
+// TODO(Steve) This should be variadic
+template <typename F, typename T1, typename T2, typename T3, typename T4,
+          size_t... Is>
+constexpr inline auto for_each(F&& f, T1&& t1, T2&& t2, T3&& t3, T4&& t4,
+                               std::index_sequence<Is...>) {
+  using Swallow = int[];
+  static_cast<void>(Swallow{(
+      static_cast<void>(std::forward<F>(f)(std::get<Is>(std::forward<T1>(t1)),
+                                           std::get<Is>(std::forward<T2>(t2)),
+                                           std::get<Is>(std::forward<T3>(t3)),
+                                           std::get<Is>(std::forward<T4>(t4)))),
+      0)...});
+}
 }  // namespace internal
 
+/**
+ * Apply a function to each element of a tuple
+ * @tparam F type with a valid `operator()`
+ * @tparam T Tuple
+ * @param f A functor to apply over each element of the tuple.
+ * @param t A tuple
+ */
+template <typename F, typename T>
+constexpr inline void for_each(F&& f, const std::tuple<>& /* t */) {
+  return;
+}
+
 /**
  * Apply a function to each element of a tuple
  * @tparam F type with a valid `operator()`
@@ -114,6 +140,24 @@ constexpr inline auto for_each(F&& f, T1&& t1, T2&& t2, T3&& t3) {
                             std::make_index_sequence<t1_size>());
 }
 
+template <typename F, typename T1, typename T2, typename T3, typename T4>
+constexpr inline auto for_each(F&& f, T1&& t1, T2&& t2, T3&& t3, T4&& t4) {
+  constexpr auto t1_size = std::tuple_size<std::decay_t<T1>>::value;
+  constexpr auto t2_size = std::tuple_size<std::decay_t<T2>>::value;
+  constexpr auto t3_size = std::tuple_size<std::decay_t<T3>>::value;
+  constexpr auto t4_size = std::tuple_size<std::decay_t<T4>>::value;
+  static_assert(t1_size == t2_size,
+                "Size Mismatch between t1 and t2 in for_each");
+  static_assert(t1_size == t3_size,
+                "Size Mismatch between t1 and t3 in for_each");
+  static_assert(t1_size == t4_size,
+                "Size Mismatch between t1 and t3 in for_each");
+  return internal::for_each(std::forward<F>(f), std::forward<T1>(t1),
+                            std::forward<T2>(t2), std::forward<T3>(t3),
+                            std::forward<T4>(t4),
+                            std::make_index_sequence<t1_size>());
+}
+
 }  // namespace math
 }  // namespace stan
 
diff --git a/stan/math/prim/functor/iter_tuple_nested.hpp b/stan/math/prim/functor/iter_tuple_nested.hpp
new file mode 100644
index 00000000000..70213512b59
--- /dev/null
+++ b/stan/math/prim/functor/iter_tuple_nested.hpp
@@ -0,0 +1,44 @@
+#ifndef STAN_MATH_PRIM_FUNCTOR_ITER_TUPLE_N_HPP
+#define STAN_MATH_PRIM_FUNCTOR_ITER_TUPLE_N_HPP
+
+#include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/prim/meta.hpp>
+#include <stan/math/prim/functor/for_each.hpp>
+#include <stan/math/prim/fun/max_size.hpp>
+#include <utility>
+namespace stan::math {
+/**
+ * Iterate and nest into a tuple or std::vector to apply `f` to each matrix or
+ * scalar type.
+ * @tparam F a functor with `operator()(Arg&&)`
+ * @tparam Types types of arguments to `f`
+ * @param f functor to apply
+ * @param args arguments to apply `f` to. If `args` is a tuple or std::vector,
+ * this function will nest until it finds an Eigen type or scalar then apply `f`
+ * to that value.
+ * @return void, all arguments are passed by reference and this function will
+ * only create side effects.
+ */
+template <typename F, typename... Types>
+inline void iter_tuple_nested(F&& f, Types&&... args) {
+  constexpr bool is_vec_container
+      = (is_std_vector_v<Types> && ...)
+        && (!is_stan_scalar<value_type_t<Types>>::value && ...);
+  if constexpr ((is_tuple_v<Types> && ...)) {
+    stan::math::for_each(
+        [&f](auto&&... args_i) {
+          iter_tuple_nested(f, std::forward<decltype(args_i)>(args_i)...);
+        },
+        std::forward<Types>(args)...);
+  } else if constexpr (is_vec_container) {
+    const auto vec_size = max_size(args...);
+    for (Eigen::Index i = 0; i < vec_size; ++i) {
+      iter_tuple_nested(f, args[i]...);
+    }
+  } else {
+    f(std::forward<Types>(args)...);
+  }
+}
+
+}  // namespace stan::math
+#endif
diff --git a/stan/math/prim/functor/make_holder_tuple.hpp b/stan/math/prim/functor/make_holder_tuple.hpp
new file mode 100644
index 00000000000..f436ccfcc28
--- /dev/null
+++ b/stan/math/prim/functor/make_holder_tuple.hpp
@@ -0,0 +1,76 @@
+#ifndef STAN_MATH_PRIM_FUNCTOR_MAKE_HOLDER_TUPLE_HPP
+#define STAN_MATH_PRIM_FUNCTOR_MAKE_HOLDER_TUPLE_HPP
+
+#include <stan/math/prim/functor/apply.hpp>
+#include <stan/math/prim/meta.hpp>
+#include <functional>
+#include <tuple>
+#include <utility>
+
+namespace stan {
+namespace math {
+namespace internal {
+
+/**
+ * @brief Helper template to deduce the correct type for tuple elements.
+ *
+ * This template determines the type to store in a tuple when forwarding
+ * arguments.
+ * - If the argument type T is an rvalue reference, the resulting type is the
+ * decayed type (i.e. cv-qualified types and references are removed) so that the
+ * tuple element becomes a value.
+ * - If the argument type T is not an rvalue reference (typically deduced as an
+ * lvalue reference), then T&& will collapse to an lvalue reference, preserving
+ * the reference.
+ *
+ * @tparam T The type to deduce.
+ */
+template <typename T>
+struct deduce_cvr {
+  using type
+      = std::conditional_t<std::is_rvalue_reference_v<T>, std::decay_t<T>, T&&>;
+};
+
+template <typename T>
+using deduce_cvr_t = typename deduce_cvr<T>::type;
+}  // namespace internal
+/**
+ * Holds ownership of rvalues and forwards lvalues into a tuple.
+ *
+ * Constructs a tuple from the provided arguments such that:
+ * - If an argument is an xvalue (an rvalue), the tuple element will be a
+ * decayed value.
+ * - If an argument is an lvalue (or const lvalue), the tuple element will
+ * maintain its reference type.
+ *
+ * This behavior ensures that temporaries are stored by value in the tuple while
+ * lvalues are preserved as references. It is similar in intent to the `Holder`
+ * class in behavior, but for tuples instead of Eigen types.
+ * It is the opposite of `std::forward_as_tuple`, with the difference in
+ * handling rvalues. `std::forward_as_tuple` does not extend object lifetimes,
+ * so when an rvalue is passed to `std::forward_as_tuple`, the resulting tuple
+ * element will be a reference to a temporary that is destroyed at the end of
+ * the statement. This function ensures that rvalues are stored by value in the
+ * tuple, extending their lifetimes.
+ *
+ * @tparam Types Parameter pack representing the types of the arguments.
+ * @param args The arguments to forward into the tuple.
+ * @return A tuple containing the forwarded arguments with types deduced via
+ * deduce_cvr_t.
+ *
+ * @note The function is declared constexpr. It is noexcept when, for each input
+ * type, the type value coming in is either an lvalue reference or an rvalue
+ * type whose move constructor is nothrow
+ */
+template <typename... Types>
+inline constexpr auto make_holder_tuple(Types&&... args) {
+  if constexpr (sizeof...(Types) == 0) {
+    return std::tuple<>{};
+  } else {
+    return std::tuple<internal::deduce_cvr_t<Types&&>...>{
+        std::forward<Types>(args)...};
+  }
+}
+}  // namespace math
+}  // namespace stan
+#endif
diff --git a/stan/math/prim/functor/map_if.hpp b/stan/math/prim/functor/map_if.hpp
new file mode 100644
index 00000000000..05838502d69
--- /dev/null
+++ b/stan/math/prim/functor/map_if.hpp
@@ -0,0 +1,85 @@
+#ifndef STAN_MATH_PRIM_FUNCTOR_MAP_IF_HPP
+#define STAN_MATH_PRIM_FUNCTOR_MAP_IF_HPP
+
+#include <stan/math/prim/functor/apply.hpp>
+#include <stan/math/prim/functor/make_holder_tuple.hpp>
+#include <stan/math/prim/meta.hpp>
+#include <functional>
+#include <tuple>
+#include <utility>
+
+namespace stan {
+namespace math {
+namespace internal {
+
+template <template <typename...> class Filter, typename F, typename Arg>
+inline constexpr decltype(auto) filter_fun(F&& f, Arg&& arg) {
+  if constexpr (Filter<Arg>::value) {
+    return f(std::forward<Arg>(arg));
+  } else {
+    return std::forward<Arg>(arg);
+  }
+}
+
+}  // namespace internal
+
+/*
+ * Subset a tuple by a compile time filter on the types and return a
+ * tuple with an unary functor applied to each element where the filter was
+ * true:
+ * @note For types that fail the filter, a reference to the original type is
+ *  returned so we avoid a copy.
+ *
+ * @tparam Filter a struct that accepts one template parameter and has a static
+ *   constexpr bool member named value
+ * @tparam F Type of functor
+ * @tparam Args A parameter pack of arguments
+ * @param f functor callable
+ * @param args parameter pack of args
+ */
+template <template <typename...> class Filter, typename F, typename Tuple,
+          require_t<is_tuple<Tuple>>* = nullptr>
+inline constexpr auto map_if(F&& f, Tuple&& arg) {
+  return stan::math::apply(
+      [](auto&& f, auto&&... args) {
+        return make_holder_tuple(internal::filter_fun<Filter>(
+            std::forward<decltype(f)>(f),
+            std::forward<decltype(args)>(args))...);
+      },
+      std::forward<Tuple>(arg), std::forward<F>(f));
+}
+
+/*
+ * Subset a parameter pack by a compile time filter on the types and return a
+ * tuple with an unary functor applied to each element where the filter was
+ * true:
+ *
+ * @note For types that fail the filter, a reference to the original type is
+ *  returned so we avoid a copy.
+ * @tparam Filter a struct that accepts one template parameter and has a static
+ *   constexpr bool member named value
+ * @tparam F Type of functor
+ * @tparam Args A parameter pack of arguments
+ * @param f functor callable
+ * @param args parameter pack of args
+ */
+template <template <typename...> class Filter, typename F, typename Arg1,
+          typename... Args,
+          require_t<bool_constant<!is_tuple<Arg1>::value>>* = nullptr>
+inline constexpr auto map_if(F&& f, Arg1&& arg1, Args&&... args) {
+  return make_holder_tuple(
+      internal::filter_fun<Filter>(f, std::forward<Arg1>(arg1)),
+      internal::filter_fun<Filter>(f, std::forward<Args>(args))...);
+}
+
+template <template <typename...> class Filter, typename F, typename Arg,
+          require_t<bool_constant<!is_tuple<Arg>::value>>* = nullptr>
+inline constexpr decltype(auto) map_if(F&& f, Arg&& arg) {
+  return internal::filter_fun<Filter>(std::forward<F>(f),
+                                      std::forward<Arg>(arg));
+}
+
+}  // namespace math
+}  // namespace stan
+
+#endif
diff --git a/stan/math/prim/functor/tuple_concat.hpp b/stan/math/prim/functor/tuple_concat.hpp
new file mode 100644
index 00000000000..965ad233d6d
--- /dev/null
+++ b/stan/math/prim/functor/tuple_concat.hpp
@@ -0,0 +1,137 @@
+#ifndef STAN_MATH_PRIM_FUNCTOR_TUPLE_CONCAT_HPP
+#define STAN_MATH_PRIM_FUNCTOR_TUPLE_CONCAT_HPP
+
+#include <stan/math/prim/functor/make_holder_tuple.hpp>
+#include <stan/math/prim/meta.hpp>
+#include <functional>
+#include <tuple>
+#include <utility>
+
+/**
+ * `tuple_concat` only exists because of a bug in clang-7's `std::tuple_cat`
+ * If we move up to clang-8+, we can remove these functions and use
+ * `std::tuple_cat`
+ */
+
+namespace stan {
+namespace math {
+namespace internal {
+
+template <typename Tuple1, typename Tuple2, std::size_t... I1,
+          std::size_t... I2>
+inline auto constexpr tuple_concat_impl(Tuple1&& x, Tuple2&& y,
+                                        std::index_sequence<I1...> /* i */,
+                                        std::index_sequence<I2...> /* j */) {
+  return make_holder_tuple(std::get<I1>(std::forward<Tuple1>(x))...,
+                           std::get<I2>(std::forward<Tuple2>(y))...);
+}
+
+template <typename Tuple1, typename Tuple2, typename Tuple3, std::size_t... I1,
+          std::size_t... I2, std::size_t... I3>
+inline auto constexpr tuple_concat_impl(Tuple1&& x, Tuple2&& y, Tuple3&& z,
+                                        std::index_sequence<I1...> /* i */,
+                                        std::index_sequence<I2...> /* j */,
+                                        std::index_sequence<I3...> /* k */) {
+  return make_holder_tuple(std::get<I1>(std::forward<Tuple1>(x))...,
+                           std::get<I2>(std::forward<Tuple2>(y))...,
+                           std::get<I3>(std::forward<Tuple3>(z))...);
+}
+}  // namespace internal
+
+/**
+ * Base case to pass a tuple forward.
+ * @tparam Tuple Tuple type.
+ * @param x Tuple.
+ */
+inline constexpr auto tuple_concat() noexcept { return std::make_tuple(); }
+
+/**
+ * Base case to pass a tuple forward.
+ * @tparam Tuple Tuple type.
+ * @param x Tuple.
+ */
+template <typename Tuple>
+inline auto tuple_concat(Tuple&& x) noexcept {
+  return std::forward<Tuple>(x);
+}
+
+/**
+ * Concatenates two tuples
+ * @tparam Tuple1 First tuple type
+ * @tparam Tuple2 Second tuple type
+ * @param x First tuple
+ * @param y Second tuple
+ * @return A tuple containing the elements of x followed by the elements of y
+ */
+template <typename Tuple1, typename Tuple2>
+inline auto tuple_concat(Tuple1&& x, Tuple2&& y) {
+  return internal::tuple_concat_impl(
+      std::forward<Tuple1>(x), std::forward<Tuple2>(y),
+      std::make_index_sequence<std::tuple_size<std::decay_t<Tuple1>>{}>{},
+      std::make_index_sequence<std::tuple_size<std::decay_t<Tuple2>>{}>{});
+}
+
+/**
+ * Concatenates three tuples.
+ * @tparam Tuple1 First tuple type
+ * @tparam Tuple2 Second tuple type
+ * @tparam Tuple3 Third tuple type
+ * @param x First tuple
+ * @param y Second tuple
+ * @param z Third tuple
+ * @return A tuple containing the elements of x followed by the elements of y
+ * and z
+ */
+template <typename Tuple1, typename Tuple2, typename Tuple3>
+inline auto tuple_concat(Tuple1&& x, Tuple2&& y, Tuple3&& z) {
+  return internal::tuple_concat_impl(
+      std::forward<Tuple1>(x), std::forward<Tuple2>(y), std::forward<Tuple3>(z),
+      std::make_index_sequence<std::tuple_size<std::decay_t<Tuple1>>{}>{},
+      std::make_index_sequence<std::tuple_size<std::decay_t<Tuple2>>{}>{},
+      std::make_index_sequence<std::tuple_size<std::decay_t<Tuple3>>{}>{});
+}
+
+/**
+ * Concatenates multiple tuples.
+ * @tparam Tuple1 First tuple type
+ * @tparam Tuple2 Second tuple type
+ * @tparam OtherTuples Remaining tuple types
+ * @param x First tuple
+ * @param y Second tuple
+ * @param args Remaining tuples
+ * @return A tuple containing the elements of x followed by the elements of y
+ * and the remaining tuples
+ */
+template <typename Tuple1, typename Tuple2, typename... OtherTuples>
+inline auto tuple_concat(Tuple1&& x, Tuple2&& y, OtherTuples&&... args) {
+  return tuple_concat(
+      tuple_concat(std::forward<Tuple1>(x), std::forward<Tuple2>(y)),
+      std::forward<OtherTuples>(args)...);
+}
+
+/**
+ * Concatenates multiple tuples.
+ * @tparam Tuple1 First tuple type
+ * @tparam Tuple2 Second tuple type
+ * @tparam Tuple3 Third tuple type
+ * @tparam OtherTuples Remaining tuple types
+ * @param x First tuple
+ * @param y Second tuple
+ * @param z Third tuple
+ * @param args Remaining tuples
+ * @return A tuple containing the elements of x followed by the elements of y,
+ * z, and the remaining tuples
+ */
+template <typename Tuple1, typename Tuple2, typename Tuple3,
+          typename... OtherTuples>
+inline auto tuple_concat(Tuple1&& x, Tuple2&& y, Tuple3&& z,
+                         OtherTuples&&... args) {
+  return tuple_concat(
+      tuple_concat(std::forward<Tuple1>(x), std::forward<Tuple2>(y),
+                   std::forward<Tuple3>(z)),
+      std::forward<OtherTuples>(args)...);
+}
+}  // namespace math
+}  // namespace stan
+
+#endif
diff --git a/stan/math/prim/meta.hpp b/stan/math/prim/meta.hpp
index 445816ca69a..dd6e3053eb6 100644
--- a/stan/math/prim/meta.hpp
+++ b/stan/math/prim/meta.hpp
@@ -72,12 +72,14 @@
 #include <stan/math/prim/meta/append_return_type.hpp>
 #include <stan/math/prim/meta/base_type.hpp>
 #include <stan/math/prim/meta/contains_std_vector.hpp>
+#include <stan/math/prim/meta/contains_tuple.hpp>
 #include <stan/math/prim/meta/error_index.hpp>
 #include <stan/math/prim/meta/forward_as.hpp>
 #include <stan/math/prim/meta/holder.hpp>
 #include <stan/math/prim/meta/include_summand.hpp>
 #include <stan/math/prim/meta/index_type.hpp>
 #include <stan/math/prim/meta/index_apply.hpp>
+#include <stan/math/prim/meta/is_all_arithmetic.hpp>
 #include <stan/math/prim/meta/is_autodiff.hpp>
 #include <stan/math/prim/meta/is_arena_matrix.hpp>
 #include <stan/math/prim/meta/is_base_pointer_convertible.hpp>
diff --git a/stan/math/prim/meta/contains_tuple.hpp b/stan/math/prim/meta/contains_tuple.hpp
new file mode 100644
index 00000000000..10c84d80eb1
--- /dev/null
+++ b/stan/math/prim/meta/contains_tuple.hpp
@@ -0,0 +1,40 @@
+#ifndef STAN_MATH_PRIM_META_CONTAINS_TUPLE_HPP
+#define STAN_MATH_PRIM_META_CONTAINS_TUPLE_HPP
+#include <stan/math/prim/meta/is_vector.hpp>
+#include <stan/math/prim/meta/is_tuple.hpp>
+
+namespace stan {
+namespace internal {
+template <typename T>
+struct contains_tuple_impl {
+  static constexpr bool value = stan::math::is_tuple_v<T>;
+};
+
+template <typename T, typename... VecArgs>
+struct contains_tuple_impl<std::vector<T, VecArgs...>> {
+  static constexpr bool value = contains_tuple_impl<T>::value;
+};
+}  // namespace internal
+
+/**
+ * Check if the type is a tuple or contains a tuple
+ * @tparam T type to check
+ */
+template <typename T>
+struct contains_tuple {
+  static constexpr bool value
+      = internal::contains_tuple_impl<std::decay_t<T>>::value;
+};
+template <typename T>
+inline constexpr bool contains_tuple_v = contains_tuple<std::decay_t<T>>::value;
+
+/**
+ * Check if the type is a std::vector containing a tuple
+ */
+template <typename T>
+inline constexpr bool is_std_vector_containing_tuple_v
+    = is_std_vector_v<std::decay_t<T>>&& contains_tuple_v<std::decay_t<T>>;
+
+}  // namespace stan
+
+#endif
diff --git a/stan/math/prim/meta/holder.hpp b/stan/math/prim/meta/holder.hpp
index d204255d8e1..a9b3e4afbce 100644
--- a/stan/math/prim/meta/holder.hpp
+++ b/stan/math/prim/meta/holder.hpp
@@ -7,7 +7,6 @@
 #include <memory>
 #include <type_traits>
 #include <utility>
-
 /**
  * \defgroup eigen_expressions Eigen expressions
  */
@@ -102,6 +101,19 @@ struct traits<stan::math::Holder<ArgType, Ptrs...>> {
 }  // namespace Eigen
 
 namespace stan {
+namespace internal {
+template <typename T>
+struct is_holder : std::false_type {};
+template <typename ArgType, typename... Ptrs>
+struct is_holder<stan::math::Holder<ArgType, Ptrs...>> : std::true_type {};
+}  // namespace internal
+
+template <typename T>
+struct is_holder : internal::is_holder<std::decay_t<T>> {};
+
+template <typename T>
+inline constexpr bool is_holder_v = is_holder<T>::value;
+
 namespace math {
 
 /**
@@ -237,13 +249,17 @@ namespace math {
  */
 template <typename T, typename... Ptrs,
           std::enable_if_t<sizeof...(Ptrs) >= 1>* = nullptr>
-Holder<T, Ptrs...> holder(T&& arg, Ptrs*... pointers) {
+inline Holder<T, Ptrs...> holder(T&& arg, Ptrs*... pointers) {
   return Holder<T, Ptrs...>(std::forward<T>(arg), pointers...);
 }
 // trivial case with no pointers constructs no holder object
 template <typename T>
-T holder(T&& arg) {
-  return std::forward<T>(arg);
+inline decltype(auto) holder(T&& arg) {
+  if constexpr (std::is_rvalue_reference<T&&>::value) {
+    return std::decay_t<T>(std::forward<T>(arg));
+  } else {
+    return std::forward<T>(arg);
+  }
 }
 
 namespace internal {
@@ -258,14 +274,14 @@ namespace internal {
  * @return tuple of pointers allocated on heap (empty).
  */
 template <typename T>
-auto holder_handle_element(T& a, T*& res) {
+inline auto holder_handle_element(T& a, T*& res) {
   res = &a;
   return std::make_tuple();
 }
 template <typename T,
           std::enable_if_t<!(Eigen::internal::traits<std::decay_t<T>>::Flags
                              & Eigen::NestByRefBit)>* = nullptr>
-auto holder_handle_element(T&& a, std::remove_reference_t<T>*& res) {
+inline auto holder_handle_element(T&& a, std::remove_reference_t<T>*& res) {
   res = &a;
   return std::make_tuple();
 }
@@ -284,13 +300,13 @@ template <typename T, require_t<std::is_rvalue_reference<T&&>>* = nullptr,
           std::enable_if_t<
               static_cast<bool>(Eigen::internal::traits<std::decay_t<T>>::Flags&
                                     Eigen::NestByRefBit)>* = nullptr>
-auto holder_handle_element(T&& a, T*& res) {
+inline auto holder_handle_element(T&& a, T*& res) {
   res = new T(std::move(a));
   return std::make_tuple(res);
 }
 template <typename T, require_t<std::is_rvalue_reference<T&&>>* = nullptr,
           require_not_eigen_t<T>* = nullptr>
-auto holder_handle_element(T&& a, T*& res) {
+inline auto holder_handle_element(T&& a, T*& res) {
   res = new T(std::move(a));
   return std::make_tuple(res);
 }
@@ -307,8 +323,8 @@ auto holder_handle_element(T&& a, T*& res) {
  * @return `holder` referencing given expression
  */
 template <typename T, std::size_t... Is, typename... Args>
-auto make_holder_impl_construct_object(T&& expr, std::index_sequence<Is...>,
-                                       const std::tuple<Args*...>& ptrs) {
+inline auto make_holder_impl_construct_object(
+    T&& expr, std::index_sequence<Is...>, const std::tuple<Args*...>& ptrs) {
   return holder(std::forward<T>(expr), std::get<Is>(ptrs)...);
 }
 
@@ -322,13 +338,13 @@ auto make_holder_impl_construct_object(T&& expr, std::index_sequence<Is...>,
  * @return `holder` referencing expression constructed by given functor
  */
 template <typename F, std::size_t... Is, typename... Args>
-auto make_holder_impl(const F& func, std::index_sequence<Is...>,
-                      Args&&... args) {
+inline auto make_holder_impl(F&& func, std::index_sequence<Is...>,
+                             Args&&... args) {
   std::tuple<std::remove_reference_t<Args>*...> res;
   auto ptrs = std::tuple_cat(
       holder_handle_element(std::forward<Args>(args), std::get<Is>(res))...);
   return make_holder_impl_construct_object(
-      func(*std::get<Is>(res)...),
+      std::forward<F>(func)(*std::get<Is>(res)...),
       std::make_index_sequence<std::tuple_size<decltype(ptrs)>::value>(), ptrs);
 }
 
@@ -346,11 +362,11 @@ auto make_holder_impl(const F& func, std::index_sequence<Is...>,
  * @param args arguments for the functor
  * @return `holder` referencing expression constructed by given functor
  */
-template <typename F, typename... Args,
-          require_not_plain_type_t<
-              decltype(std::declval<F>()(std::declval<Args&>()...))>* = nullptr>
-auto make_holder(const F& func, Args&&... args) {
-  return internal::make_holder_impl(func,
+template <
+    typename F, typename... Args,
+    require_not_plain_type_t<std::invoke_result_t<F, Args&&...>>* = nullptr>
+inline auto make_holder(F&& func, Args&&... args) {
+  return internal::make_holder_impl(std::forward<F>(func),
                                     std::make_index_sequence<sizeof...(Args)>(),
                                     std::forward<Args>(args)...);
 }
@@ -366,10 +382,9 @@ auto make_holder(const F& func, Args&&... args) {
  * @return `holder` referencing expression constructed by given functor
  */
 template <typename F, typename... Args,
-          require_plain_type_t<
-              decltype(std::declval<F>()(std::declval<Args&>()...))>* = nullptr>
-auto make_holder(const F& func, Args&&... args) {
-  return func(std::forward<Args>(args)...);
+          require_plain_type_t<std::invoke_result_t<F, Args&&...>>* = nullptr>
+inline auto make_holder(F&& func, Args&&... args) {
+  return std::forward<F>(func)(std::forward<Args>(args)...);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/meta/is_all_arithmetic.hpp b/stan/math/prim/meta/is_all_arithmetic.hpp
new file mode 100644
index 00000000000..b1633576e39
--- /dev/null
+++ b/stan/math/prim/meta/is_all_arithmetic.hpp
@@ -0,0 +1,41 @@
+#ifndef STAN_MATH_PRIM_META_IS_ALL_ARITHMETIC_HPP
+#define STAN_MATH_PRIM_META_IS_ALL_ARITHMETIC_HPP
+
+#include <stan/math/prim/meta/scalar_type.hpp>
+#include <type_traits>
+#include <tuple>
+
+namespace stan {
+template <typename T>
+using is_arithmetic = std::is_arithmetic<scalar_type_t<T>>;
+
+template <typename T>
+inline constexpr bool is_arithmetic_v = is_arithmetic<std::decay_t<T>>::value;
+
+namespace internal {
+
+template <typename... Types>
+struct is_all_arithmetic_scalar_impl
+    : std::conjunction<is_arithmetic<std::decay_t<Types>>...> {};
+
+template <typename... Types>
+struct is_all_arithmetic_scalar_impl<std::tuple<Types...>>
+    : std::conjunction<is_all_arithmetic_scalar_impl<std::decay_t<Types>>...> {
+};
+template <typename T, typename... VecArgs>
+struct is_all_arithmetic_scalar_impl<std::vector<T, VecArgs...>>
+    : std::conjunction<is_all_arithmetic_scalar_impl<std::decay_t<T>>> {};
+}  // namespace internal
+
+template <typename... Types>
+struct is_all_arithmetic_scalar
+    : std::conjunction<
+          internal::is_all_arithmetic_scalar_impl<std::decay_t<Types>>...> {};
+
+template <typename... Types>
+inline constexpr bool is_all_arithmetic_scalar_v
+    = is_all_arithmetic_scalar<std::decay_t<Types>...>::value;
+
+}  // namespace stan
+
+#endif
diff --git a/stan/math/prim/meta/is_autodiff.hpp b/stan/math/prim/meta/is_autodiff.hpp
index 0d4b93b5ddc..fa78d0b4edb 100644
--- a/stan/math/prim/meta/is_autodiff.hpp
+++ b/stan/math/prim/meta/is_autodiff.hpp
@@ -19,6 +19,9 @@ struct is_autodiff
     : bool_constant<math::disjunction<is_var<std::decay_t<T>>,
                                       is_fvar<std::decay_t<T>>>::value> {};
 
+template <typename T>
+inline constexpr bool is_autodiff_v = is_autodiff<T>::value;
+
 /*! \ingroup require_stan_scalar_real */
 /*! \defgroup autodiff_types autodiff  */
 /*! \addtogroup autodiff_types */
diff --git a/stan/math/prim/meta/is_container.hpp b/stan/math/prim/meta/is_container.hpp
index 25479694f6b..058350ec3c7 100644
--- a/stan/math/prim/meta/is_container.hpp
+++ b/stan/math/prim/meta/is_container.hpp
@@ -24,6 +24,9 @@ template <typename Container>
 using is_container = bool_constant<
     math::disjunction<is_eigen<Container>, is_std_vector<Container>>::value>;
 
+template <typename T>
+inline constexpr bool is_container_v = is_container<std::decay_t<T>>::value;
+
 /*! \ingroup general_types */
 /*! \defgroup container_types container  */
 /*! \addtogroup container_types */
diff --git a/stan/math/prim/meta/is_eigen.hpp b/stan/math/prim/meta/is_eigen.hpp
index 5489a713b94..ef776763c64 100644
--- a/stan/math/prim/meta/is_eigen.hpp
+++ b/stan/math/prim/meta/is_eigen.hpp
@@ -20,6 +20,9 @@ template <typename T>
 struct is_eigen
     : bool_constant<is_base_pointer_convertible<Eigen::EigenBase, T>::value> {};
 
+template <typename T>
+inline constexpr bool is_eigen_v = is_eigen<T>::value;
+
 namespace internal {
 // primary template handles types that have no nested ::type member:
 template <class, class = void>
diff --git a/stan/math/prim/meta/is_fvar.hpp b/stan/math/prim/meta/is_fvar.hpp
index dea6f6bb0a4..0a26f93c1b5 100644
--- a/stan/math/prim/meta/is_fvar.hpp
+++ b/stan/math/prim/meta/is_fvar.hpp
@@ -14,6 +14,15 @@ namespace stan {
 template <typename T, typename = void>
 struct is_fvar : std::false_type {};
 
+/** \ingroup type_trait
+ * Specialization for pointers returns the underlying value the pointer is
+ * pointing to.
+ */
+template <typename T>
+struct value_type<T, std::enable_if_t<is_fvar<std::decay_t<T>>::value>> {
+  using type = typename std::decay_t<T>::Scalar;
+};
+
 /*! \ingroup require_stan_scalar_real */
 /*! \defgroup fvar_types fvar  */
 /*! \addtogroup fvar_types */
diff --git a/stan/math/prim/meta/is_plain_type.hpp b/stan/math/prim/meta/is_plain_type.hpp
index 8c91b4ae7eb..d3c7a4fc4ed 100644
--- a/stan/math/prim/meta/is_plain_type.hpp
+++ b/stan/math/prim/meta/is_plain_type.hpp
@@ -11,7 +11,8 @@ namespace stan {
  * to detect whether a type is an Eigen matrix expression.
  */
 template <typename S>
-using is_plain_type = std::is_same<std::decay_t<S>, plain_type_t<S>>;
+using is_plain_type
+    = std::is_same<std::decay_t<S>, plain_type_t<std::decay_t<S>>>;
 
 /*! \ingroup require_eigens_types */
 /*! \defgroup plain_type_types plain_type  */
diff --git a/stan/math/prim/meta/is_stan_scalar.hpp b/stan/math/prim/meta/is_stan_scalar.hpp
index 52d0b9f0356..60abe7c7819 100644
--- a/stan/math/prim/meta/is_stan_scalar.hpp
+++ b/stan/math/prim/meta/is_stan_scalar.hpp
@@ -28,6 +28,9 @@ struct is_stan_scalar
           is_fvar<std::decay_t<T>>, std::is_arithmetic<std::decay_t<T>>,
           is_complex<std::decay_t<T>>>::value> {};
 
+template <typename T>
+inline constexpr bool is_stan_scalar_v = is_stan_scalar<T>::value;
+
 /*! \ingroup require_stan_scalar_real */
 /*! \defgroup stan_scalar_types stan_scalar  */
 /*! \addtogroup stan_scalar_types */
diff --git a/stan/math/prim/meta/is_tuple.hpp b/stan/math/prim/meta/is_tuple.hpp
index 32740daed92..82ba01363e6 100644
--- a/stan/math/prim/meta/is_tuple.hpp
+++ b/stan/math/prim/meta/is_tuple.hpp
@@ -19,6 +19,8 @@ struct is_tuple_impl<std::tuple<Types...>> : std::true_type {};
 template <typename T>
 struct is_tuple : internal::is_tuple_impl<std::decay_t<T>> {};
 
+template <typename T>
+constexpr bool is_tuple_v = is_tuple<T>::value;
 /*! \ingroup require_std */
 /*! \defgroup tuple_types tuple  */
 /*! \addtogroup tuple_types */
@@ -45,8 +47,8 @@ template <typename... Types>
 using require_all_not_tuple_t
     = require_all_not_t<is_tuple<std::decay_t<Types>>...>;
 /*! @} */
-
 }  // namespace math
+
 }  // namespace stan
 
 #endif
diff --git a/stan/math/prim/meta/is_var.hpp b/stan/math/prim/meta/is_var.hpp
index 7f3f9c7afac..160700faa02 100644
--- a/stan/math/prim/meta/is_var.hpp
+++ b/stan/math/prim/meta/is_var.hpp
@@ -13,6 +13,71 @@ namespace stan {
 template <typename T, typename = void>
 struct is_var : std::false_type {};
 
+template <typename T>
+using has_var_scalar_type = is_var<scalar_type_t<T>>;
+
+template <typename T>
+inline constexpr bool is_var_v = is_var<T>::value;
+
+namespace internal {
+
+template <typename... Types>
+struct is_any_var_scalar_impl {
+  static constexpr bool value
+      = (has_var_scalar_type<std::decay_t<Types>>::value || ...);
+};
+
+template <typename... Types>
+struct is_any_var_scalar_impl<std::tuple<Types...>> {
+  static constexpr bool value
+      = (is_any_var_scalar_impl<std::decay_t<Types>>::value || ...);
+};
+
+template <typename T, typename... VecArgs>
+struct is_any_var_scalar_impl<std::vector<T, VecArgs...>> {
+  static constexpr bool value = is_any_var_scalar_impl<std::decay_t<T>>::value;
+};
+
+}  // namespace internal
+
+template <typename... Types>
+struct is_any_var_scalar
+    : std::disjunction<
+          internal::is_any_var_scalar_impl<std::decay_t<Types>>...> {};
+
+template <typename... Types>
+constexpr bool is_any_var_scalar_v
+    = is_any_var_scalar<std::decay_t<Types>...>::value;
+
+namespace internal {
+template <typename... Types>
+struct is_all_var_scalar_impl {
+  static constexpr bool value
+      = (has_var_scalar_type<std::decay_t<Types>>::value && ...);
+};
+template <typename... Types>
+struct is_all_var_scalar_impl<std::tuple<Types...>> {
+  static constexpr bool value
+      = (is_all_var_scalar_impl<std::decay_t<Types>>::value && ...);
+};
+
+template <typename... Types, typename... VecArgs>
+struct is_all_var_scalar_impl<std::vector<std::tuple<Types...>, VecArgs...>> {
+  static constexpr bool value
+      = (is_all_var_scalar_impl<std::decay_t<Types>>::value && ...);
+};
+
+}  // namespace internal
+
+template <typename... Types>
+struct is_all_var_scalar
+    : std::disjunction<
+          internal::is_all_var_scalar_impl<std::decay_t<Types>>...> {};
+
+template <typename... Types>
+constexpr bool is_all_var_scalar_v
+    = is_all_var_scalar<std::decay_t<Types>...>::value;
+
 /*! \ingroup require_stan_scalar_real */
 /*! \defgroup var_types var  */
 /*! \addtogroup var_types */
diff --git a/stan/math/prim/meta/is_vector.hpp b/stan/math/prim/meta/is_vector.hpp
index b0c62d255f2..697454c29fa 100644
--- a/stan/math/prim/meta/is_vector.hpp
+++ b/stan/math/prim/meta/is_vector.hpp
@@ -597,6 +597,9 @@ struct is_std_vector<
     T, std::enable_if_t<internal::is_std_vector_impl<std::decay_t<T>>::value>>
     : std::true_type {};
 
+template <typename T>
+inline constexpr bool is_std_vector_v = is_std_vector<T>::value;
+
 /** \ingroup type_trait
  * Specialization of scalar_type for vector to recursively return the inner
  * scalar type.
diff --git a/stan/math/prim/meta/plain_type.hpp b/stan/math/prim/meta/plain_type.hpp
index 08712b2092c..376a467bb08 100644
--- a/stan/math/prim/meta/plain_type.hpp
+++ b/stan/math/prim/meta/plain_type.hpp
@@ -2,6 +2,7 @@
 #define STAN_MATH_PRIM_META_PLAIN_TYPE_HPP
 
 #include <stan/math/prim/meta/is_eigen.hpp>
+#include <stan/math/prim/meta/is_tuple.hpp>
 #include <stan/math/prim/meta/is_detected.hpp>
 #include <stan/math/prim/meta/is_var_matrix.hpp>
 #include <type_traits>
@@ -19,7 +20,7 @@ struct plain_type {
 };
 
 template <typename T>
-using plain_type_t = typename plain_type<T>::type;
+using plain_type_t = typename plain_type<std::decay_t<T>>::type;
 
 /**
  * Determines return type of calling \c .eval() on Eigen expression.
@@ -81,6 +82,11 @@ struct plain_type<
   using type = typename std::decay_t<T>::PlainObject;
 };
 
+template <typename... Types>
+struct plain_type<std::tuple<Types...>> {
+  using type = std::tuple<typename plain_type<std::decay_t<Types>>::type...>;
+};
+
 }  // namespace stan
 
 #endif  // STAN_MATH_PRIM_META_PLAIN_TYPE_HPP
diff --git a/stan/math/prim/meta/promote_scalar_type.hpp b/stan/math/prim/meta/promote_scalar_type.hpp
index fbcbbe1f749..7824d0cfd19 100644
--- a/stan/math/prim/meta/promote_scalar_type.hpp
+++ b/stan/math/prim/meta/promote_scalar_type.hpp
@@ -111,6 +111,11 @@ struct promote_scalar_type<std::tuple<PromotionScalars...>,
   using type = std::tuple<typename promote_scalar_type<
       std::decay_t<PromotionScalars>, std::decay_t<UnPromotedTypes>>::type...>;
 };
+template <typename PromotionScalar, typename... UnPromotedTypes>
+struct promote_scalar_type<PromotionScalar, std::tuple<UnPromotedTypes...>> {
+  using type = std::tuple<typename promote_scalar_type<
+      std::decay_t<PromotionScalar>, std::decay_t<UnPromotedTypes>>::type...>;
+};
 
 template <typename T, typename S>
 using promote_scalar_t =
diff --git a/stan/math/prim/meta/scalar_type.hpp b/stan/math/prim/meta/scalar_type.hpp
index 9920ee15a31..0c74957edef 100644
--- a/stan/math/prim/meta/scalar_type.hpp
+++ b/stan/math/prim/meta/scalar_type.hpp
@@ -24,5 +24,10 @@ struct scalar_type {
 template <typename T>
 using scalar_type_t = typename scalar_type<T>::type;
 
+template <typename... Args>
+struct scalar_type<std::tuple<Args...>, void> {
+  using type = std::tuple<scalar_type_t<Args>...>;
+};
+
 }  // namespace stan
 #endif
diff --git a/stan/math/rev/core/arena_matrix.hpp b/stan/math/rev/core/arena_matrix.hpp
index da9094abcb2..5cb0ddcaaf7 100644
--- a/stan/math/rev/core/arena_matrix.hpp
+++ b/stan/math/rev/core/arena_matrix.hpp
@@ -480,7 +480,8 @@ namespace Eigen {
 namespace internal {
 
 template <typename T>
-struct traits<stan::math::arena_matrix<T>> {
+struct traits<
+    stan::math::arena_matrix<T, stan::require_eigen_dense_base_t<T>>> {
   using base = traits<Eigen::Map<T>>;
   using Scalar = typename base::Scalar;
   using XprKind = typename Eigen::internal::traits<std::decay_t<T>>::XprKind;
@@ -493,6 +494,14 @@ struct traits<stan::math::arena_matrix<T>> {
   };
 };
 
+template <typename T>
+struct traits<stan::math::arena_matrix<T, stan::require_eigen_sparse_base_t<T>>>
+    : traits<Eigen::Map<T>> {
+  using base = traits<Eigen::Map<T>>;
+  using Scalar = typename base::Scalar;
+  using XprKind = typename Eigen::internal::traits<std::decay_t<T>>::XprKind;
+};
+
 }  // namespace internal
 }  // namespace Eigen
 
diff --git a/stan/math/rev/core/count_vars.hpp b/stan/math/rev/core/count_vars.hpp
index 6c276a946c9..3edd209399a 100644
--- a/stan/math/rev/core/count_vars.hpp
+++ b/stan/math/rev/core/count_vars.hpp
@@ -1,9 +1,9 @@
 #ifndef STAN_MATH_REV_CORE_COUNT_VARS_HPP
 #define STAN_MATH_REV_CORE_COUNT_VARS_HPP
 
-#include <stan/math/prim/meta.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core/var.hpp>
+#include <stan/math/prim/functor/apply.hpp>
 
 #include <utility>
 #include <vector>
@@ -34,7 +34,6 @@ template <typename Arith, require_arithmetic_t<scalar_type_t<Arith>>* = nullptr,
 inline size_t count_vars_impl(size_t count, Arith& x, Pargs&&... args);
 
 inline size_t count_vars_impl(size_t count);
-
 /**
  * Count the number of vars in x (a std::vector of vars),
  *  add it to the running total,
@@ -130,10 +129,26 @@ inline size_t count_vars_impl(size_t count, Arith& x, Pargs&&... args) {
   return count_vars_impl(count, std::forward<Pargs>(args)...);
 }
 
+inline size_t count_vars_impl(size_t count, std::basic_ostream<char>*&) {
+  return count;
+}
 /**
  * End count_vars_impl recursion and return total number of counted vars
  */
 inline size_t count_vars_impl(size_t count) { return count; }
+
+template <typename... Pargs, typename... Args>
+inline size_t count_vars_impl(std::size_t count,
+                              const std::tuple<Pargs...>& arg, Args&&... args) {
+  return count_vars_impl(
+      stan::math::apply(
+          [count](auto&&... inner_args) {
+            return (count_vars_impl(0, inner_args) + ... + count);
+          },
+          arg),
+      std::forward<Args>(args)...);
+}
+
 }  // namespace internal
 
 /**
diff --git a/stan/math/rev/fun/adjoint_of.hpp b/stan/math/rev/fun/adjoint_of.hpp
index cfaf1ced7d7..c726835cfe8 100644
--- a/stan/math/rev/fun/adjoint_of.hpp
+++ b/stan/math/rev/fun/adjoint_of.hpp
@@ -13,13 +13,13 @@ struct nonexisting_adjoint {
     return *this;
   }
   template <typename T>
-  nonexisting_adjoint operator+=(T) {
+  nonexisting_adjoint operator+=(T) const {
     throw std::runtime_error(
         "internal::nonexisting_adjoint::operator+= should never be called! "
         "Please file a bug report.");
   }
   template <typename T>
-  nonexisting_adjoint operator-=(T) {
+  nonexisting_adjoint operator-=(T) const {
     throw std::runtime_error(
         "internal::nonexisting_adjoint::operator-= should never be called! "
         "Please file a bug report.");
@@ -34,7 +34,7 @@ struct nonexisting_adjoint {
  * @return reference to `x`'s adjoint
  */
 template <typename T, require_var_t<T>* = nullptr>
-auto& adjoint_of(const T& x) {
+inline auto& adjoint_of(const T& x) noexcept {
   return x.adj();
 }
 
diff --git a/stan/math/rev/fun/digamma.hpp b/stan/math/rev/fun/digamma.hpp
index beca0e006ee..be4cbda9a47 100644
--- a/stan/math/rev/fun/digamma.hpp
+++ b/stan/math/rev/fun/digamma.hpp
@@ -17,7 +17,7 @@ namespace math {
  * @return derivative of log gamma function at argument
  */
 inline var digamma(const var& a) {
-  return make_callback_var(digamma(a.val()), [a](auto& vi) {
+  return make_callback_var(digamma(a.val()), [a](auto&& vi) {
     a.adj() += vi.adj() * trigamma(a.val());
   });
 }
@@ -32,17 +32,17 @@ inline var digamma(const var& a) {
  */
 template <typename T, require_var_matrix_t<T>* = nullptr>
 inline auto digamma(const T& a) {
-  return make_callback_var(
-      a.val()
-          .array()
-          .unaryExpr([](auto& x) { return digamma(x); })
-          .matrix()
-          .eval(),
-      [a](auto& vi) mutable {
-        a.adj().array()
-            += vi.adj().array()
-               * a.val().array().unaryExpr([](auto& x) { return trigamma(x); });
-      });
+  return make_callback_var(a.val()
+                               .array()
+                               .unaryExpr([](auto&& x) { return digamma(x); })
+                               .matrix()
+                               .eval(),
+                           [a](auto&& vi) mutable {
+                             a.adj().array()
+                                 += vi.adj().array()
+                                    * a.val().array().unaryExpr(
+                                        [](auto&& x) { return trigamma(x); });
+                           });
 }
 
 }  // namespace math
diff --git a/stan/math/rev/fun/to_arena.hpp b/stan/math/rev/fun/to_arena.hpp
index 9a17e400a40..1335232cf8e 100644
--- a/stan/math/rev/fun/to_arena.hpp
+++ b/stan/math/rev/fun/to_arena.hpp
@@ -4,6 +4,7 @@
 #include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core/arena_matrix.hpp>
+#include <stan/math/prim/functor.hpp>
 #include <vector>
 #include <cstring>
 
@@ -45,7 +46,8 @@ inline arena_t<T> to_arena(T&& a) {
  */
 template <typename T, require_same_t<T, arena_t<T>>* = nullptr,
           require_not_matrix_cl_t<T>* = nullptr,
-          require_not_std_vector_t<T>* = nullptr>
+          require_not_std_vector_t<T>* = nullptr,
+          require_not_tuple_t<T>* = nullptr>
 inline std::remove_reference_t<T> to_arena(T&& a) {
   // intentionally never returning a reference. If an object is just
   // referenced it will likely go out of scope before it is used.
@@ -133,6 +135,21 @@ inline arena_t<std::vector<T>> to_arena(const std::vector<T>& a) {
   return res;
 }
 
+/**
+ * Copies objects inside of tuple onto ad stack
+ * @tparam Tuple `std::tuple` type
+ * @param tup A tuple with inner objects to be move to the ad stack
+ * @return A tuple with inner types moved into the AD stack
+ */
+template <typename Tuple, require_tuple_t<Tuple>* = nullptr>
+inline auto to_arena(Tuple&& tup) {
+  return stan::math::apply(
+      [](auto&&... args) {
+        return std::make_tuple(to_arena(std::forward<decltype(args)>(args))...);
+      },
+      std::forward<Tuple>(tup));
+}
+
 /**
  * If the condition is true, converts given argument into a type that has any
  * dynamic allocation on AD stack. Otherwise returns the argument
diff --git a/stan/math/rev/meta/arena_type.hpp b/stan/math/rev/meta/arena_type.hpp
index 095fd53f86f..3cf68cb512d 100644
--- a/stan/math/rev/meta/arena_type.hpp
+++ b/stan/math/rev/meta/arena_type.hpp
@@ -3,6 +3,7 @@
 
 #include <stan/math/prim/meta/is_eigen.hpp>
 #include <stan/math/prim/meta/is_var.hpp>
+#include <stan/math/prim/meta/is_tuple.hpp>
 #include <stan/math/prim/meta/plain_type.hpp>
 #include <stan/math/rev/core/arena_allocator.hpp>
 #include <stan/math/rev/core/chainable_alloc.hpp>
@@ -47,6 +48,7 @@ struct arena_type_impl<
                      && T::ColsAtCompileTime != Eigen::Dynamic>> {
   using type = plain_type_t<T>;
 };
+
 }  // namespace internal
 
 /**
diff --git a/test/unit/math/ad_tolerances.hpp b/test/unit/math/ad_tolerances.hpp
index 9d8e84e4b35..268767b2192 100644
--- a/test/unit/math/ad_tolerances.hpp
+++ b/test/unit/math/ad_tolerances.hpp
@@ -47,7 +47,7 @@ struct ad_tolerances {
   relative_tolerance grad_hessian_val_;
   relative_tolerance grad_hessian_hessian_;
   relative_tolerance grad_hessian_grad_hessian_;
-  ad_tolerances()
+  constexpr ad_tolerances()
       : gradient_val_(1e-8),
         gradient_grad_(1e-4),
 
diff --git a/test/unit/math/expect_near_rel.hpp b/test/unit/math/expect_near_rel.hpp
index 45ea269f2b7..7d05c91850a 100644
--- a/test/unit/math/expect_near_rel.hpp
+++ b/test/unit/math/expect_near_rel.hpp
@@ -149,7 +149,8 @@ void expect_near_rel(const std::string& msg, EigMat1&& x1, EigMat2&& x2,
     Eigen::IOFormat CleanFmt(5, 0, ", ", "\n", "[", "]");
     FAIL() << "\nx1: \n"
            << x1.format(CleanFmt) << "\nx2: \n"
-           << x2.format(CleanFmt) << "\n";
+           << x2.format(CleanFmt)
+           << "\ndiff:" << (x1 - x2).eval().format(CleanFmt);
   }
 #endif
 }
diff --git a/test/unit/math/is_finite.hpp b/test/unit/math/is_finite.hpp
index 368c805f88d..20c2c86a1e6 100644
--- a/test/unit/math/is_finite.hpp
+++ b/test/unit/math/is_finite.hpp
@@ -13,7 +13,7 @@ namespace test {
  * @param x value to test
  * @return true if value is finite
  */
-bool is_finite(double x) {
+inline bool is_finite(double x) {
   return !stan::math::is_inf(x) && !stan::math::is_nan(x);
 }
 
@@ -27,7 +27,7 @@ bool is_finite(double x) {
  * @return true if all container values are finite
  */
 template <typename T, int R, int C>
-bool is_finite(const Eigen::Matrix<T, R, C>& x) {
+inline bool is_finite(const Eigen::Matrix<T, R, C>& x) {
   for (int i = 0; i < x.size(); ++i)
     if (!is_finite(x(i)))
       return false;
@@ -42,7 +42,7 @@ bool is_finite(const Eigen::Matrix<T, R, C>& x) {
  * @return true if all container values are finite
  */
 template <typename T>
-bool is_finite(const std::vector<T>& x) {
+inline bool is_finite(const std::vector<T>& x) {
   for (size_t i = 0; i < x.size(); ++i)
     if (!is_finite(x[i]))
       return false;
diff --git a/test/unit/math/laplace/aki_disease_data/x1.hpp b/test/unit/math/laplace/aki_disease_data/x1.hpp
new file mode 100644
index 00000000000..efa762fd650
--- /dev/null
+++ b/test/unit/math/laplace/aki_disease_data/x1.hpp
@@ -0,0 +1,360 @@
+#ifndef STAN_TEST_UNIT_MIX_LAPLACE_AKI_DISEASE_DATA_HPP
+#define STAN_TEST_UNIT_MIX_LAPLACE_AKI_DISEASE_DATA_HPP
+namespace stan {
+namespace test {
+namespace laplace {
+namespace disease {
+static const auto x1 = std::vector<double>{
+    1,  1,  2,  2,  2,  2,  3,  3,  3,  3,  4,  4,  4,  5,  5,  5,  5,  6,  6,
+    6,  6,  6,  6,  6,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
+    7,  7,  7,  7,  7,  7,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
+    8,  8,  8,  8,  8,  8,  8,  8,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+    9,  9,  9,  9,  9,  9,  9,  9,  9,  10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+    10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11,
+    11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 12,
+    12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14,
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+    14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+    15, 15, 15, 15, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+    16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 17,
+    17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
+    17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
+    17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
+    18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
+    18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+    20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+    20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 21, 21,
+    21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+    21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+    21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
+    22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
+    22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
+    22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+    23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+    23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+    23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25,
+    25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+    25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+    25, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+    26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+    26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+    28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29,
+    29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+    30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 31, 31, 31, 31,
+    31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33};
+static const auto x2 = std::vector<double>{
+    4,  5,  3,  4,  5,  6,  3,  4,  5,  6,  3,  4,  5,  3,  4,  5,  6,  2,  3,
+    4,  5,  6,  7,  8,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
+    16, 17, 18, 19, 20, 21, 2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14,
+    15, 16, 17, 18, 19, 20, 21, 22, 2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12,
+    13, 14, 15, 16, 17, 18, 19, 20, 21, 2,  3,  4,  5,  6,  7,  8,  9,  10, 11,
+    12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 52, 53, 1,  2,  3,  4,  5,  6,
+    7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 2,
+    3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
+    22, 23, 24, 50, 2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16,
+    17, 18, 19, 20, 21, 22, 23, 24, 25, 49, 50, 51, 2,  3,  4,  5,  6,  7,  8,
+    9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 47,
+    48, 49, 50, 2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17,
+    18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 35, 36, 37, 38, 39, 40, 41, 42, 43,
+    44, 45, 46, 47, 48, 49, 50, 51, 3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13,
+    14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 34, 35,
+    36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 3,  4,  5,  6,  7,
+    8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
+    27, 28, 29, 30, 31, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
+    48, 49, 50, 3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18,
+    19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
+    38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 3,  4,  5,  6,  7,  8,  9,
+    10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
+    29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 48,
+    49, 51, 52, 53, 54, 4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17,
+    18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
+    37, 38, 39, 40, 41, 42, 43, 44, 45, 49, 51, 52, 53, 54, 55, 56, 57, 4,  5,
+    6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
+    25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 41, 42, 43, 44,
+    45, 46, 49, 51, 52, 54, 57, 58, 4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14,
+    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
+    34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
+    53, 54, 55, 56, 57, 58, 4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16,
+    17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
+    36, 37, 38, 39, 40, 41, 42, 43, 44, 46, 47, 48, 49, 50, 51, 52, 53, 54, 57,
+    58, 5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
+    23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
+    42, 43, 44, 46, 49, 50, 51, 52, 53, 54, 58, 6,  7,  8,  9,  10, 11, 12, 13,
+    14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
+    33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 49, 51, 52, 53, 54, 55,
+    56, 7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
+    25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44,
+    45, 47, 52, 54, 56, 8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
+    22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+    42, 43, 46, 9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
+    25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 10, 11, 12, 13, 14,
+    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 31, 34, 35, 36,
+    12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 13, 14, 15, 16,
+    17, 18, 19, 20, 21, 22, 15, 16, 17, 18, 19, 20, 21, 16, 17, 18, 19, 20};
+static const auto y = std::vector<int>{
+    4,    3,   0,   122,  29,   0,   6,    25,  32,  0,   16,  0,    4,    4,
+    0,    6,   0,   0,    0,    10,  4,    7,   0,   1,   0,   1,    25,   3,
+    45,   172, 52,  324,  4,    5,   34,   4,   12,  27,  46,  55,   31,   18,
+    0,    6,   0,   2,    15,   162, 67,   82,  124, 81,  62,  953,  104,  107,
+    19,   57,  52,  74,   33,   57,  421,  26,  3,   9,   31,  160,  2288, 133,
+    15,   46,  155, 251,  40,   48,  30,   27,  29,  42,  29,  44,   79,   169,
+    17,   4,   60,  62,   223,  126, 94,   83,  120, 135, 47,  42,   143,  59,
+    34,   97,  128, 28,   73,   80,  53,   11,  0,   0,   0,   116,  26,   90,
+    342,  89,  205, 96,   64,   213, 59,   35,  68,  18,  26,  95,   54,   327,
+    104,  63,  35,  71,   250,  6,   139,  73,  55,  96,  121, 89,   79,   55,
+    43,   80,  157, 26,   86,   38,  32,   68,  67,  168, 133, 105,  21,   108,
+    232,  0,   15,  136,  65,   64,  54,   304, 83,  118, 196, 1855, 24,   48,
+    9,    12,  24,  111,  79,   44,  42,   41,  37,  42,  221, 10,   0,    4,
+    0,    0,   115, 279,  183,  20,  30,   52,  307, 177, 679, 32,   50,   21,
+    84,   26,  87,  43,   90,   107, 27,   83,  30,  67,  56,  7,    0,    1,
+    1,    0,   1,   223,  179,  95,  71,   63,  536, 62,  83,  48,   116,  24,
+    74,   52,  21,  23,   36,   21,  16,   10,  18,  44,  27,  22,   132,  33,
+    57,   24,  12,  56,   17,   37,  2,    11,  12,  9,   1,   2,    25,   0,
+    16,   5,   0,   3195, 2290, 209, 726,  198, 45,  45,  39,  38,   33,   53,
+    113,  145, 27,  18,   63,   26,  28,   5,   29,  18,  48,  150,  19,   17,
+    182,  9,   0,   221,  161,  20,  1,    10,  7,   17,  7,   7,    6,    6,
+    4,    4,   1,   1,    1,    690, 1713, 540, 163, 119, 100, 21,   58,   48,
+    28,   233, 26,  44,   7,    31,  33,   20,  31,  35,  44,  19,   132,  22,
+    107,  37,  37,  31,   23,   0,   119,  36,  35,  8,   0,   10,   3,    3,
+    3,    3,   2,   2,    5,    1,   0,    1,   0,   0,   386, 122,  54,   67,
+    1180, 103, 11,  45,   10,   38,  55,   45,  36,  83,  15,  31,   20,   58,
+    24,   84,  36,  97,   8,    10,  37,   65,  767, 198, 83,  28,   27,   2,
+    6,    20,  13,  5,    2,    9,   6,    1,   4,   48,  3,   0,    1,    0,
+    4,    38,  75,  70,   226,  157, 269,  30,  122, 28,  14,  123,  983,  133,
+    191,  35,  94,  14,   12,   17,  74,   46,  9,   33,  24,  9,    73,   246,
+    62,   33,  10,  9,    6,    0,   3,    237, 179, 5,   1,   2,    8,    2,
+    1,    2,   0,   0,    0,    0,   0,    0,   15,  162, 81,  98,   34,   22,
+    35,   22,  78,  23,   47,   67,  32,   72,  20,  16,  45,  7,    21,   28,
+    8,    25,  32,  6,    8,    81,  30,   9,   5,   11,  4,   1,    5,    11,
+    12,   6,   5,   2,    0,    18,  8,    0,   0,   0,   0,   1,    0,    3,
+    0,    0,   3,   80,   127,  853, 51,   12,  27,  49,  16,  91,   19,   51,
+    27,   23,  27,  53,   69,   18,  39,   136, 6,   5,   6,   22,   20,   47,
+    4,    13,  3,   6,    7,    28,  3,    1,   17,  5,   5,   2,    8,    51,
+    1,    0,   0,   0,    1,    0,   0,    0,   0,   901, 164, 49,   36,   8,
+    120,  44,  29,  17,   17,   241, 17,   166, 47,  10,  29,  21,   170,  60,
+    8,    13,  18,  10,   37,   0,   11,   2,   79,  7,   5,   3,    0,    13,
+    4,    1,   0,   2,    0,    3,   5,    2,   0,   4,   0,   0,    0,    0,
+    5,    2,   0,   0,    1,    6,   0,    0,   168, 59,  27,  20,   18,   35,
+    105,  466, 57,  35,   48,   9,   22,   20,  29,  69,  100, 107,  59,   17,
+    11,   8,   15,  3,    4,    2,   4,    7,   8,   9,   4,   2,    1,    12,
+    16,   105, 12,  8,    1,    1,   0,    0,   0,   1,   24,  10,   0,    1,
+    0,    0,   0,   56,   54,   100, 66,   77,  9,   39,  28,  103,  79,   346,
+    128,  37,  851, 188,  33,   67,  22,   10,  2,   4,   415, 74,   9,    50,
+    15,   7,   5,   8,    2,    2,   1,    14,  3,   3,   6,   3,    0,    0,
+    3,    1,   0,   0,    1,    0,   3,    1,   0,   14,  46,  644,  43,   8,
+    50,   19,  23,  72,   33,   19,  14,   61,  83,  74,  22,  42,   3,    2,
+    94,   20,  39,  14,   3,    2,   8,    10,  29,  4,   7,   31,   6,    11,
+    1,    9,   11,  0,    12,   6,   0,    0,   0,   0,   0,   0,    1,    0,
+    10,   170, 45,  10,   8,    51,  29,   15,  15,  80,  21,  61,   75,   23,
+    7,    3,   36,  7,    19,   2,   1,    40,  20,  35,  10,  8,    6,    4,
+    12,   8,   14,  3,    5,    39,  10,   3,   0,   0,   0,   0,    0,    0,
+    9,    594, 30,  17,   7,    321, 34,   13,  21,  116, 48,  11,   12,   8,
+    127,  48,  3,   7,    4,    7,   12,   73,  32,  6,   9,   3,    8,    12,
+    115,  8,   6,   6,    0,    0,   0,    0,   6,   97,  13,  52,   87,   19,
+    22,   63,  73,  108,  18,   95,  9,    28,  4,   1,   125, 12,   2,    7,
+    7,    3,   3,   3,    2,    1,   7,    9,   1,   1,   4,   82,   48,   45,
+    24,   69,  23,  605,  53,   24,  16,   40,  15,  0,   1,   5,    1,    9,
+    2,    3,   0,   0,    0,    0,   14,   18,  140, 20,  66,  24,   86,   41,
+    20,   208, 3,   0,    0,    1,   1,    1,   16,  108, 32,  21,   11,   9,
+    0,    7,   0,   4,    24,   82,  14,   6,   4,   0,   0,   5,    3,    3,
+    0};
+static const auto ye = Eigen::VectorXd{
+    {2.8079055,    7.0898599,    1.8430127,    174.96143,    42.061934,
+     0.12833066,   4.340199,     34.082447,    51.48571,     0.13278291,
+     10.589369,    7.3046351,    4.8329585,    7.8532574,    5.8476511,
+     5.7880622,    0.72856462,   0.2799728,    0.12444456,   11.557298,
+     10.396495,    7.7440359,    0.84993784,   3.9912302,    0.097159,
+     2.3783082,    18.981563,    9.9705535,    58.144073,    179.51441,
+     47.729256,    458.1849,     8.2946817,    4.8010997,    32.635018,
+     4.7074167,    13.387533,    32.884418,    66.614769,    99.756987,
+     50.29044,     22.515207,    0.17914949,   4.3733269,    0.0135727,
+     0.72286756,   17.405913,    165.86485,    103.2835,     91.931015,
+     118.52939,    109.83366,    86.619977,    1025.0153,    101.01579,
+     78.657199,    23.971224,    83.336609,    78.757016,    114.06701,
+     62.16655,     104.95877,    534.55587,    47.620912,    2.2954138,
+     7.7934308,    40.158531,    163.21877,    2506.0659,    192.97843,
+     21.835028,    42.302459,    184.88548,    244.29468,    52.362386,
+     52.176951,    25.664934,    29.689173,    29.218903,    60.022954,
+     57.198501,    68.015308,    115.22675,    286.80855,    32.900904,
+     1.519439,     63.684781,    62.185461,    228.58175,    135.88382,
+     87.4316,      80.619066,    135.83706,    141.65653,    51.037915,
+     48.618129,    141.22714,    53.295604,    41.964699,    123.58541,
+     154.29759,    57.650262,    107.47161,    98.554211,    56.876424,
+     21.474296,    0.040422619,  0.34821039,   0.001,        143.23232,
+     37.982352,    100.45313,    396.51826,    92.769604,    223.84957,
+     79.091398,    64.660394,    233.74731,    59.249283,    29.543396,
+     55.312306,    20.178246,    30.197972,    83.957626,    62.695163,
+     412.31784,    85.738651,    86.717987,    46.352508,    103.76509,
+     306.76142,    6.2909621,    170.82238,    78.163638,    65.361058,
+     90.182609,    132.45141,    115.09998,    74.322633,    73.654898,
+     39.684313,    75.021054,    190.74998,    25.387099,    84.748298,
+     38.512918,    27.881239,    65.435182,    76.08324,     169.90848,
+     133.48166,    77.146067,    32.069336,    132.66612,    213.08964,
+     1.8067821,    11.997476,    167.21566,    53.346788,    63.462813,
+     50.036795,    290.92892,    87.058757,    115.32806,    197.9864,
+     1861.9949,    31.789102,    29.640872,    12.361098,    19.489799,
+     28.202109,    125.93309,    74.330987,    39.67347,     35.313346,
+     41.783712,    53.589689,    56.439326,    237.71279,    16.848286,
+     0.21993524,   3.1928984,    0.037911704,  0.69110819,   127.20582,
+     302.93702,    177.52261,    25.085587,    37.601925,    54.156493,
+     311.59822,    198.2311,     767.71236,    30.528553,    68.529954,
+     27.118555,    94.311358,    41.451931,    89.84789,     55.667646,
+     95.13495,     94.043529,    38.134755,    78.031443,    14.399746,
+     60.12356,     54.886318,    8.5315266,    0.038080321,  1.5793305,
+     2.7579936,    1.049687,     1.0982942,    258.62518,    175.22942,
+     93.322562,    75.218137,    60.056009,    671.7655,     70.222474,
+     77.078647,    45.786527,    121.41169,    27.840659,    72.341196,
+     50.032733,    25.070173,    31.929108,    39.344009,    21.690175,
+     15.116468,    10.57575,     21.302586,    47.678595,    35.711475,
+     27.435279,    109.57075,    40.16688,     67.930981,    21.375488,
+     20.002431,    52.465632,    15.375098,    34.018903,    3.1449289,
+     9.6746873,    10.729735,    5.0687518,    0.85546808,   2.3337694,
+     18.805409,    0.28000834,   6.5446359,    2.5544882,    0.0017414397,
+     3260.1201,    2457.0023,    216.8167,     737.41461,    220.52428,
+     50.633002,    56.160596,    41.716996,    38.1466,      31.966245,
+     47.295488,    141.2575,     122.98356,    34.109307,    15.887184,
+     56.383073,    32.921152,    27.342766,    3.4082205,    22.667169,
+     10.824355,    42.94846,     127.95805,    27.49756,     19.170851,
+     182.8949,     8.1964545,    0.91188566,   191.26598,    191.67284,
+     28.450453,    2.2579429,    10.019578,    4.0464199,    10.708548,
+     2.8114207,    4.768944,     4.134144,     5.8534102,    2.162349,
+     3.9541432,    1.342653,     0.91529879,   3.9002465,    743.0063,
+     1598.0077,    536.34986,    123.93432,    111.50481,    110.17095,
+     19.456837,    55.57457,     50.254706,    38.115542,    202.06064,
+     22.735728,    47.437094,    16.675338,    38.56963,     32.691523,
+     14.118096,    17.311103,    26.749477,    34.056677,    17.736093,
+     117.28666,    22.7567,      107.75481,    44.131476,    30.49434,
+     21.645093,    19.348974,    0.079406058,  104.95783,    33.090951,
+     38.29627,     6.6571875,    0.26229133,   10.488489,    3.9361475,
+     1.5829231,    3.1799059,    3.8968506,    3.8265142,    0.39171756,
+     5.5257424,    1.3473818,    0.023453171,  2.212155,     0.0040656913,
+     0.60265964,   374.55744,    110.37954,    60.202321,    80.970051,
+     1161.4218,    110.64017,    11.777246,    36.505843,    15.452632,
+     36.911494,    56.918281,    44.833513,    49.549443,    95.043703,
+     16.121778,    34.872602,    15.616248,    46.090323,    16.137712,
+     76.921971,    38.102508,    73.290657,    10.725773,    16.935231,
+     33.51789,     59.073008,    737.71698,    175.17118,    58.225519,
+     16.669716,    23.898271,    4.3778595,    3.0043434,    21.87579,
+     15.348173,    5.2770556,    2.2717941,    7.5654304,    6.4390779,
+     3.1644486,    7.2063012,    24.896623,    5.5661099,    0.1757917,
+     0.46016137,   0.028401166,  2.2769759,    35.836204,    63.768107,
+     65.961175,    213.19376,    184.107,      231.2068,     25.779306,
+     82.553184,    25.92105,     16.050637,    109.40016,    967.37663,
+     113.5866,     180.80319,    18.844468,    72.801862,    20.602838,
+     15.446136,    14.714812,    67.195246,    38.206297,    9.6948426,
+     38.804963,    25.273864,    11.340326,    67.054077,    275.15858,
+     57.967788,    21.957164,    6.6336674,    6.8855312,    6.3093907,
+     0.10269473,   2.8306819,    246.27315,    157.43093,    8.5258479,
+     3.3886577,    3.6383763,    2.9913716,    4.8594352,    2.1390241,
+     1.9017458,    0.41315486,   0.42741621,   0.001,        0.5386798,
+     0.1529444,    0.094871205,  15.197767,    143.48816,    69.229037,
+     98.517541,    25.512032,    24.252967,    27.7063,      19.196998,
+     66.564102,    25.374879,    31.827813,    62.439111,    34.501844,
+     49.554048,    25.699775,    20.588072,    43.626833,    11.844879,
+     14.474697,    22.75674,     4.2225824,    20.096198,    26.487958,
+     2.9531129,    5.2937605,    62.531464,    24.40185,     8.4113858,
+     3.6627988,    8.3542272,    2.4619647,    3.3846724,    4.8488691,
+     7.6661352,    9.1054431,    5.1034876,    4.8284948,    1.6566176,
+     1.5212708,    8.2614538,    6.1771674,    2.0841611,    0.13372279,
+     0.24060309,   0.2057354,    0.6766589,    0.57142167,   4.352334,
+     2.1999308,    0.70988057,   3.036213,     82.739916,    144.36021,
+     749.33922,    53.218416,    14.611087,    26.886852,    52.053184,
+     17.426813,    80.121529,    14.195308,    48.278151,    32.023248,
+     18.632297,    27.257992,    52.727063,    68.564754,    21.357125,
+     30.769108,    121.5369,     11.100909,    4.8862493,    5.306794,
+     15.38494,     19.934964,    26.441305,    3.1095696,    11.390125,
+     7.7813322,    3.711585,     3.3504113,    25.727677,    3.9458818,
+     0.9864188,    11.884295,    2.3753064,    1.2145425,    4.0695821,
+     6.2647199,    44.949764,    1.3823914,    0.076236933,  0.13903797,
+     0.93641143,   2.1220815,    0.20417439,   0.43063847,   0.7858135,
+     0.053243063,  792.43513,    146.46798,    49.513223,    31.125114,
+     7.7515767,    84.972886,    41.134958,    21.137359,    24.840748,
+     17.998721,    235.34337,    11.115606,    153.78061,    35.507648,
+     19.259173,    22.079289,    18.680777,    179.54699,    56.349346,
+     10.59656,     15.408957,    15.862917,    5.7561348,    33.133203,
+     0.45479332,   5.7638218,    2.7705378,    52.777928,    5.8761671,
+     4.4351054,    2.7159767,    1.7203242,    12.879771,    6.2936517,
+     1.8223816,    0.895328,     1.3266594,    0.58655748,   1.6712497,
+     5.6194667,    1.7400984,    0.20793027,   4.6306127,    0.13316812,
+     0.0048640432, 0.0068769836, 0.055226084,  8.8360272,    2.5540894,
+     0.2756354,    0.1281359,    0.4395864,    3.3616155,    0.82291967,
+     0.39481028,   142.74963,    55.53204,     22.933974,    28.241655,
+     15.673616,    25.966506,    92.549959,    382.10259,    40.362133,
+     36.125211,    35.778578,    16.991068,    18.131618,    27.919869,
+     27.890157,    57.641388,    91.698704,    109.40946,    52.729831,
+     20.356057,    12.833251,    8.1737293,    9.1068086,    1.3078578,
+     3.6704633,    2.4364525,    2.5573847,    10.312683,    4.2610746,
+     5.5071067,    2.366001,     1.4528914,    1.516798,     8.9310845,
+     9.0072596,    97.002265,    10.861113,    13.479311,    2.2650819,
+     0.73767952,   0.0372318,    0.0093589144, 0.0040105089, 0.5796563,
+     25.093921,    15.963899,    0.58904687,   0.14116927,   0.03326521,
+     0.001,        0.63403667,   39.598572,    51.413634,    69.978597,
+     55.809331,    61.876961,    12.595016,    26.042962,    23.855305,
+     76.454059,    55.654986,    304.85673,    104.60265,    26.253281,
+     740.98202,    160.28843,    30.758761,    54.308421,    18.648536,
+     7.3469814,    1.7897547,    8.8329055,    347.95782,    44.763751,
+     12.487016,    31.360225,    5.9201984,    6.0486533,    4.6356517,
+     4.013579,     4.5960256,    3.363408,     1.7823716,    8.0281325,
+     2.3626662,    8.1467089,    7.4792722,    3.1072764,    0.38412526,
+     2.7627489,    1.0496475,    1.596867,     0.0065632298, 0.045555971,
+     1.5793621,    0.0099377085, 0.95849964,   1.1275722,    2.2229409,
+     8.2507844,    35.70347,     619.22109,    42.057051,    6.3773366,
+     41.63295,     20.664321,    21.547638,    65.243731,    33.661125,
+     15.856443,    13.135322,    43.565092,    60.25733,     86.816681,
+     15.712241,    27.118575,    1.0592478,    3.7175065,    87.488486,
+     20.077608,    23.360356,    10.216764,    4.2137635,    4.2270488,
+     7.3231727,    4.8329137,    24.783687,    2.37178,      4.0414849,
+     24.734675,    4.3612481,    10.947756,    0.75072895,   8.0458263,
+     4.8723387,    0.6329216,    9.5825983,    2.4072976,    0.05487123,
+     0.0021761201, 0.045056743,  3.0180046,    0.028401166,  1.1067772,
+     1.3809492,    0.0054914295, 7.2256951,    136.7522,     38.679883,
+     10.983757,    10.725049,    40.50498,     24.500563,    14.056835,
+     14.061547,    58.961962,    10.33436,     44.505135,    49.584511,
+     20.503963,    11.563546,    5.8747409,    23.990314,    4.6233188,
+     18.87811,     7.3301682,    3.7671048,    30.866675,    14.87168,
+     19.460711,    4.7434952,    3.8362977,    6.2833446,    3.4414523,
+     8.2668733,    10.024785,    8.7906324,    2.8087193,    11.800107,
+     32.609097,    9.4208165,    7.1831193,    0.1068828,    0.13592667,
+     0.0026545723, 0.001,        0.037911704,  0.39889666,   6.6165956,
+     492.18765,    31.221589,    14.705176,    9.0949455,    352.65831,
+     39.767338,    9.2815253,    17.333625,    84.566872,    39.066769,
+     6.0803828,    9.9190387,    9.3333777,    128.38794,    28.302207,
+     0.86527991,   6.8277449,    8.3706889,    5.0262387,    11.903669,
+     51.586752,    22.525381,    7.301115,     7.7974257,    2.5721985,
+     7.9080151,    20.013651,    96.705323,    13.753545,    3.0540841,
+     3.9432765,    2.7296655,    1.3362144,    0.025177499,  0.0028377512,
+     7.8346715,    67.709182,    24.750486,    63.133497,    73.13714,
+     23.247488,    15.011142,    46.249985,    67.052228,    63.328789,
+     13.404621,    59.655427,    9.1633943,    20.022761,    5.4770284,
+     2.5958268,    92.574856,    7.1500347,    4.0019164,    3.251226,
+     5.733657,     1.3568457,    7.3253572,    4.2843157,    1.2275175,
+     1.9271144,    6.4264267,    6.7801983,    2.0850692,    0.79213142,
+     2.3543667,    75.710074,    47.040601,    36.497108,    17.639033,
+     52.660943,    22.679494,    569.96476,    40.502742,    13.524114,
+     8.8073649,    25.968678,    13.6126,      0.68392291,   1.4700891,
+     3.1304939,    3.592514,     4.9835516,    1.3162852,    2.5140758,
+     0.12674878,   0.069865516,  1.3280474,    1.6261318,    6.8285696,
+     15.979119,    103.22879,    20.6829,      49.314788,    19.906749,
+     58.002137,    36.003474,    15.245109,    160.28187,    2.5661325,
+     0.22747381,   0.053246837,  1.0809564,    2.145496,     0.99126199,
+     14.193248,    68.097195,    21.604477,    20.424173,    14.523847,
+     8.595883,     2.5293397,    5.5249527,    0.47465493,   3.8843123,
+     13.80246,     82.321295,    13.871562,    2.4878699,    0.97101431,
+     0.059880931,  0.84816308,   2.7030209,    2.909627,     3.1878836,
+     0.41693701}};
+}  // namespace disease
+}  // namespace laplace
+}  // namespace test
+}  // namespace stan
+#endif
diff --git a/test/unit/math/laplace/aki_synth_data/x1.hpp b/test/unit/math/laplace/aki_synth_data/x1.hpp
new file mode 100644
index 00000000000..4b935a08c2b
--- /dev/null
+++ b/test/unit/math/laplace/aki_synth_data/x1.hpp
@@ -0,0 +1,188 @@
+#ifndef STAN_TEST_UNIT_MIX_LAPLACE_AKI_SYNTH_DATA_HPP
+#define STAN_TEST_UNIT_MIX_LAPLACE_AKI_SYNTH_DATA_HPP
+namespace stan {
+namespace test {
+namespace laplace {
+static const auto x2 = std::vector<double>{
+    0.051008,  -0.74807,  -0.77293,   0.21837,   0.37268,   -0.62932,
+    -0.43307,  -0.84152,  0.47526,    0.32083,   0.32061,   -0.89077,
+    0.1785,    0.31558,   0.55777,    0.031919,  0.25091,   0.23572,
+    -0.072362, 0.5044,    -0.63223,   -0.76785,  -0.70018,  -0.64713,
+    -0.76739,  -0.51789,  0.17517,    -0.68031,  0.015952,  -0.71481,
+    0.078379,  -0.80872,  -0.84211,   -0.98592,  0.29104,   0.24322,
+    -0.60104,  -1.2465,   -0.82769,   -0.62117,  -0.70584,  0.067189,
+    0.30505,   0.60788,   -0.78937,   -0.53123,  0.25202,   -0.5788,
+    -0.83177,  -0.69859,  -0.73643,   -0.93496,  0.43959,   -0.54691,
+    -0.084056, 0.32211,   0.10765,    -0.71864,  -0.87878,  -0.69846,
+    0.39757,   -0.50451,  0.25024,    0.61709,   0.31833,   -0.57453,
+    0.097619,  0.48449,   0.52401,    -0.78138,  -0.49705,  -0.96985,
+    0.43541,   -0.67942,  -0.62529,   -0.023181, 0.232,     0.093844,
+    0.14234,   -0.61686,  0.23636,    0.38914,   -0.95179,  0.24088,
+    0.12446,   -0.60566,  -0.71397,   0.31008,   0.18019,   -0.42664,
+    0.061432,  0.07737,   0.42815,    -0.80251,  0.40143,   0.37085,
+    -0.80775,  0.50164,   0.58238,    -0.59136,  -0.87037,  -0.72087,
+    0.27778,   0.33241,   -0.14092,   -0.5976,   -0.85582,  -0.88912,
+    0.21346,   -0.53468,  0.31687,    -0.68122,  -0.97586,  0.41457,
+    0.32751,   -0.93209,  0.58395,    -0.44437,  0.29109,   -0.51081,
+    -0.96598,  0.18741,   0.17965,    -0.7269,   -0.5434,   -0.59823,
+    -0.20195,  0.47146,   -0.09822,   -0.35658,  0.63881,   0.62981,
+    -0.46223,  -0.073316, -0.55406,   -0.43762,  -0.22238,  0.093462,
+    0.53175,   0.40208,   0.47555,    -0.23383,  -0.31579,  -0.47352,
+    0.59239,   -0.22605,  -0.43995,   -0.54645,  0.46404,   -0.15194,
+    0.48536,   0.34726,   0.43897,    -0.21416,  0.5738,    0.38717,
+    0.32038,   -0.20781,  -0.18651,   0.24753,   0.6605,    -0.28659,
+    -0.32588,  -0.25205,  0.37259,    -0.29097,  -0.3047,   -0.2139,
+    -0.3683,   -0.46928,  0.3935,     -0.4564,   0.51128,   0.2255,
+    0.01463,   -0.19173,  0.38323,    0.49792,   0.35335,   -0.34723,
+    0.5838,    -0.13728,  0.38827,    -0.53173,  -0.11685,  0.54336,
+    -0.45399,  -0.21913,  0.30486,    0.65677,   0.6142,    -0.4581,
+    -0.21617,  -0.26016,  0.31885,    -0.23727,  0.5831,    0.028413,
+    -0.4184,   0.67413,   -0.25278,   0.5161,    0.20392,   -0.17207,
+    0.27275,   0.076348,  -0.36653,   0.44291,   -0.19976,  -0.54076,
+    -0.070603, 0.50715,   -0.060486,  0.21533,   0.46809,   -0.29889,
+    0.8613,    0.70121,   -0.11343,   0.31234,   -0.12173,  0.36868,
+    0.57311,   -0.25841,  0.30937,    0.43319,   -0.30448,  0.44276,
+    -0.19442,  -0.061052, 0.076193,   0.85827,   0.37039,   0.51482,
+    0.43128,   0.42286,   0.29815,    0.37128,   -0.51529,  0.38526,
+    -0.34825,  0.68511,   -0.36529,   -0.40904,  0.43574,   0.26888,
+    -0.49255,  0.07616,   0.49226,    -0.4025,   0.10477,   -0.56469,
+    -0.99882,  0.30459,   0.40456,    -0.76008,  -0.47643,  -0.80726,
+    0.8331,    0.59777,   0.18562,    -0.58728,  0.25104,   0.30927,
+    0.62925,   0.011422,  0.23849,    0.38469,   0.068541,  0.64612,
+    -0.56508,  -0.8886,   -0.62845,   -0.48411,  -0.7185,   -0.41442,
+    0.24785,   -0.71066,  0.045339,   -0.79354,  0.16722,   -0.92343,
+    -0.949,    -1.0669,   -0.0033876, 0.38705,   -0.56853,  -1.322,
+    -0.69066,  -0.79232,  -0.71607,   0.043044,  0.33697,   0.63917,
+    -0.87586,  -0.53424,  0.23553,    -0.51603,  -0.72244,  -0.58766,
+    -0.82279,  -0.92723,  0.31818,    -0.65826,  -0.08474,  0.47538,
+    0.030681,  -0.6815,   -0.90134,   -0.58672,  0.28867,   -0.50126,
+    0.30549,   0.72715,   0.47275,    -0.56594,  -0.05154,  0.41026,
+    0.41785,   -0.54634,  -0.55861,   -0.89504,  0.41617,   -0.59056,
+    -0.70178,  -0.16341,  0.089764,   0.14266,   0.12461,   -0.63647,
+    0.37829,   0.4183,    -0.93201,   0.39965,   0.044016,  -0.536,
+    -0.63046,  0.28571,   0.20175,    -0.54322,  -0.053363, 0.087857,
+    0.50038,   -0.54396,  0.33474,    0.38958,   -0.816,    0.30833,
+    0.53849,   -0.77083,  -0.78633,   -0.80967,  0.28779,   0.27796,
+    -0.11057,  -0.65763,  -0.80682,   -0.81519,  0.38465,   -0.55409,
+    0.10303,   -0.76518,  -0.8404,    0.30736,   0.42361,   -0.91969,
+    0.72762,   -0.64046,  0.27132,    -0.63159,  -0.67517,  0.26994,
+    0.31755,   -0.83271,  -0.59026,   -0.62548,  -0.092105, 0.44367,
+    -0.028066, -0.56176,  0.60343,    0.54745,   -0.61994,  -0.022518,
+    -0.52586,  -0.43427,  -0.35575,   0.20621,   0.56677,   0.37217,
+    0.47784,   -0.26003,  -0.49081,   -0.50208,  0.50926,   -0.32397,
+    -0.55559,  -0.59981,  0.26378,    -0.05552,  0.53737,   0.34525,
+    0.43549,   -0.29398,  0.67567,    0.37385,   0.24893,   -0.072676,
+    -0.20899,  0.18862,   0.63112,    -0.37138,  -0.43789,  0.00055432,
+    0.53814,   -0.26021,  -0.43041,   -0.30045,  -0.38595,  -0.39014,
+    0.2603,    -0.68939,  0.36637,    0.25886,   0.053765,  -0.14656,
+    0.37021,   0.51629,   0.30574,    -0.26102,  0.44764,   -0.091775,
+    0.3034,    -0.56522,  -0.061568,  0.64727,   -0.56576,  -0.093066,
+    0.37087,   0.64998,   0.59468,    -0.47986,  -0.24649,  -0.25786,
+    0.32397,   -0.15467,  0.7358,     0.075105,  -0.43937,  0.73665,
+    -0.23446,  0.41312,   0.29885,    -0.14137,  0.28626,   0.12787,
+    -0.34039,  0.34876,   -0.216,     -0.55536,  -0.1238,   0.67536,
+    -0.14806,  0.16695,   0.39689,    -0.41631,  0.84207,   0.6738,
+    0.039579,  0.28744,   -0.22815,   0.52902,   0.69658,   -0.28137,
+    0.15876,   0.38873,   -0.32007,   0.47037,   -0.22054,  -0.01671,
+    0.11538,   0.7332,    0.2756,     0.4407,    0.38049,   0.3908,
+    0.2994,    0.068365,  -0.56099,   0.5095,    -0.45492,  0.77848,
+    -0.33026,  -0.41194,  0.45399,    0.11237,   -0.501,    0.23655,
+    0.5021,    -0.39836};
+static const auto x1 = std::vector<double>{
+    0.16086,  0.08904,  0.26317,   0.12706,   0.49656,   0.63202,   0.14479,
+    -0.19131, 0.22484,  0.32721,   0.33408,   0.41169,   0.44691,   0.38853,
+    0.47273,  0.01223,  0.30717,   0.22494,   0.33377,   0.080546,  0.44552,
+    0.23615,  0.21039,  0.15921,   0.09259,   0.032881,  0.34535,   0.47612,
+    0.32168,  0.51421,  0.32285,   0.47037,   0.092942,  0.48309,   0.34276,
+    0.51488,  0.050601, 0.45923,   0.36187,   -0.10912,  0.65908,   0.60575,
+    0.47418,  0.39362,  0.17592,   0.42653,   0.1703,    0.26554,   0.54447,
+    0.38567,  0.11858,  0.11371,   0.41431,   0.24956,   0.36521,   0.69087,
+    0.57947,  0.25646,  0.45065,   0.95054,   0.1181,    0.57196,   0.39784,
+    0.10186,  0.087906, 0.18624,   0.55177,   0.35373,   0.46617,   -0.075347,
+    0.59948,  0.46625,  0.12192,   0.30754,   0.07099,   0.40443,   0.71067,
+    0.46674,  0.17899,  0.25508,   0.51544,   0.4043,    -0.037722, 0.71949,
+    0.45179,  0.26906,  0.30872,   0.34675,   0.46205,   0.64723,   0.32491,
+    0.32183,  0.13446,  0.66879,   0.42516,   0.26407,   0.41486,   0.23935,
+    0.22843,  0.3023,   0.26941,   0.19677,   0.21792,   0.2735,    0.39247,
+    0.1479,   0.14514,  0.26896,   0.43612,   0.57901,   0.39706,   0.042098,
+    0.45965,  0.27141,  0.3678,    0.09362,   0.47147,   0.2301,    0.19366,
+    0.41496,  0.17931,  0.29747,   0.45175,   0.35728,   0.41012,   0.98701,
+    0.62102,  0.48221,  0.58756,   0.6371,    0.42112,   0.28146,   0.61661,
+    0.55822,  0.51253,  0.87812,   0.88851,   0.6731,    0.54373,   0.51638,
+    0.65056,  0.63643,  0.75031,   0.63854,   0.89257,   0.79789,   0.52099,
+    0.74577,  0.51065,  0.81218,   0.82018,   0.70814,   0.62817,   0.64364,
+    0.63713,  0.58578,  0.53529,   0.65132,   0.81755,   0.39082,   0.89919,
+    0.73376,  0.39866,  0.67358,   0.49786,   1.0437,    0.86858,   1.0932,
+    0.7564,   0.88775,  0.77975,   0.80523,   0.76606,   0.46451,   0.40191,
+    0.80943,  0.75602,  0.61334,   0.77324,   0.70178,   0.76358,   0.71246,
+    0.44977,  0.61934,  0.87851,   0.41175,   0.66513,   0.83485,   0.98029,
+    0.75766,  0.75039,  0.77969,   0.88626,   0.81009,   0.84518,   0.80179,
+    0.7771,   0.75793,  0.68041,   0.60245,   0.70526,   0.62092,   0.91641,
+    1.0088,   0.29347,  0.56222,   0.64831,   0.80088,   0.54295,   0.65293,
+    1.003,    0.35046,  0.62983,   0.6026,    0.87182,   0.7367,    0.47289,
+    0.74573,  0.60067,  0.90756,   0.84113,   0.37053,   0.4095,    0.67192,
+    0.50823,  0.77017,  0.5782,    0.58023,   0.89877,   0.74185,   0.35386,
+    0.9582,   0.72342,  0.76204,   0.54259,   0.65242,   0.93454,   0.70089,
+    0.76473,  0.65528,  0.5053,    0.78067,   0.45703,   0.7423,    0.4469,
+    0.44559,  1.0144,   0.63795,   0.46876,   0.71301,   0.087445,  0.085959,
+    0.28641,  0.1697,   0.45928,   0.60838,   0.34716,   -0.41715,  0.44778,
+    0.36097,  0.43408,  0.24527,   0.38791,   0.36073,   0.515,     -0.15479,
+    0.35433,  0.10365,  0.34038,   0.14578,   0.47823,   0.34441,   0.311,
+    0.094123, 0.1183,   -0.061557, 0.21317,   0.5686,    0.32168,   0.50872,
+    0.41396,  0.52982,  0.12796,   0.60812,   0.43574,   0.53886,   -0.018435,
+    0.39408,  0.48108,  -0.2703,   0.65663,   0.41086,   0.57623,   0.47979,
+    0.17603,  0.41944,  -0.078331, 0.32365,   0.32523,   0.15374,   0.12657,
+    0.018859, 0.45546,  0.31726,   0.45098,   0.62176,   0.62441,   0.26652,
+    0.53325,  1.0042,   0.20789,   0.55877,   0.38312,   0.20264,   -0.12446,
+    0.13578,  0.42471,  0.31547,   0.53104,   0.0072256, 0.49799,   0.41914,
+    0.13563,  0.27835,  0.10117,   0.44442,   0.61767,   0.44906,   -0.034222,
+    0.36961,  0.45253,  0.28391,   -0.063117, 0.57662,   0.4497,    0.213,
+    0.5265,   0.4606,   0.21236,   0.69136,   0.1851,    0.29633,   0.1509,
+    0.74356,  0.39786,  0.4217,    0.36677,   0.2721,    0.2949,    0.31082,
+    0.35751,  0.22909,  0.13951,   0.092961,  0.57833,   0.08745,   0.15548,
+    0.32528,  0.44748,  0.48854,   0.35029,   0.029609,  0.60754,   0.18533,
+    0.44627,  0.12448,  0.44809,   0.1244,    0.16524,   0.40629,   0.032371,
+    0.31669,  0.36953,  0.34786,   0.44374,   0.89655,   0.59219,   0.51722,
+    0.40397,  0.74069,  0.66357,   0.3774,    0.58503,   0.60108,   0.40893,
+    1.0659,   0.98258,  0.75184,   0.45614,   0.54838,   0.59473,   0.60528,
+    0.69331,  0.53597,  0.80169,   0.7769,    0.35111,   0.80653,   0.49887,
+    0.8821,   0.84715,  0.75757,   0.47986,   0.54161,   0.59244,   0.59675,
+    0.64816,  0.62233,  0.9437,    0.43836,   1.0166,    0.74645,   0.33297,
+    0.52544,  0.51341,  1.1256,    0.83932,   1.0391,    0.72553,   0.77809,
+    0.73045,  0.78716,  0.77065,   0.45813,   0.46304,   0.82036,   0.93742,
+    0.64455,  0.95369,  0.62947,   0.81623,   0.68644,   0.50979,   0.67874,
+    0.65991,  0.27904,  0.52103,   0.87503,   1.1273,    0.72498,   0.83162,
+    0.83424,  0.7811,   0.84983,   0.76999,   0.95341,   0.77384,   0.92153,
+    0.63791,  0.6614,   0.69898,   0.41873,   0.8182,    1.0701,    0.28798,
+    0.45035,  0.58567,  0.82583,   0.44365,   0.75043,   0.9389,    0.53134,
+    0.52184,  0.62252,  0.71972,   0.66434,   0.41357,   0.78586,   0.69488,
+    0.93761,  0.80382,  0.45207,   0.48939,   0.68394,   0.56536,   0.81145,
+    0.4795,   0.65619,  0.83305,   0.68146,   0.37156,   0.92744,   0.71024,
+    0.82158,  0.64727,  0.63263,   0.9673,    0.67706,   0.78769,   0.69928,
+    0.44361,  0.80816,  0.51714,   0.75154,   0.61988,   0.38474,   0.94073,
+    0.46296,  0.55981,  0.79972};
+static const auto y = std::vector<int>{
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+}  // namespace laplace
+}  // namespace test
+}  // namespace stan
+#endif
diff --git a/test/unit/math/laplace/laplace_bernoulli_logit_rng_test.cpp b/test/unit/math/laplace/laplace_bernoulli_logit_rng_test.cpp
new file mode 100644
index 00000000000..3cfa826292f
--- /dev/null
+++ b/test/unit/math/laplace/laplace_bernoulli_logit_rng_test.cpp
@@ -0,0 +1,99 @@
+#include <stan/math.hpp>
+#include <stan/math/mix.hpp>
+
+#include <boost/random/mersenne_twister.hpp>
+#include <boost/math/distributions.hpp>
+
+#include <gtest/gtest.h>
+#include <iostream>
+#include <istream>
+#include <fstream>
+#include <vector>
+
+namespace {
+struct stationary_point {
+  template <typename T0, typename T1>
+  inline Eigen::Matrix<typename stan::return_type<T0, T1>::type, Eigen::Dynamic,
+                       1>
+  operator()(const Eigen::Matrix<T0, Eigen::Dynamic, 1>& theta,
+             const Eigen::Matrix<T1, Eigen::Dynamic, 1>& parms,
+             const std::vector<double>& dat, const std::vector<int>& dat_int,
+             std::ostream* pstream__ = 0) const {
+    Eigen::Matrix<typename stan::return_type<T0, T1>::type, Eigen::Dynamic, 1>
+        z(2);
+    z(0) = 1 / (1 + exp(theta(0))) - theta(0) / (parms(0) * parms(0));
+    z(1) = -1 / (1 + exp(-theta(1))) - theta(1) / (parms(1) * parms(1));
+    return z;
+  }
+};
+
+struct diagonal_kernel_functor {
+  template <typename T1, typename T2>
+  auto operator()(const T1& arg1, const T2& arg2,
+                  std::ostream* msgs = nullptr) const {
+    Eigen::Matrix<stan::return_type_t<T1, T2>, Eigen::Dynamic, Eigen::Dynamic>
+        K(2, 2);
+    K(0, 0) = arg1 * arg1;
+    K(1, 1) = arg2 * arg2;
+    K(0, 1) = 0;
+    K(1, 0) = 0;
+    return K;
+  }
+};
+
+template <typename T1, typename T2>
+Eigen::Matrix<T1, Eigen::Dynamic, Eigen::Dynamic> laplace_covariance(
+    const Eigen::Matrix<T1, Eigen::Dynamic, 1>& theta,
+    const Eigen::Matrix<T2, Eigen::Dynamic, 1>& phi) {
+  using stan::math::exp;
+  using stan::math::square;
+  Eigen::Matrix<T1, Eigen::Dynamic, Eigen::Dynamic> K(2, 2);
+  K(0, 0)
+      = -1
+        / (-1 / (phi(0) * phi(0)) - exp(theta(0)) / square(1 + exp(theta(0))));
+  K(1, 1) = -1
+            / (-1 / (phi(1) * phi(1))
+               - exp(-theta(1)) / square(1 + exp(-theta(1))));
+  K(0, 1) = 0;
+  K(1, 0) = 0;
+  return K;
+}
+
+TEST(laplace_bernoulli_logit_rng, two_dim_diag) {
+  using stan::math::algebra_solver;
+  using stan::math::laplace_latent_bernoulli_logit_rng;
+  using stan::math::multi_normal_rng;
+  using stan::math::sqrt;
+  using stan::math::square;
+
+  Eigen::VectorXd theta_0(2);
+  theta_0 << 0, 0;
+  Eigen::VectorXd phi(2);
+  phi << 3, 2;
+  std::vector<int> n_samples = {1, 1};
+  std::vector<int> sums = {1, 0};
+  Eigen::VectorXd ye(2);
+  ye << 1, 1;
+  std::vector<double> d0;
+  std::vector<int> di0;
+  std::vector<Eigen::VectorXd> x_dummy;
+  boost::random::mt19937 rng;
+  rng.seed(1954);
+  Eigen::MatrixXd theta_pred = laplace_latent_bernoulli_logit_rng(
+      sums, n_samples, theta_0, diagonal_kernel_functor{},
+      std::forward_as_tuple(phi(0), phi(1)), rng, nullptr);
+
+  // Compute exact mean and covariance
+  Eigen::VectorXd theta_root
+      = algebra_solver(stationary_point{}, theta_0, phi, d0, di0);
+  Eigen::MatrixXd K_laplace = laplace_covariance(theta_root, phi);
+
+  rng.seed(1954);
+  Eigen::MatrixXd theta_benchmark
+      = multi_normal_rng(theta_root, K_laplace, rng);
+
+  double tol = 1e-3;
+  EXPECT_NEAR(theta_benchmark(0), theta_pred(0), tol);
+  EXPECT_NEAR(theta_benchmark(1), theta_pred(1), tol);
+}
+}  // namespace
diff --git a/test/unit/math/laplace/laplace_marginal_bernoulli_logit_lpmf_test.cpp b/test/unit/math/laplace/laplace_marginal_bernoulli_logit_lpmf_test.cpp
new file mode 100644
index 00000000000..3f383294f4c
--- /dev/null
+++ b/test/unit/math/laplace/laplace_marginal_bernoulli_logit_lpmf_test.cpp
@@ -0,0 +1,71 @@
+#include <test/unit/math/test_ad.hpp>
+#include <stan/math.hpp>
+#include <stan/math/mix.hpp>
+#include <test/unit/math/laplace/laplace_utility.hpp>
+#include <test/unit/math/laplace/aki_synth_data/x1.hpp>
+
+#include <test/unit/math/rev/fun/util.hpp>
+
+#include <gtest/gtest.h>
+#include <iostream>
+#include <istream>
+#include <fstream>
+#include <vector>
+
+TEST(laplace_marginal_bernoulli_logit_lpmf, phi_dim500) {
+  using stan::math::laplace_marginal_bernoulli_logit_lpmf;
+  using stan::math::laplace_marginal_tol_bernoulli_logit_lpmf;
+  using stan::math::to_vector;
+  using stan::math::var;
+  using stan::math::test::flag_test;
+  int dim_theta = 500;
+  int n_observations = 500;
+  auto x1 = stan::test::laplace::x1;
+  auto x2 = stan::test::laplace::x2;
+  auto y = stan::test::laplace::y;
+
+  int dim_x = 2;
+  std::vector<Eigen::VectorXd> x(dim_theta);
+  for (int i = 0; i < dim_theta; i++) {
+    Eigen::VectorXd coordinate(dim_x);
+    coordinate << x1[i], x2[i];
+    x[i] = coordinate;
+  }
+  std::vector<int> n_samples = stan::math::rep_array(1, dim_theta);
+  Eigen::VectorXd theta_0 = Eigen::VectorXd::Zero(dim_theta);
+  std::vector<double> delta;
+  std::vector<int> delta_int;
+  int dim_phi = 2;
+  double tol = 8e-5;
+  Eigen::Matrix<double, Eigen::Dynamic, 1> phi_dbl(dim_phi);
+  phi_dbl << 1.6, 1;
+  using stan::math::test::sqr_exp_kernel_functor;
+  double target = laplace_marginal_bernoulli_logit_lpmf(
+      y, n_samples, theta_0, sqr_exp_kernel_functor{},
+      std::forward_as_tuple(x, phi_dbl(0), phi_dbl(1)), nullptr);
+  // Benchmark against gpstuff.
+  EXPECT_NEAR(-195.368, target, tol);
+  constexpr double tolerance = 1e-8;
+  constexpr int max_num_steps = 1000;
+  // solver_num, max_steps_line_search, hessian_block_size
+  using stan::math::test::laplace_issue;
+  constexpr std::array known_issues{
+      laplace_issue{1, 1, 1}, laplace_issue{1, 2, 1}, laplace_issue{1, 2, 3}};
+  stan::math::test::run_solver_grid(
+      [&](int solver_num, int hessian_block_size, int max_steps_line_search,
+          auto&& theta_0) {
+        auto f = [&](auto&& alpha, auto&& rho) {
+          return laplace_marginal_tol_bernoulli_logit_lpmf(
+              y, n_samples, theta_0, sqr_exp_kernel_functor{},
+              std::forward_as_tuple(x, alpha, rho), tolerance, max_num_steps,
+              hessian_block_size, solver_num, max_steps_line_search, nullptr);
+        };
+        stan::test::ad_tolerances tols;
+        if (flag_test(known_issues, solver_num, max_steps_line_search,
+                      hessian_block_size)) {
+          tols.gradient_grad_ = 0.005;
+        }
+        stan::test::expect_ad<true>(tols, f, phi_dbl[0], phi_dbl[1]);
+      },
+      theta_0);
+}
diff --git a/test/unit/math/laplace/laplace_marginal_lpdf_test.cpp b/test/unit/math/laplace/laplace_marginal_lpdf_test.cpp
new file mode 100644
index 00000000000..546c360ca34
--- /dev/null
+++ b/test/unit/math/laplace/laplace_marginal_lpdf_test.cpp
@@ -0,0 +1,747 @@
+#include <test/unit/math/test_ad.hpp>
+#include <stan/math.hpp>
+#include <stan/math/mix.hpp>
+#include <test/unit/math/laplace/laplace_utility.hpp>
+#include <test/unit/math/rev/fun/util.hpp>
+#include <stan/math/prim/fun/lgamma.hpp>
+#include <test/unit/math/laplace/aki_synth_data/x1.hpp>
+#include <test/unit/math/laplace/motorcycle_gp/x_vec.hpp>
+#include <gtest/gtest.h>
+#include <iostream>
+#include <istream>
+#include <fstream>
+#include <vector>
+
+struct poisson_log_likelihood2 {
+  template <typename Theta>
+  auto operator()(const Theta& theta, const std::vector<int>& delta_int,
+                  std::ostream* pstream) const {
+    return stan::math::poisson_log_lpmf(delta_int, theta);
+  }
+};
+
+template <typename T1, typename T2>
+auto in_throw_list(T1&& test_values, T2&& test_arr) {
+  for (auto&& x : test_values) {
+    if (x[0] == test_arr[0] && x[1] == test_arr[1] && x[2] == test_arr[2]) {
+      return true;
+    }
+  }
+  return false;
+}
+
+struct poisson_log_likelihood_tuple {
+  template <typename Theta, typename Eta>
+  auto operator()(const Theta& theta, const std::vector<int>& delta_int,
+                  Eta&& eta, std::ostream* pstream) const {
+    return stan::math::poisson_log_lpmf(delta_int, theta) + std::get<0>(eta)
+           + std::get<1>(eta);
+  }
+};
+
+struct poisson_log_likelihood_tuple_expanded {
+  template <typename Theta, typename Eta, typename Eta1, typename Eta2>
+  auto operator()(const Theta& theta, const std::vector<int>& delta_int,
+                  Eta&& eta, Eta1&& eta1, Eta2&& eta2,
+                  std::ostream* pstream) const {
+    return stan::math::poisson_log_lpmf(delta_int, theta) + std::get<0>(eta)
+           + std::get<1>(eta) + stan::math::sum(eta1) + stan::math::sum(eta2);
+  }
+};
+
+TEST(laplace, poisson_log_phi_dim_2_tuple_extended) {
+  using stan::math::laplace_marginal;
+  using stan::math::laplace_marginal_tol;
+  using stan::math::to_vector;
+  using stan::math::value_of;
+  using stan::math::var;
+  // logger->current_test_name_ = "poisson_log_phi_dim_2";
+  int dim_phi = 2;
+  Eigen::Matrix<double, Eigen::Dynamic, 1> phi_dbl(dim_phi);
+  phi_dbl << 1.6, 0.45;
+
+  int dim_theta = 2;
+  Eigen::VectorXd theta_0(dim_theta);
+  theta_0 << 0, 0;
+
+  int dim_x = 2;
+  std::vector<Eigen::VectorXd> x(dim_theta);
+  Eigen::VectorXd x_0{{0.05100797, 0.16086164}};
+  Eigen::VectorXd x_1{{-0.59823393, 0.98701425}};
+  x[0] = x_0;
+  x[1] = x_1;
+
+  Eigen::VectorXd y_dummy;
+
+  std::vector<int> n_samples = {1, 1};
+  std::vector<int> sums = {1, 0};
+
+  constexpr double tolerance = 1e-12;
+  constexpr int max_num_steps = 100;
+  using stan::is_var_v;
+  using stan::scalar_type_t;
+  using stan::math::test::laplace_issue;
+  constexpr std::array known_issues{laplace_issue{0, 0, 0}};
+  stan::test::ad_tolerances tols;
+  tols.gradient_grad_ = 1e-1;
+  stan::math::test::run_solver_grid(
+      [&](int solver_num, int hessian_block_size, int max_steps_line_search,
+          auto&& theta_0) {
+        auto f_ll = [&](auto&& eta1, auto&& eta2, auto&& eta3) {
+          auto eta1_tuple = std::make_tuple(eta1(0), eta1(1));
+          return laplace_marginal_tol<false>(
+              poisson_log_likelihood_tuple_expanded{},
+              std::forward_as_tuple(sums, eta1_tuple, eta2, eta3), theta_0,
+              stan::math::test::squared_kernel_functor{},
+              std::forward_as_tuple(x, std::make_tuple(phi_dbl(0), phi_dbl(1))),
+              tolerance, max_num_steps, hessian_block_size, solver_num,
+              max_steps_line_search, nullptr);
+        };
+        Eigen::VectorXd test1(phi_dbl);
+        std::vector<double> test2 = {1.0, 1.0};
+        stan::test::expect_ad<true>(tols, f_ll, phi_dbl, test1, test2);
+      },
+      theta_0);
+}
+
+TEST(laplace, poisson_log_phi_dim_2_tuple) {
+  using stan::math::laplace_marginal;
+  using stan::math::laplace_marginal_tol;
+  using stan::math::to_vector;
+  using stan::math::value_of;
+  using stan::math::var;
+  // logger->current_test_name_ = "poisson_log_phi_dim_2";
+  int dim_phi = 2;
+  Eigen::Matrix<double, Eigen::Dynamic, 1> phi_dbl(dim_phi);
+  phi_dbl << 1.6, 0.45;
+
+  int dim_theta = 2;
+  Eigen::VectorXd theta_0(dim_theta);
+  theta_0 << 0, 0;
+
+  int dim_x = 2;
+  std::vector<Eigen::VectorXd> x(dim_theta);
+  Eigen::VectorXd x_0{{0.05100797, 0.16086164}};
+  Eigen::VectorXd x_1{{-0.59823393, 0.98701425}};
+  x[0] = x_0;
+  x[1] = x_1;
+
+  Eigen::VectorXd y_dummy;
+
+  std::vector<int> n_samples = {1, 1};
+  std::vector<int> sums = {1, 0};
+
+  constexpr double tolerance = 1e-12;
+  constexpr int max_num_steps = 100;
+  using stan::is_var_v;
+  using stan::scalar_type_t;
+  using stan::math::test::laplace_issue;
+  constexpr std::array known_issues{laplace_issue{0, 0, 0}};
+  stan::test::ad_tolerances tols;
+  tols.gradient_grad_ = 1e-1;
+  stan::math::test::run_solver_grid(
+      [&](int solver_num, int hessian_block_size, int max_steps_line_search,
+          auto&& theta_0) {
+        auto f_covar = [&](auto&& x_v, auto&& alpha, auto&& rho) {
+          return laplace_marginal_tol<false>(
+              poisson_log_likelihood2{}, std::forward_as_tuple(sums), theta_0,
+              stan::math::test::squared_kernel_functor{},
+              std::forward_as_tuple(x_v, std::make_tuple(alpha, rho)),
+              tolerance, max_num_steps, hessian_block_size, solver_num,
+              max_steps_line_search, nullptr);
+        };
+        stan::test::expect_ad<true>(tols, f_covar, x, phi_dbl[0], phi_dbl[1]);
+      },
+      theta_0);
+  stan::math::test::run_solver_grid(
+      [&](int solver_num, int hessian_block_size, int max_steps_line_search,
+          auto&& theta_0) {
+        auto f_ll = [&](auto&& alpha_rho, auto&& eta1, auto&& eta2) {
+          return laplace_marginal_tol<false>(
+              poisson_log_likelihood_tuple{},
+              std::forward_as_tuple(sums, std::make_tuple(eta1, eta2)), theta_0,
+              stan::math::test::squared_kernel_functor{},
+              std::forward_as_tuple(
+                  x, std::make_tuple(alpha_rho(0), alpha_rho(1))),
+              tolerance, max_num_steps, hessian_block_size, solver_num,
+              max_steps_line_search, nullptr);
+        };
+        auto test1 = 1.0;
+        auto test2 = 1.0;
+        stan::test::expect_ad<true>(tols, f_ll, phi_dbl, test1, test2);
+      },
+      theta_0);
+}
+
+struct poisson_log_likelihood_array_tuple {
+  template <typename Theta, typename Eta>
+  auto operator()(const Theta& theta, const std::vector<int>& delta_int,
+                  Eta&& eta, std::ostream* pstream) const {
+    return stan::math::poisson_log_lpmf(delta_int, theta) + std::get<0>(eta[0])
+           + std::get<1>(eta[0]);
+  }
+};
+
+TEST(laplace, poisson_log_phi_dim_2_array_tuple) {
+  using stan::math::laplace_marginal;
+  using stan::math::laplace_marginal_tol;
+  using stan::math::to_vector;
+  using stan::math::value_of;
+  using stan::math::var;
+  // logger->current_test_name_ = "poisson_log_phi_dim_2";
+  int dim_phi = 2;
+  Eigen::Matrix<double, Eigen::Dynamic, 1> phi_dbl(dim_phi);
+  phi_dbl << 1.6, 0.45;
+
+  int dim_theta = 2;
+  Eigen::VectorXd theta_0(dim_theta);
+  theta_0 << 0, 0;
+
+  int dim_x = 2;
+  std::vector<Eigen::VectorXd> x(dim_theta);
+  Eigen::VectorXd x_0{{0.05100797, 0.16086164}};
+  Eigen::VectorXd x_1{{-0.59823393, 0.98701425}};
+  x[0] = x_0;
+  x[1] = x_1;
+
+  Eigen::VectorXd y_dummy;
+
+  std::vector<int> n_samples = {1, 1};
+  std::vector<int> sums = {1, 0};
+
+  constexpr double tolerance = 1e-12;
+  constexpr int max_num_steps = 100;
+  using stan::is_var_v;
+  using stan::scalar_type_t;
+  using stan::math::test::laplace_issue;
+  constexpr std::array known_issues{laplace_issue{0, 0, 0}};
+  stan::test::ad_tolerances tols;
+  tols.gradient_grad_ = 1e-1;
+  stan::math::test::run_solver_grid(
+      [&](int solver_num, int hessian_block_size, int max_steps_line_search,
+          auto&& theta_0) {
+        auto f_ll = [&](auto&& alpha_rho, auto&& eta1, auto&& eta2) {
+          std::vector<std::tuple<std::decay_t<decltype(eta1)>,
+                                 std::decay_t<decltype(eta2)>>>
+              eta_tuple;
+          eta_tuple.push_back(std::make_tuple(eta1, eta2));
+          using alpha_scalar = stan::scalar_type_t<decltype(alpha_rho)>;
+          std::vector<std::tuple<alpha_scalar, alpha_scalar>> alpha_tuple;
+          alpha_tuple.push_back(std::make_tuple(alpha_rho(0), alpha_rho(1)));
+          return laplace_marginal_tol<false>(
+              poisson_log_likelihood_array_tuple{},
+              std::forward_as_tuple(sums, eta_tuple), theta_0,
+              stan::math::test::squared_kernel_functor{},
+              std::forward_as_tuple(x, alpha_tuple), tolerance, max_num_steps,
+              hessian_block_size, solver_num, max_steps_line_search, nullptr);
+        };
+        auto test1 = 1.0;
+        auto test2 = 1.0;
+        stan::test::expect_ad<true>(tols, f_ll, phi_dbl, test1, test2);
+      },
+      theta_0);
+}
+
+TEST(laplace, poisson_log_phi_dim_2) {
+  using stan::math::laplace_marginal;
+  using stan::math::laplace_marginal_tol;
+  using stan::math::to_vector;
+  using stan::math::value_of;
+  using stan::math::var;
+  // logger->current_test_name_ = "poisson_log_phi_dim_2";
+  int dim_phi = 2;
+  Eigen::Matrix<double, Eigen::Dynamic, 1> phi_dbl(dim_phi);
+  phi_dbl << 1.6, 0.45;
+
+  int dim_theta = 2;
+  Eigen::VectorXd theta_0(dim_theta);
+  theta_0 << 0, 0;
+
+  int dim_x = 2;
+  std::vector<Eigen::VectorXd> x(dim_theta);
+  Eigen::VectorXd x_0{{0.05100797, 0.16086164}};
+  Eigen::VectorXd x_1{{-0.59823393, 0.98701425}};
+  x[0] = x_0;
+  x[1] = x_1;
+
+  Eigen::VectorXd y_dummy;
+
+  std::vector<int> n_samples = {1, 1};
+  std::vector<int> sums = {1, 0};
+
+  double target = laplace_marginal<false>(
+      poisson_log_likelihood2{}, std::forward_as_tuple(sums), theta_0,
+      stan::math::test::squared_kernel_functor{},
+      std::forward_as_tuple(x, phi_dbl(0), phi_dbl(1)), nullptr);
+
+  // TODO(Charles): benchmark target against gpstuff.
+  // Expected: -2.53056
+  double tol = 1e-4;
+  EXPECT_NEAR(-2.53056, value_of(target), tol);
+
+  // Test with optional arguments
+  {
+    constexpr double tolerance = 1e-8;
+    constexpr int max_num_steps = 100;
+    constexpr int hessian_block_size = 1;
+    constexpr int solver = 1;
+    constexpr int max_steps_line_search = 10;
+
+    target = laplace_marginal_tol<false>(
+        poisson_log_likelihood2{}, std::forward_as_tuple(sums), theta_0,
+        stan::math::test::squared_kernel_functor{},
+        std::forward_as_tuple(x, phi_dbl(0), phi_dbl(1)), tolerance,
+        max_num_steps, hessian_block_size, solver, max_steps_line_search,
+        nullptr);
+    EXPECT_NEAR(-2.53056, value_of(target), tol);
+  }
+
+  constexpr double tolerance = 1e-12;
+  constexpr int max_num_steps = 100;
+  using stan::is_var_v;
+  using stan::scalar_type_t;
+  using stan::math::test::laplace_issue;
+  constexpr std::array known_issues{laplace_issue{0, 0, 0}};
+  stan::test::ad_tolerances tols;
+  tols.gradient_grad_ = 1e-1;
+  stan::math::test::run_solver_grid(
+      [&](int solver_num, int hessian_block_size, int max_steps_line_search,
+          auto&& theta_0) {
+        auto f = [&](auto&& x_v, auto&& alpha, auto&& rho) {
+          return laplace_marginal_tol<false>(
+              poisson_log_likelihood2{}, std::forward_as_tuple(sums), theta_0,
+              stan::math::test::squared_kernel_functor{},
+              std::forward_as_tuple(x_v, alpha, rho), tolerance, max_num_steps,
+              hessian_block_size, solver_num, max_steps_line_search, nullptr);
+        };
+        stan::test::expect_ad<true>(tols, f, x, phi_dbl[0], phi_dbl[1]);
+      },
+      theta_0);
+}
+
+struct poisson_log_exposure_likelihood {
+  template <typename Theta, typename YEVec>
+  auto operator()(const Theta& theta, YEVec&& ye,
+                  const std::vector<int>& delta_int,
+                  std::ostream* pstream) const {
+    return stan::math::poisson_log_lpmf(
+        delta_int, stan::math::add(theta, stan::math::log(ye)));
+  }
+};
+
+TEST_F(laplace_disease_map_test, laplace_marginal) {
+  using stan::math::laplace_marginal;
+  using stan::math::laplace_marginal_poisson_log_lpmf;
+  using stan::math::laplace_marginal_tol;
+  using stan::math::value_of;
+  using stan::math::var;
+
+  {
+    double marginal_density = laplace_marginal<false>(
+        poisson_log_exposure_likelihood{}, std::forward_as_tuple(ye, y),
+        theta_0, stan::math::test::sqr_exp_kernel_functor{},
+        std::forward_as_tuple(x, phi_dbl(0), phi_dbl(1)), nullptr);
+
+    double tol = 6e-4;
+    // Benchmark from GPStuff.
+    EXPECT_NEAR(-2866.88, value_of(marginal_density), tol);
+  }
+  constexpr double tolerance = 1e-8;
+  constexpr int max_num_steps = 100;
+  stan::math::test::run_solver_grid(
+      [&](int solver_num, int hessian_block_size, int max_steps_line_search,
+          auto&& theta_0) {
+        auto f = [&](auto&& alpha, auto&& rho) {
+          return laplace_marginal_tol<false>(
+              poisson_log_exposure_likelihood{}, std::forward_as_tuple(ye, y),
+              theta_0, stan::math::test::sqr_exp_kernel_functor{},
+              std::forward_as_tuple(x, alpha, rho), tolerance, max_num_steps,
+              hessian_block_size, solver_num, max_steps_line_search, nullptr);
+        };
+        stan::test::expect_ad<true>(f, phi_dbl[0], phi_dbl[1]);
+      },
+      theta_0);
+}
+
+struct bernoulli_logit_likelihood {
+  template <typename Theta>
+  auto operator()(const Theta& theta, const std::vector<int>& delta_int,
+                  std::ostream* pstream) const {
+    return stan::math::bernoulli_logit_lpmf(delta_int, theta);
+  }
+};
+
+TEST(laplace, bernoulli_logit_phi_dim500) {
+  using stan::math::laplace_marginal;
+  using stan::math::laplace_marginal_tol;
+  using stan::math::to_vector;
+  // logger->current_test_name_ = "bernoulli_logit_phi_dim500";
+  int dim_theta = 500;
+  int n_observations = 500;
+  auto x1 = stan::test::laplace::x1;
+  auto x2 = stan::test::laplace::x2;
+  auto y = stan::test::laplace::y;
+
+  int dim_x = 2;
+  std::vector<Eigen::VectorXd> x(dim_theta);
+  for (int i = 0; i < dim_theta; i++) {
+    Eigen::VectorXd coordinate(dim_x);
+    coordinate << x1[i], x2[i];
+    x[i] = coordinate;
+  }
+  Eigen::VectorXd theta_0 = Eigen::VectorXd::Zero(dim_theta);
+  Eigen::VectorXd delta_L;
+  std::vector<double> delta;
+  int dim_phi = 2;
+  Eigen::Matrix<double, Eigen::Dynamic, 1> phi_dbl(dim_phi);
+  phi_dbl << 1.6, 1;
+
+  stan::math::test::sqr_exp_kernel_functor K;
+  double target = laplace_marginal<false>(
+      bernoulli_logit_likelihood{}, std::forward_as_tuple(y), theta_0,
+      stan::math::test::sqr_exp_kernel_functor{},
+      std::forward_as_tuple(x, phi_dbl(0), phi_dbl(1)), nullptr);
+
+  double tol = 8e-5;
+  // Benchmark against gpstuff.
+  EXPECT_NEAR(-195.368, target, tol);
+  // All fail for ad check with relative tolerance ~0.002
+  constexpr double tolerance = 1e-8;
+  constexpr int max_num_steps = 100;
+  stan::test::ad_tolerances tols;
+  tols.gradient_grad_ = 1e-3;
+  stan::math::test::run_solver_grid(
+      [&](int solver_num, int hessian_block_size, int max_steps_line_search,
+          auto&& theta_0) {
+        auto f = [&](auto&& alpha, auto&& rho) {
+          return laplace_marginal_tol<false>(
+              bernoulli_logit_likelihood{}, std::forward_as_tuple(y), theta_0,
+              stan::math::test::sqr_exp_kernel_functor{},
+              std::forward_as_tuple(x, alpha, rho), tolerance, max_num_steps,
+              hessian_block_size, solver_num, max_steps_line_search, nullptr);
+        };
+        stan::test::expect_ad<true>(tols, f, phi_dbl[0], phi_dbl[1]);
+      },
+      theta_0);
+}
+
+struct covariance_motorcycle_functor {
+  template <typename TX, typename LengthF, typename LengthG, typename SigmaF,
+            typename SigmaG>
+  auto operator()(const TX& x, const LengthF& length_scale_f,
+                  const LengthG& length_scale_g, const SigmaF& sigma_f,
+                  const SigmaG& sigma_g, const int n_obs,
+                  std::ostream* msgs = nullptr) const {
+    using Eigen::Matrix;
+    using stan::math::gp_exp_quad_cov;
+    using scalar_t = stan::return_type_t<LengthF, LengthG, SigmaF, SigmaG>;
+
+    double jitter = 1e-12;
+    Matrix<scalar_t, -1, -1> kernel_f
+        = gp_exp_quad_cov(x, sigma_f, length_scale_f);
+    Matrix<scalar_t, -1, -1> kernel_g
+        = gp_exp_quad_cov(x, sigma_g, length_scale_g);
+
+    Matrix<scalar_t, -1, -1> kernel_all
+        = Eigen::MatrixXd::Zero(2 * n_obs, 2 * n_obs);
+    for (Eigen::Index i = 0; i < n_obs; i++) {
+      for (Eigen::Index j = 0; j <= i; j++) {
+        kernel_all(2 * i, 2 * j) = kernel_f(i, j);
+        kernel_all(2 * i + 1, 2 * j + 1) = kernel_g(i, j);
+        if (i != j) {
+          kernel_all(2 * j, 2 * i) = kernel_all(2 * i, 2 * j);
+          kernel_all(2 * j + 1, 2 * i + 1) = kernel_all(2 * i + 1, 2 * j + 1);
+        }
+      }
+    }
+    for (Eigen::Index i = 0; i < 2 * n_obs; i++) {
+      kernel_all(i, i) += jitter;
+    }
+    return kernel_all;
+  }
+};
+
+struct normal_likelihood {
+  template <typename Theta, typename YVec>
+  auto operator()(const Theta& theta, const YVec& y, const int delta_int,
+                  std::ostream* pstream) const {
+    int n_obs = delta_int;
+    Eigen::Matrix<stan::return_type_t<Theta>, -1, 1> mu(n_obs);
+    Eigen::Matrix<stan::return_type_t<Theta>, -1, 1> sigma(n_obs);
+    for (Eigen::Index i = 0; i < n_obs; i++) {
+      mu(i) = theta(2 * i);
+      // TODO(Charles): Theta can be a large negative value so sigma can be 0
+      sigma(i) = exp(0.5 * theta(2 * i + 1)) + 1e-12;
+    }
+    try {
+      return stan::math::normal_lpdf(y, mu, sigma);
+    } catch (const std::domain_error& e) {
+      std::cout << "Error in normal_lpdf: " << e.what() << std::endl;
+      std::cout << "theta: \n" << theta.transpose() << std::endl;
+      std::cout << "y: \n" << y.transpose() << std::endl;
+      std::cout << "mu: \n" << mu.transpose() << std::endl;
+      std::cout << "sigma: \n" << sigma.transpose() << std::endl;
+      return stan::math::normal_lpdf(y, mu, sigma);
+    }
+  }
+};
+
+class laplace_motorcyle_gp_test : public ::testing::Test {
+ protected:
+  void SetUp() override {
+    using stan::math::gp_exp_quad_cov;
+    using stan::math::value_of;
+    Eigen::MatrixXd K_plus_I
+        = gp_exp_quad_cov(x, value_of(sigma_f), value_of(length_scale_f))
+          + Eigen::MatrixXd::Identity(n_obs, n_obs);
+    Eigen::VectorXd mu_hat = K_plus_I.colPivHouseholderQr().solve(y);
+    // Remark: finds optimal point with or without informed initial guess.
+    for (int i = 0; i < n_obs; i++) {
+      theta0(2 * i) = mu_hat(i);  // 0
+      theta0(2 * i + 1) = 0.1;
+    }
+  }
+
+  int n_obs{133};
+  int dim_phi{4};
+  std::vector<double> x{stan::test::laplace::moto::x};
+  Eigen::VectorXd y{stan::test::laplace::moto::y};
+
+  double length_scale_f{0.3};
+  double length_scale_g{0.5};
+  double sigma_f{0.25};
+  double sigma_g{0.25};
+  std::vector<int> delta_int{n_obs};
+  Eigen::VectorXd theta0{Eigen::VectorXd::Zero(2 * n_obs)};
+  Eigen::Matrix<double, -1, 1> eta{{1.0}};
+  Eigen::VectorXd eta_dbl{{1.0}};
+  int solver{2};
+  double eps{1e-7};
+  Eigen::VectorXd phi_dbl{{length_scale_f, length_scale_g, sigma_f, sigma_g}};
+};
+
+TEST_F(laplace_motorcyle_gp_test, gp_motorcycle) {
+  // logger->current_test_name_ = "gp_motorcycle";
+  using stan::math::laplace_marginal;
+  using stan::math::laplace_marginal_tol;
+  using stan::math::value_of;
+
+  {
+    constexpr double tolerance = 1e-08;
+    constexpr int max_num_steps = 100;
+    constexpr int hessian_block_size = 2;
+    solver = 2;
+    constexpr int do_line_search = 1;
+    constexpr int max_steps_line_search = 10;
+
+    double target = laplace_marginal_tol<false>(
+        normal_likelihood{}, std::forward_as_tuple(y, delta_int[0]), theta0,
+        covariance_motorcycle_functor{},
+        std::forward_as_tuple(x, phi_dbl(0), phi_dbl(1), phi_dbl(2), phi_dbl(3),
+                              n_obs),
+        tolerance, max_num_steps, hessian_block_size, solver,
+        max_steps_line_search, nullptr);
+  }
+
+  // TODO(Steve): benchmark this result against GPStuff.
+  constexpr double tolerance = 1e-6;
+  constexpr int max_num_steps = 1000;
+  auto phi_0 = phi_dbl(0);
+  auto phi_1 = phi_dbl(1);
+  Eigen::VectorXd phi_rest = phi_dbl.tail(2);
+  Eigen::VectorXd phi_01{{phi_0, phi_1}};
+  using stan::math::test::laplace_issue;
+  using stan::math::test::LaplaceFailures;
+  constexpr std::array known_issues{
+      std::pair(laplace_issue{1, 0, 1}, LaplaceFailures::HessianFailure),
+      std::pair(laplace_issue{1, 100, 1}, LaplaceFailures::HessianFailure),
+      std::pair(laplace_issue{1, 200, 1}, LaplaceFailures::HessianFailure),
+      std::pair(laplace_issue{1, 300, 1}, LaplaceFailures::HessianFailure),
+      std::pair(laplace_issue{1, 400, 1}, LaplaceFailures::HessianFailure),
+      std::pair(laplace_issue{1, 500, 1}, LaplaceFailures::HessianFailure),
+      std::pair(laplace_issue{1, 0, 2}, LaplaceFailures::SqrtDNE),
+      std::pair(laplace_issue{1, 100, 2}, LaplaceFailures::SqrtDNE),
+      std::pair(laplace_issue{1, 200, 2}, LaplaceFailures::SqrtDNE),
+      std::pair(laplace_issue{1, 300, 2}, LaplaceFailures::SqrtDNE),
+      std::pair(laplace_issue{1, 400, 2}, LaplaceFailures::SqrtDNE),
+      std::pair(laplace_issue{1, 500, 2}, LaplaceFailures::SqrtDNE),
+      std::pair(laplace_issue{1, 0, 3}, LaplaceFailures::SqrtDNE),
+      std::pair(laplace_issue{1, 100, 3}, LaplaceFailures::SqrtDNE),
+      std::pair(laplace_issue{1, 200, 3}, LaplaceFailures::SqrtDNE),
+      std::pair(laplace_issue{1, 300, 3}, LaplaceFailures::SqrtDNE),
+      std::pair(laplace_issue{1, 400, 3}, LaplaceFailures::SqrtDNE),
+      std::pair(laplace_issue{1, 500, 3}, LaplaceFailures::SqrtDNE),
+      std::pair(laplace_issue{1, 0, 4}, LaplaceFailures::SqrtDNE),
+      std::pair(laplace_issue{1, 100, 4}, LaplaceFailures::SqrtDNE),
+      std::pair(laplace_issue{1, 200, 4}, LaplaceFailures::SqrtDNE),
+      std::pair(laplace_issue{1, 300, 4}, LaplaceFailures::SqrtDNE),
+      std::pair(laplace_issue{1, 400, 4}, LaplaceFailures::SqrtDNE),
+      std::pair(laplace_issue{1, 500, 4}, LaplaceFailures::SqrtDNE),
+      std::pair(laplace_issue{2, 0, 1}, LaplaceFailures::NaNTheta),
+      std::pair(laplace_issue{2, 100, 1}, LaplaceFailures::NaNTheta),
+      std::pair(laplace_issue{2, 200, 1}, LaplaceFailures::NaNTheta),
+      std::pair(laplace_issue{2, 300, 1}, LaplaceFailures::NaNTheta),
+      std::pair(laplace_issue{2, 400, 1}, LaplaceFailures::NaNTheta),
+      std::pair(laplace_issue{2, 500, 1}, LaplaceFailures::NaNTheta),
+      std::pair(laplace_issue{2, 0, 3}, LaplaceFailures::NaNTheta),
+      std::pair(laplace_issue{2, 100, 3}, LaplaceFailures::NaNTheta),
+      std::pair(laplace_issue{2, 200, 3}, LaplaceFailures::NaNTheta),
+      std::pair(laplace_issue{2, 300, 3}, LaplaceFailures::NaNTheta),
+      std::pair(laplace_issue{2, 400, 3}, LaplaceFailures::NaNTheta),
+      std::pair(laplace_issue{2, 500, 3}, LaplaceFailures::NaNTheta),
+      std::pair(laplace_issue{2, 0, 4}, LaplaceFailures::IterExceeded),
+      std::pair(laplace_issue{2, 100, 4}, LaplaceFailures::IterExceeded),
+      std::pair(laplace_issue{2, 200, 4}, LaplaceFailures::IterExceeded),
+      std::pair(laplace_issue{2, 300, 4}, LaplaceFailures::IterExceeded),
+      std::pair(laplace_issue{2, 400, 4}, LaplaceFailures::IterExceeded),
+      std::pair(laplace_issue{2, 500, 4}, LaplaceFailures::IterExceeded),
+      std::pair(laplace_issue{3, 0, 1}, LaplaceFailures::NaNTheta),
+      std::pair(laplace_issue{3, 100, 1}, LaplaceFailures::NaNTheta),
+      std::pair(laplace_issue{3, 200, 1}, LaplaceFailures::NaNTheta),
+      std::pair(laplace_issue{3, 300, 1}, LaplaceFailures::NaNTheta),
+      std::pair(laplace_issue{3, 400, 1}, LaplaceFailures::NaNTheta),
+      std::pair(laplace_issue{3, 500, 1}, LaplaceFailures::NaNTheta),
+      std::pair(laplace_issue{3, 0, 3}, LaplaceFailures::NaNTheta),
+      std::pair(laplace_issue{3, 100, 3}, LaplaceFailures::NaNTheta),
+      std::pair(laplace_issue{3, 200, 3}, LaplaceFailures::NaNTheta),
+      std::pair(laplace_issue{3, 300, 3}, LaplaceFailures::NaNTheta),
+      std::pair(laplace_issue{3, 400, 3}, LaplaceFailures::NaNTheta),
+      std::pair(laplace_issue{3, 500, 3}, LaplaceFailures::NaNTheta),
+      std::pair(laplace_issue{3, 0, 4}, LaplaceFailures::IterExceeded),
+      std::pair(laplace_issue{3, 100, 4}, LaplaceFailures::IterExceeded),
+      std::pair(laplace_issue{3, 200, 4}, LaplaceFailures::IterExceeded),
+      std::pair(laplace_issue{3, 300, 4}, LaplaceFailures::IterExceeded),
+      std::pair(laplace_issue{3, 400, 4}, LaplaceFailures::IterExceeded),
+      std::pair(laplace_issue{3, 500, 4}, LaplaceFailures::IterExceeded)};
+
+  /**
+   * Note: This test is designed to check the error behavior
+   *  of the laplace_marginal_tol function. We do not force
+   *  a function to fail because some of these errors can be machine
+   *  specific. So for cases we know there can be a test failure for a
+   *  machine we call the function in a try block. if it *does* fail,
+   *  we expect it to be the associated error found in the known_issues array.
+   *  If we have not seen this parameter combination fail before, we run the
+   *  standard AD testing procedure.
+   */
+  for (int solver_num = 1; solver_num < 4; solver_num++) {
+    for (int max_steps_line_search = 0; max_steps_line_search <= 20;
+         max_steps_line_search += 10) {
+      for (int hessian_block_size = 1; hessian_block_size < 3;
+           hessian_block_size++) {
+        // logger->update_laplace_info(solver_num, hessian_block_size,
+        // max_steps_line_search);
+        if (theta0.size() % hessian_block_size != 0) {
+          std::cerr << "[          ] [ INFO ]"
+                    << " Skipping test for hessian of size " << theta0.size()
+                    << " with hessian block size of " << hessian_block_size
+                    << std::endl;
+          continue;
+        }
+        auto f = [&](auto&& y_v, auto&& phi_01_v, auto&& phi_rest_v) {
+          return laplace_marginal_tol<false>(
+              normal_likelihood{}, std::forward_as_tuple(y_v, delta_int[0]),
+              theta0, covariance_motorcycle_functor{},
+              std::forward_as_tuple(x, phi_01_v(0), phi_01_v(0), phi_rest_v(0),
+                                    phi_rest_v(1), n_obs),
+              tolerance, max_num_steps, hessian_block_size, solver_num,
+              max_steps_line_search, nullptr);
+        };
+        stan::test::ad_tolerances tols;
+        tols.gradient_grad_ = 1e-1;
+        using stan::math::test::flag_test;
+        auto flag_val = flag_test(known_issues, solver_num,
+                                  max_steps_line_search, hessian_block_size);
+        if (flag_val != LaplaceFailures::None) {
+          try {
+            auto ret = f(y, phi_01, phi_rest);
+          } catch (const std::domain_error& e) {
+            using stan::math::test::err_to_laplace_failure;
+            LaplaceFailures err_val = err_to_laplace_failure(e);
+            EXPECT_EQ(err_val, flag_val)
+                << "Error: " << e.what()
+                << "\n\terr_val: " << to_string(err_val)
+                << "\n\tflag_val: " << to_string(flag_val)
+                << "\n\tsolver_num: " << solver_num
+                << "\n\tmax_steps_line_search: " << max_steps_line_search
+                << "\n\thessian_block_size: " << hessian_block_size;
+          }
+          stan::math::recover_memory();
+        } else {
+          try {
+            stan::test::expect_ad<true>(tols, f, y, phi_01, phi_rest);
+          } catch (const std::domain_error e) {
+            ADD_FAILURE() << "Exception: " << e.what()
+                          << "\n\tsolver_num: " << solver_num
+                          << "\n\tmax_steps_line_search: "
+                          << max_steps_line_search
+                          << "\n\thessian_block_size: " << hessian_block_size
+                          << std::endl;
+            stan::math::recover_memory();
+          }
+        }
+      }
+    }
+  }
+}
+
+struct normal_likelihood2 {
+  template <typename Theta, typename Eta>
+  auto operator()(const Theta& theta, const Eigen::VectorXd& y,
+                  const std::vector<int>& delta_int, const Eta& eta,
+                  std::ostream* pstream) const {
+    using stan::math::multiply;
+    int n_obs = delta_int[0];
+    Eigen::Matrix<stan::return_type_t<Theta>, -1, 1> mu(n_obs);
+    Eigen::Matrix<stan::return_type_t<Theta>, -1, 1> sigma(n_obs);
+    auto sigma_global = eta(0);
+    for (int i = 0; i < n_obs; i++) {
+      mu(i) = theta(2 * i);
+      sigma(i) = stan::math::exp(
+          multiply(0.5, theta(2 * i + 1)));  // * sigma_global;
+    }
+    // return stan::math::normal_lpdf(y, mu, sigma);
+    return stan::math::normal_lpdf(y, mu, multiply(sigma_global, sigma));
+  }
+};
+
+TEST_F(laplace_motorcyle_gp_test, gp_motorcycle2) {
+  using stan::math::laplace_marginal;
+  using stan::math::laplace_marginal_tol;
+  using stan::math::value_of;
+  {
+    double tolerance = 1e-12;
+    constexpr int max_num_steps = 300;
+    int hessian_block_size = 2;
+    solver = 3;
+    int do_line_search = 1;
+    int max_steps_line_search = 10;
+    double target = laplace_marginal_tol<false>(
+        normal_likelihood2{}, std::forward_as_tuple(y, delta_int, eta), theta0,
+        covariance_motorcycle_functor{},
+        std::forward_as_tuple(x, phi_dbl(0), phi_dbl(1), phi_dbl(2), phi_dbl(3),
+                              n_obs),
+        tolerance, max_num_steps, hessian_block_size, solver,
+        max_steps_line_search, nullptr);
+  }
+  // TODO(Charles): benchmark this result against GPStuff.
+  constexpr double tolerance = 1e-8;
+  constexpr int max_num_steps = 100;
+  stan::test::ad_tolerances tols;
+  tols.gradient_grad_ = 1e-3;
+
+  stan::math::test::run_solver_grid(
+      [&](int solver_num, int hessian_block_size, int max_steps_line_search,
+          auto&& theta_0) {
+        auto f = [&](auto&& eta_v, auto&& phi_0, auto&& phi) {
+          return laplace_marginal_tol<false>(
+              normal_likelihood2{}, std::forward_as_tuple(y, delta_int, eta_v),
+              theta_0, covariance_motorcycle_functor{},
+              std::forward_as_tuple(x, phi_0, phi(1), phi(2), phi(3), n_obs),
+              tolerance, max_num_steps, hessian_block_size, solver_num,
+              max_steps_line_search, nullptr);
+        };
+        stan::test::expect_ad<true>(tols, f, eta_dbl, phi_dbl(0), phi_dbl);
+      },
+      theta0);
+}
diff --git a/test/unit/math/laplace/laplace_marginal_neg_binomial_log_lpmf_test.cpp b/test/unit/math/laplace/laplace_marginal_neg_binomial_log_lpmf_test.cpp
new file mode 100644
index 00000000000..e8ae6f25936
--- /dev/null
+++ b/test/unit/math/laplace/laplace_marginal_neg_binomial_log_lpmf_test.cpp
@@ -0,0 +1,103 @@
+#include <test/unit/pretty_print_types.hpp>
+#include <test/unit/math/test_ad.hpp>
+#include <stan/math.hpp>
+#include <stan/math/mix.hpp>
+#include <test/unit/math/laplace/laplace_utility.hpp>
+#include <test/unit/math/rev/fun/util.hpp>
+
+#include <gtest/gtest.h>
+#include <iostream>
+#include <istream>
+#include <fstream>
+#include <vector>
+
+TEST(laplace_marginal_beg_binomial_log_lpmf, phi_dim_2) {
+  using stan::math::laplace_marginal_neg_binomial_2_log_lpmf;
+  using stan::math::laplace_marginal_tol_neg_binomial_2_log_lpmf;
+  using stan::math::to_vector;
+  using stan::math::value_of;
+  using stan::math::var;
+
+  int dim_phi = 2;
+  double alpha_dbl = 1.6;
+  double rho_dbl = 0.45;
+  int dim_theta = 2;
+  Eigen::VectorXd theta_0(dim_theta);
+  theta_0 << 0, 0;
+
+  int dim_x = 2;
+  std::vector<Eigen::VectorXd> x(dim_theta);
+  Eigen::VectorXd x_0(2);
+  x_0 << 0.05100797, 0.16086164;
+  Eigen::VectorXd x_1(2);
+  x_1 << -0.59823393, 0.98701425;
+  x[0] = x_0;
+  x[1] = x_1;
+
+  std::vector<double> delta;
+  std::vector<int> delta_int;
+
+  std::vector<int> y = {1, 0};
+  std::vector<int> y_index = {0, 1};
+  double eta_dbl = 10000;
+
+  constexpr double tolerance = 1e-12;
+  constexpr int max_num_steps = 1000;
+  stan::math::test::run_solver_grid(
+      [&](int solver_num, int hessian_block_size, int max_steps_line_search,
+          auto&& theta_0) {
+        auto f = [&](auto&& alpha, auto&& rho, auto&& eta) {
+          return laplace_marginal_tol_neg_binomial_2_log_lpmf(
+              y, y_index, eta, theta_0,
+              stan::math::test::squared_kernel_functor{},
+              std::forward_as_tuple(x, alpha, rho), tolerance, max_num_steps,
+              hessian_block_size, solver_num, max_steps_line_search, nullptr);
+        };
+        stan::test::expect_ad<true>(f, alpha_dbl, rho_dbl, eta_dbl);
+      },
+      theta_0);
+}
+
+TEST_F(laplace_disease_map_test, laplace_marginal_neg_binomial_2_log_lpmf) {
+  using stan::is_var_v;
+  using stan::math::laplace_marginal_neg_binomial_2_log_lpmf;
+  using stan::math::laplace_marginal_tol_neg_binomial_2_log_lpmf;
+  using stan::math::to_vector;
+  using stan::math::value_of;
+  using stan::math::var;
+  double eta = 1;
+
+  double marginal_density = laplace_marginal_neg_binomial_2_log_lpmf(
+      y, y_index, eta, theta_0, stan::math::test::sqr_exp_kernel_functor(),
+      std::forward_as_tuple(x, phi_dbl(0), phi_dbl(1)), nullptr);
+
+  // ToDo (charlesm93): get benchmark from GPStuff or another software.
+  constexpr double tolerance = 1e-6;
+  constexpr int max_num_steps = 100;
+  stan::math::test::run_solver_grid(
+      [&](int solver_num, int hessian_block_size, int max_steps_line_search,
+          auto&& theta_0) {
+        auto f = [&](auto&& alpha, auto&& rho, auto&& eta) {
+          return laplace_marginal_tol_neg_binomial_2_log_lpmf(
+              y, y_index, eta, theta_0,
+              stan::math::test::sqr_exp_kernel_functor{},
+              std::forward_as_tuple(x, alpha, rho), tolerance, max_num_steps,
+              hessian_block_size, solver_num, max_steps_line_search, nullptr);
+        };
+        auto ret = f(phi_dbl[0], phi_dbl[1], eta);
+      },
+      theta_0);
+  stan::math::test::run_solver_grid(
+      [&](int solver_num, int hessian_block_size, int max_steps_line_search,
+          auto&& theta_0) {
+        auto f = [&](auto&& alpha, auto&& rho, auto&& eta) {
+          return laplace_marginal_tol_neg_binomial_2_log_lpmf(
+              y, y_index, eta, theta_0,
+              stan::math::test::sqr_exp_kernel_functor{},
+              std::forward_as_tuple(x, alpha, rho), tolerance, max_num_steps,
+              hessian_block_size, solver_num, max_steps_line_search, nullptr);
+        };
+        stan::test::expect_ad<true>(f, phi_dbl[0], phi_dbl[1], eta);
+      },
+      theta_0);
+}
diff --git a/test/unit/math/laplace/laplace_marginal_neg_binomial_log_summary_lpmf_test.cpp b/test/unit/math/laplace/laplace_marginal_neg_binomial_log_summary_lpmf_test.cpp
new file mode 100644
index 00000000000..a0daa97f650
--- /dev/null
+++ b/test/unit/math/laplace/laplace_marginal_neg_binomial_log_summary_lpmf_test.cpp
@@ -0,0 +1,116 @@
+#include <test/unit/pretty_print_types.hpp>
+#include <test/unit/math/test_ad.hpp>
+#include <stan/math.hpp>
+#include <stan/math/mix.hpp>
+#include <test/unit/math/laplace/laplace_utility.hpp>
+#include <test/unit/math/rev/fun/util.hpp>
+
+#include <gtest/gtest.h>
+#include <iostream>
+#include <istream>
+#include <fstream>
+#include <vector>
+
+TEST(laplace_marginal_beg_binomial_log_summary_lpmf, phi_dim_2) {
+  using stan::math::laplace_marginal_neg_binomial_2_log_summary_lpmf;
+  using stan::math::laplace_marginal_tol_neg_binomial_2_log_summary_lpmf;
+  using stan::math::to_vector;
+  using stan::math::value_of;
+  using stan::math::var;
+
+  int dim_phi = 2;
+  double alpha_dbl = 1.6;
+  double rho_dbl = 0.45;
+  int dim_theta = 2;
+  Eigen::VectorXd theta_0(dim_theta);
+  theta_0 << 0, 0;
+
+  int dim_x = 2;
+  std::vector<Eigen::VectorXd> x(dim_theta);
+  Eigen::VectorXd x_0(2);
+  x_0 << 0.05100797, 0.16086164;
+  Eigen::VectorXd x_1(2);
+  x_1 << -0.59823393, 0.98701425;
+  x[0] = x_0;
+  x[1] = x_1;
+
+  std::vector<double> delta;
+  std::vector<int> delta_int;
+
+  std::vector<int> y = {1, 0};
+  std::vector<int> y_index = {0, 1};
+  double eta_dbl = 10000;
+  std::vector<int> n_per_group(theta_0.size(), 0);
+  std::vector<int> counts_per_group(theta_0.size(), 0);
+  for (int i = 0; i < y.size(); i++) {
+    n_per_group[y_index[i]]++;
+    counts_per_group[y_index[i]] += y[i];
+  }
+  constexpr double tolerance = 1e-12;
+  constexpr int max_num_steps = 1000;
+  stan::math::test::run_solver_grid(
+      [&](int solver_num, int hessian_block_size, int max_steps_line_search,
+          auto&& theta_0) {
+        auto f = [&](auto&& alpha, auto&& rho, auto&& eta) {
+          return laplace_marginal_tol_neg_binomial_2_log_summary_lpmf(
+              y, n_per_group, counts_per_group, eta, theta_0,
+              stan::math::test::squared_kernel_functor{},
+              std::forward_as_tuple(x, alpha, rho), tolerance, max_num_steps,
+              hessian_block_size, solver_num, max_steps_line_search, nullptr);
+        };
+        stan::test::expect_ad<true>(f, alpha_dbl, rho_dbl, eta_dbl);
+      },
+      theta_0);
+}
+
+TEST_F(laplace_disease_map_test,
+       laplace_marginal_neg_binomial_2_log_summary_lpmf) {
+  using stan::is_var_v;
+  using stan::math::laplace_marginal_neg_binomial_2_log_summary_lpmf;
+  using stan::math::laplace_marginal_tol_neg_binomial_2_log_summary_lpmf;
+  using stan::math::to_vector;
+  using stan::math::value_of;
+  using stan::math::var;
+  double eta = 1;
+  std::vector<int> n_per_group(theta_0.size(), 0);
+  std::vector<int> counts_per_group(theta_0.size(), 0);
+  for (int i = 0; i < y.size(); i++) {
+    n_per_group[y_index[i]]++;
+    counts_per_group[y_index[i]] += y[i];
+  }
+
+  double marginal_density = laplace_marginal_neg_binomial_2_log_summary_lpmf(
+      y, n_per_group, counts_per_group, eta, theta_0,
+      stan::math::test::sqr_exp_kernel_functor{},
+      std::forward_as_tuple(x, phi_dbl(0), phi_dbl(1)), nullptr);
+
+  // ToDo (charlesm93): get benchmark from GPStuff or another software.
+  constexpr double tolerance = 1e-6;
+  constexpr int max_num_steps = 100;
+  stan::math::test::run_solver_grid(
+      [&](int solver_num, int hessian_block_size, int max_steps_line_search,
+          auto&& theta_0) {
+        auto f = [&](auto&& alpha, auto&& rho, auto&& eta) {
+          return laplace_marginal_tol_neg_binomial_2_log_summary_lpmf(
+              y, n_per_group, counts_per_group, eta, theta_0,
+              stan::math::test::sqr_exp_kernel_functor{},
+              std::forward_as_tuple(x, alpha, rho), tolerance, max_num_steps,
+              hessian_block_size, solver_num, max_steps_line_search, nullptr);
+        };
+        auto ret = f(phi_dbl[0], phi_dbl[1], eta);
+      },
+      theta_0);
+  stan::math::test::run_solver_grid(
+      [&](int solver_num, int hessian_block_size, int max_steps_line_search,
+          auto&& theta_0) {
+        auto f = [&](auto&& alpha, auto&& rho, auto&& eta) {
+          return laplace_marginal_tol_neg_binomial_2_log_summary_lpmf(
+              y, n_per_group, counts_per_group, eta, theta_0,
+              stan::math::test::sqr_exp_kernel_functor{},
+              std::forward_as_tuple(x, alpha, rho), tolerance, max_num_steps,
+              hessian_block_size, solver_num, max_steps_line_search, nullptr);
+        };
+        stan::test::expect_ad<true>(f, phi_dbl[0], phi_dbl[1], eta);
+      },
+      theta_0);
+}
diff --git a/test/unit/math/laplace/laplace_marginal_poisson_log_lpmf_test.cpp b/test/unit/math/laplace/laplace_marginal_poisson_log_lpmf_test.cpp
new file mode 100644
index 00000000000..b2481d21814
--- /dev/null
+++ b/test/unit/math/laplace/laplace_marginal_poisson_log_lpmf_test.cpp
@@ -0,0 +1,121 @@
+#include <test/unit/math/test_ad.hpp>
+#include <stan/math.hpp>
+#include <stan/math/mix.hpp>
+#include <test/unit/math/laplace/laplace_utility.hpp>
+#include <test/unit/math/rev/fun/util.hpp>
+
+#include <gtest/gtest.h>
+#include <iostream>
+#include <istream>
+#include <fstream>
+#include <vector>
+
+TEST(laplace_marginal_poisson_log_lpmf, phi_dim_2) {
+  using stan::math::laplace_marginal_poisson_2_log_lpmf;
+  using stan::math::laplace_marginal_poisson_log_lpmf;
+  using stan::math::laplace_marginal_tol_poisson_2_log_lpmf;
+  using stan::math::laplace_marginal_tol_poisson_log_lpmf;
+
+  using stan::math::to_vector;
+  using stan::math::value_of;
+  using stan::math::var;
+
+  int dim_phi = 2;
+  double alpha_dbl = 1.6;
+  double rho_dbl = 0.45;
+  int dim_theta = 2;
+  Eigen::VectorXd theta_0(dim_theta);
+  theta_0 << 0, 0;
+
+  int dim_x = 2;
+  std::vector<Eigen::VectorXd> x(dim_theta);
+  Eigen::VectorXd x_0(2);
+  x_0 << 0.05100797, 0.16086164;
+  Eigen::VectorXd x_1(2);
+  x_1 << -0.59823393, 0.98701425;
+  x[0] = x_0;
+  x[1] = x_1;
+
+  std::vector<double> delta;
+  std::vector<int> delta_int;
+
+  std::vector<int> y = {1, 0};
+  std::vector<int> y_index = {0, 1};
+
+  stan::math::test::squared_kernel_functor sq_kernel;
+  constexpr double tolerance = 1e-6;
+  constexpr int max_num_steps = 100;
+
+  stan::test::ad_tolerances tols;
+  // tols.gradient_val_ = 1e-3;
+  tols.gradient_grad_ = 1e-3;
+
+  for (int max_steps_line_search = 0; max_steps_line_search < 4;
+       ++max_steps_line_search) {
+    for (int hessian_block_size = 1; hessian_block_size < 4;
+         hessian_block_size++) {
+      for (int solver_num = 1; solver_num < 4; solver_num++) {
+        auto f = [&](auto&& alpha, auto&& rho) {
+          return laplace_marginal_tol_poisson_log_lpmf(
+              y, y_index, theta_0, sq_kernel,
+              std::forward_as_tuple(x, alpha, rho), tolerance, max_num_steps,
+              hessian_block_size, solver_num, max_steps_line_search, nullptr);
+        };
+        stan::test::expect_ad<true>(tols, f, alpha_dbl, rho_dbl);
+      }
+    }
+  }
+
+  Eigen::VectorXd ye(2);
+  ye << 1, 1;
+  for (int max_steps_line_search = 0; max_steps_line_search < 4;
+       ++max_steps_line_search) {
+    for (int hessian_block_size = 1; hessian_block_size < 4;
+         hessian_block_size++) {
+      for (int solver_num = 1; solver_num < 4; solver_num++) {
+        auto f = [&](auto&& alpha, auto&& rho) {
+          return laplace_marginal_tol_poisson_2_log_lpmf(
+              y, y_index, ye, theta_0, sq_kernel,
+              std::forward_as_tuple(x, alpha, rho), tolerance, max_num_steps,
+              hessian_block_size, solver_num, max_steps_line_search, nullptr);
+        };
+        stan::test::expect_ad<true>(tols, f, alpha_dbl, rho_dbl);
+      }
+    }
+  }
+}
+
+TEST_F(laplace_disease_map_test, laplace_marginal_poisson_log_lpmf) {
+  using stan::math::laplace_marginal_poisson_2_log_lpmf;
+  using stan::math::laplace_marginal_poisson_log_lpmf;
+  using stan::math::laplace_marginal_tol_poisson_2_log_lpmf;
+  using stan::math::value_of;
+  using stan::math::var;
+
+  double marginal_density = laplace_marginal_poisson_2_log_lpmf(
+      y, y_index, ye, theta_0, stan::math::test::sqr_exp_kernel_functor(),
+      std::forward_as_tuple(x, phi_dbl(0), phi_dbl(1)), nullptr);
+
+  double tol = 6e-4;
+  // Benchmark from GPStuff.
+  EXPECT_NEAR(-2866.88, marginal_density, tol);
+
+  constexpr double tolerance = 1e-6;
+  constexpr int max_num_steps = 100;
+  for (int max_steps_line_search = 0; max_steps_line_search < 4;
+       ++max_steps_line_search) {
+    for (int hessian_block_size = 1; hessian_block_size < 4;
+         hessian_block_size++) {
+      for (int solver_num = 1; solver_num < 4; solver_num++) {
+        auto f = [&](auto&& alpha, auto&& rho) {
+          return laplace_marginal_tol_poisson_2_log_lpmf(
+              y, n_samples, ye, theta_0,
+              stan::math::test::sqr_exp_kernel_functor(),
+              std::forward_as_tuple(x, alpha, rho), tolerance, max_num_steps,
+              hessian_block_size, solver_num, max_steps_line_search, nullptr);
+        };
+        stan::test::expect_ad<true>(f, phi_dbl[0], phi_dbl[1]);
+      }
+    }
+  }
+}
diff --git a/test/unit/math/laplace/laplace_neg_binomial_2_log_rng_test.cpp b/test/unit/math/laplace/laplace_neg_binomial_2_log_rng_test.cpp
new file mode 100644
index 00000000000..9069499797c
--- /dev/null
+++ b/test/unit/math/laplace/laplace_neg_binomial_2_log_rng_test.cpp
@@ -0,0 +1,148 @@
+#include <stan/math.hpp>
+#include <stan/math/mix.hpp>
+#include <test/unit/math/laplace/laplace_utility.hpp>
+
+#include <boost/random/mersenne_twister.hpp>
+#include <boost/math/distributions.hpp>
+
+#include <gtest/gtest.h>
+#include <iostream>
+#include <istream>
+#include <fstream>
+#include <vector>
+
+namespace {
+struct stationary_point_nb {
+  template <typename T0, typename T1>
+  inline Eigen::Matrix<typename stan::return_type<T0, T1>::type, Eigen::Dynamic,
+                       1>
+  operator()(const Eigen::Matrix<T0, Eigen::Dynamic, 1>& theta,
+             const Eigen::Matrix<T1, Eigen::Dynamic, 1>& parms,
+             const std::vector<double>& dat, const std::vector<int>& dat_int,
+             std::ostream* pstream__ = 0) const {
+    using stan::math::exp;
+    Eigen::Matrix<typename stan::return_type<T0, T1>::type, Eigen::Dynamic, 1>
+        z(2);
+    double eta = dat[0];
+    Eigen::Matrix<T0, Eigen::Dynamic, 1> exp_theta = exp(theta);
+    std::vector<int> y = {1, 0};
+
+    z(0) = -exp_theta(0) * (y[0] + eta) / (eta + exp_theta(0)) + y[0]
+           - theta(0) / parms(0);
+    z(1) = -exp_theta(1) * (y[1] + eta) / (eta + exp_theta(1)) + y[1]
+           - theta(1) / parms(1);
+    // z(0) = 1 - (1 - eta) / (1 + eta * exp(theta(0))) - theta(0) / parms(0);
+    // z(1) = 0 - (0 - eta) / (1 + eta * exp(theta(1))) - theta(1) / parms(1);
+    return z;
+  }
+};
+
+struct diagonal_kernel_nb_functor {
+  template <typename T1, typename T2>
+  auto operator()(const T1& alpha, const T2& rho,
+                  std::ostream* msgs = nullptr) const {
+    Eigen::Matrix<T1, Eigen::Dynamic, Eigen::Dynamic> K(2, 2);
+    K(0, 0) = alpha;
+    K(1, 1) = rho;
+    K(0, 1) = 0;
+    K(1, 0) = 0;
+    return K;
+  }
+};
+
+template <typename T1, typename T2>
+Eigen::Matrix<T1, Eigen::Dynamic, Eigen::Dynamic> laplace_covariance_nb(
+    const Eigen::Matrix<T1, Eigen::Dynamic, 1>& theta,
+    const Eigen::Matrix<T2, Eigen::Dynamic, 1>& phi, const double& eta) {
+  using stan::math::exp;
+  using stan::math::square;
+  Eigen::Matrix<T1, Eigen::Dynamic, Eigen::Dynamic> K(2, 2);
+  Eigen::Matrix<T1, Eigen::Dynamic, 1> exp_theta = exp(theta);
+  std::vector<int> y = {1, 0};
+  K(0, 0) = 1
+            / ((eta * exp_theta(0) * (y[0] + eta) / square(eta + exp_theta(0)))
+               + 1 / phi(0));
+  K(1, 1) = 1
+            / ((eta * exp_theta(1) * (y[1] + eta) / square(eta + exp_theta(1)))
+               + 1 / phi(1));
+
+  // K(0, 0) = 1 / (1 / phi(0) + (1 - eta) * exp(theta(0))
+  //                                          / square(1 + eta *
+  //                                          exp(theta(0))));
+  // K(1, 1) = 1 / (1 / phi(1) + (0 - eta) * exp(theta(1))
+  //                                          / square(1 + eta *
+  //                                          exp(theta(1))));
+  K(0, 1) = 0;
+  K(1, 0) = 0;
+  return K;
+}
+
+TEST(laplace_latent_neg_binomial_2_log_rng, count_two_dim_diag) {
+  using stan::math::algebra_solver;
+  using stan::math::laplace_latent_neg_binomial_2_log_rng;
+  using stan::math::laplace_latent_tol_neg_binomial_2_log_rng;
+  using stan::math::multi_normal_rng;
+  using stan::math::sqrt;
+  using stan::math::square;
+
+  std::vector<int> y = {1, 0};
+  std::vector<int> y_index = {0, 1};
+  Eigen::VectorXd theta_0{{1, 1}};
+  Eigen::VectorXd phi{{3, 2}};
+
+  double eta = 2;
+  std::vector<double> d0 = {eta};
+  std::vector<int> di0;
+
+  Eigen::VectorXd theta_root
+      = algebra_solver(stationary_point_nb(), theta_0, phi, d0, di0);
+  Eigen::MatrixXd K_laplace = laplace_covariance_nb(theta_root, phi, eta);
+
+  boost::random::mt19937 rng;
+  rng.seed(1954);
+  Eigen::MatrixXd theta_benchmark
+      = stan::math::multi_normal_rng(theta_root, K_laplace, rng);
+
+  rng.seed(1954);
+  Eigen::MatrixXd theta_pred = laplace_latent_neg_binomial_2_log_rng(
+      y, y_index, eta, theta_0, diagonal_kernel_nb_functor{},
+      std::forward_as_tuple(phi(0), phi(1)), rng, nullptr);
+
+  double tol = 1e-3;
+  EXPECT_NEAR(theta_benchmark(0), theta_pred(0), tol);
+  EXPECT_NEAR(theta_benchmark(1), theta_pred(1), tol);
+
+  int n_sim = 5e5;
+  Eigen::VectorXd theta_dim0(n_sim);
+  Eigen::VectorXd theta_dim1(n_sim);
+  for (int i = 0; i < n_sim; i++) {
+    rng.seed(2025 + i);
+    Eigen::MatrixXd theta_pred = laplace_latent_neg_binomial_2_log_rng(
+        y, y_index, eta, theta_0, diagonal_kernel_nb_functor{},
+        std::forward_as_tuple(phi(0), phi(1)), rng, nullptr);
+
+    theta_dim0(i) = theta_pred(0);
+    theta_dim1(i) = theta_pred(1);
+  }
+
+  Eigen::MatrixXd K_sample(2, 2);
+  K_sample(0, 0)
+      = theta_dim0.array().square().mean() - square(theta_dim0.mean());
+  K_sample(1, 1)
+      = theta_dim1.array().square().mean() - square(theta_dim1.mean());
+  K_sample(0, 1) = theta_dim0.cwiseProduct(theta_dim1).mean()
+                   - theta_dim0.mean() * theta_dim1.mean();
+  K_sample(1, 0) = K_sample(0, 1);
+
+  // Check answers are within three std of the true answer.
+  EXPECT_NEAR(theta_root(0), theta_dim0.mean(),
+              3 * sqrt(K_laplace(0, 0) / n_sim));
+  EXPECT_NEAR(theta_root(1), theta_dim1.mean(),
+              3 * sqrt(K_laplace(1, 1) / n_sim));
+
+  // Check sample covariance
+  EXPECT_NEAR(K_laplace(0, 0), K_sample(0, 0), 6e-3);
+  EXPECT_NEAR(K_laplace(1, 1), K_sample(1, 1), 6e-3);
+  EXPECT_NEAR(K_laplace(0, 1), K_sample(0, 1), 1e-3);
+}
+}  // namespace
diff --git a/test/unit/math/laplace/laplace_poisson_log_rng_test.cpp b/test/unit/math/laplace/laplace_poisson_log_rng_test.cpp
new file mode 100644
index 00000000000..41922ffa042
--- /dev/null
+++ b/test/unit/math/laplace/laplace_poisson_log_rng_test.cpp
@@ -0,0 +1,116 @@
+#include <stan/math.hpp>
+#include <stan/math/mix.hpp>
+#include <test/unit/math/laplace/laplace_utility.hpp>
+
+#include <boost/random/mersenne_twister.hpp>
+#include <boost/math/distributions.hpp>
+
+#include <gtest/gtest.h>
+#include <iostream>
+#include <istream>
+#include <fstream>
+#include <vector>
+
+TEST_F(laplace_count_two_dim_diag_test, poisson_log_likelihood) {
+  using stan::math::laplace_latent_poisson_log_rng;
+  using stan::math::laplace_latent_tol_poisson_log_rng;
+  using stan::math::multi_normal_rng;
+  using stan::math::sqrt;
+  using stan::math::square;
+
+  // Compute exact mean and covariance.
+  Eigen::VectorXd theta_root = stan::math::algebra_solver(
+      stan::math::test::stationary_point(), theta_0, phi, d0, di0);
+  Eigen::MatrixXd K_laplace
+      = stan::math::test::laplace_covariance(theta_root, phi);
+
+  boost::random::mt19937 rng;
+  rng.seed(1954);
+  Eigen::MatrixXd theta_pred = laplace_latent_poisson_log_rng(
+      y, y_index, theta_0, stan::math::test::diagonal_kernel_functor{},
+      std::forward_as_tuple(phi(0), phi(1)), rng, nullptr);
+
+  // double tol = 1e-3;
+  EXPECT_NEAR(theta_benchmark(0), theta_pred(0), tol);
+  EXPECT_NEAR(theta_benchmark(1), theta_pred(1), tol);
+
+  // int n_sim = 5e5;
+  Eigen::VectorXd theta_dim0(n_sim);
+  Eigen::VectorXd theta_dim1(n_sim);
+  for (int i = 0; i < n_sim; i++) {
+    rng.seed(2025 + i);
+    Eigen::MatrixXd theta_pred = laplace_latent_poisson_log_rng(
+        y, y_index, theta_0, stan::math::test::diagonal_kernel_functor{},
+        std::forward_as_tuple(phi(0), phi(1)), rng, nullptr);
+
+    theta_dim0(i) = theta_pred(0);
+    theta_dim1(i) = theta_pred(1);
+  }
+
+  Eigen::MatrixXd K_sample(2, 2);
+  K_sample(0, 0)
+      = theta_dim0.array().square().mean() - square(theta_dim0.mean());
+  K_sample(1, 1)
+      = theta_dim1.array().square().mean() - square(theta_dim1.mean());
+  K_sample(0, 1) = theta_dim0.cwiseProduct(theta_dim1).mean()
+                   - theta_dim0.mean() * theta_dim1.mean();
+  K_sample(1, 0) = K_sample(0, 1);
+
+  // Check answers are within three std of the true answer.
+  EXPECT_NEAR(theta_root(0), theta_dim0.mean(),
+              3 * sqrt(K_laplace(0, 0) / n_sim));
+  EXPECT_NEAR(theta_root(1), theta_dim1.mean(),
+              3 * sqrt(K_laplace(1, 1) / n_sim));
+
+  // Check sample covariance
+  EXPECT_NEAR(K_laplace(0, 0), K_sample(0, 0), 5e-3);
+  EXPECT_NEAR(K_laplace(1, 1), K_sample(1, 1), 6e-3);
+  EXPECT_NEAR(K_laplace(0, 1), K_sample(0, 1), 1e-3);
+}
+
+TEST_F(laplace_count_two_dim_diag_test, poisson_log_exp_likelihood) {
+  using stan::math::laplace_latent_poisson_2_log_rng;
+  using stan::math::multi_normal_rng;
+  using stan::math::sqrt;
+  using stan::math::square;
+
+  rng.seed(1954);
+  Eigen::MatrixXd theta_pred_exp = laplace_latent_poisson_2_log_rng(
+      y, y_index, ye, theta_0, stan::math::test::diagonal_kernel_functor{},
+      std::forward_as_tuple(phi(0), phi(1)), rng, nullptr);
+
+  EXPECT_NEAR(theta_benchmark(0), theta_pred_exp(0), tol);
+  EXPECT_NEAR(theta_benchmark(1), theta_pred_exp(1), tol);
+
+  Eigen::VectorXd theta_dim0(n_sim);
+  Eigen::VectorXd theta_dim1(n_sim);
+  for (int i = 0; i < n_sim; i++) {
+    rng.seed(2025 + i);
+    Eigen::MatrixXd theta_pred = laplace_latent_poisson_2_log_rng(
+        y, y_index, ye, theta_0, stan::math::test::diagonal_kernel_functor{},
+        std::forward_as_tuple(phi(0), phi(1)), rng, nullptr);
+
+    theta_dim0(i) = theta_pred(0);
+    theta_dim1(i) = theta_pred(1);
+  }
+
+  Eigen::MatrixXd K_sample(2, 2);
+  K_sample(0, 0)
+      = theta_dim0.array().square().mean() - square(theta_dim0.mean());
+  K_sample(1, 1)
+      = theta_dim1.array().square().mean() - square(theta_dim1.mean());
+  K_sample(0, 1) = theta_dim0.cwiseProduct(theta_dim1).mean()
+                   - theta_dim0.mean() * theta_dim1.mean();
+  K_sample(1, 0) = K_sample(0, 1);
+
+  // Check answers are within three std of the true answer.
+  EXPECT_NEAR(theta_root(0), theta_dim0.mean(),
+              3 * sqrt(K_laplace(0, 0) / n_sim));
+  EXPECT_NEAR(theta_root(1), theta_dim1.mean(),
+              3 * sqrt(K_laplace(1, 1) / n_sim));
+
+  // Check sample covariance
+  EXPECT_NEAR(K_laplace(0, 0), K_sample(0, 0), 5e-3);
+  EXPECT_NEAR(K_laplace(1, 1), K_sample(1, 1), 6e-3);
+  EXPECT_NEAR(K_laplace(0, 1), K_sample(0, 1), 1e-3);
+}
diff --git a/test/unit/math/laplace/laplace_utility.hpp b/test/unit/math/laplace/laplace_utility.hpp
new file mode 100644
index 00000000000..94608f81b56
--- /dev/null
+++ b/test/unit/math/laplace/laplace_utility.hpp
@@ -0,0 +1,448 @@
+#ifndef STAN_TEST_UNIT_MATH_MIX_LAPLACE_UTILITY_HPP
+#define STAN_TEST_UNIT_MATH_MIX_LAPLACE_UTILITY_HPP
+#include <stan/math/mix.hpp>
+#include <test/unit/math/laplace/aki_disease_data/x1.hpp>
+#include <boost/algorithm/string.hpp>
+#include <iostream>
+#include <istream>
+#include <fstream>
+#include <gtest/gtest.h>
+
+namespace stan {
+namespace math {
+namespace test {
+
+struct laplace_issue {
+  int solver_num;
+  int max_steps_line_search;
+  int hessian_block_size;
+  constexpr laplace_issue(int solv, int max_steps, int hess_block)
+      : solver_num(solv),
+        max_steps_line_search(max_steps),
+        hessian_block_size(hess_block) {}
+  constexpr bool operator==(const laplace_issue& other) const {
+    return solver_num == other.solver_num
+           && max_steps_line_search == other.max_steps_line_search
+           && hessian_block_size == other.hessian_block_size;
+  }
+};
+
+namespace internal {
+template <typename T>
+struct is_pair : std::false_type {};
+
+template <typename T, typename U>
+struct is_pair<std::pair<T, U>> : std::true_type {};
+}  // namespace internal
+
+template <typename T>
+static constexpr bool is_pair_v = internal::is_pair<std::decay_t<T>>::value;
+
+enum class LaplaceFailures {
+  HessianFailure = 0,
+  SqrtDNE = 1,
+  NaNTheta = 2,
+  IterExceeded = 3,
+  Other = 4,
+  None = 5
+};
+inline std::string to_string(LaplaceFailures value) {
+  switch (value) {
+    case LaplaceFailures::HessianFailure:
+      return "LaplaceFailures::HessianFailure";
+    case LaplaceFailures::SqrtDNE:
+      return "LaplaceFailures::SqrtDNE";
+    case LaplaceFailures::NaNTheta:
+      return "LaplaceFailures::NaNTheta";
+    case LaplaceFailures::IterExceeded:
+      return "LaplaceFailures::IterExceeded";
+    case LaplaceFailures::None:
+      return "LaplaceFailures::None";
+    default:
+      return "LaplaceFailures::Other";
+  }
+}
+
+template <typename T>
+inline auto err_to_laplace_failure(T&& e) {
+  if (std::string(e.what()).find("positive") != std::string::npos) {
+    return LaplaceFailures::HessianFailure;
+  } else if (std::string(e.what()).find("schur") != std::string::npos) {
+    return LaplaceFailures::SqrtDNE;
+  } else if (std::string(e.what()).find("NaN") != std::string::npos) {
+    return LaplaceFailures::NaNTheta;
+  } else if (std::string(e.what()).find("iteration") != std::string::npos) {
+    return LaplaceFailures::IterExceeded;
+  } else {
+    return LaplaceFailures::Other;
+  }
+  return LaplaceFailures::None;
+}
+
+template <typename T1, typename T2>
+inline constexpr auto flag_test(T1&& known_issues, T2&& test_params) {
+  if constexpr (is_pair_v<decltype(known_issues[0])>) {
+    for (auto&& issue : known_issues) {
+      if (issue.first == test_params) {
+        return issue.second;
+      }
+    }
+    return LaplaceFailures::None;
+  } else {
+    for (auto&& issue : known_issues) {
+      if (issue == test_params) {
+        return true;
+      }
+    }
+    return false;
+  }
+}
+
+template <typename T1>
+inline constexpr auto flag_test(T1&& known_issues, int solver_num,
+                                int max_steps_line_search,
+                                int hessian_block_size) {
+  return flag_test(
+      known_issues,
+      laplace_issue{solver_num, max_steps_line_search, hessian_block_size});
+}
+
+struct squared_kernel_functor {
+  template <typename T1, typename T2>
+  Eigen::Matrix<T1, Eigen::Dynamic, Eigen::Dynamic> operator()(
+      const T2& x, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& phi,
+      const std::vector<double>& delta, const std::vector<int>& delta_int,
+      std::ostream* msgs = nullptr) const {
+    return stan::math::gp_exp_quad_cov(x, phi(0), phi(1))
+           + 1e-9 * Eigen::MatrixXd::Identity(x.size(), x.size());
+  }
+  template <typename T1, typename T2, typename T3>
+  Eigen::Matrix<return_type_t<T1, T2, T3>, Eigen::Dynamic, Eigen::Dynamic>
+  operator()(const T1& x, const T2& arg1, const T3& arg2,
+             std::ostream* msgs = nullptr) const {
+    return stan::math::gp_exp_quad_cov(x, arg1, arg2)
+           + 1e-9 * Eigen::MatrixXd::Identity(x.size(), x.size());
+  }
+  template <typename T1, typename T2, typename T3>
+  Eigen::Matrix<return_type_t<T1, T2, T3>, Eigen::Dynamic, Eigen::Dynamic>
+  operator()(const T1& x, const std::tuple<T2, T3>& arg1,
+             std::ostream* msgs = nullptr) const {
+    return stan::math::gp_exp_quad_cov(x, std::get<0>(arg1), std::get<1>(arg1))
+           + 1e-9 * Eigen::MatrixXd::Identity(x.size(), x.size());
+  }
+  template <typename T1, typename T2, typename T3>
+  Eigen::Matrix<return_type_t<T1, T2, T3>, Eigen::Dynamic, Eigen::Dynamic>
+  operator()(const T1& x, const std::vector<std::tuple<T2, T3>>& arg1,
+             std::ostream* msgs = nullptr) const {
+    return stan::math::gp_exp_quad_cov(x, std::get<0>(arg1[0]),
+                                       std::get<1>(arg1[0]))
+           + 1e-9 * Eigen::MatrixXd::Identity(x.size(), x.size());
+  }
+};
+
+struct sqr_exp_kernel_functor {
+  template <typename T1, typename T2, typename T3>
+  auto operator()(const T1& x, const T2& alpha, const T3& rho,
+                  std::ostream* msgs = nullptr) const {
+    constexpr double jitter = 1e-8;
+    Eigen::Matrix<return_type_t<T1, T2, T3>, Eigen::Dynamic, Eigen::Dynamic>
+        kernel = stan::math::gp_exp_quad_cov(x, alpha, rho);
+    for (int i = 0; i < kernel.cols(); i++)
+      kernel(i, i) += jitter;
+
+    return kernel;
+  }
+};
+
+struct stationary_point {
+  template <typename T0, typename T1>
+  inline Eigen::Matrix<typename stan::return_type<T0, T1>::type, Eigen::Dynamic,
+                       1>
+  operator()(const Eigen::Matrix<T0, Eigen::Dynamic, 1>& theta,
+             const Eigen::Matrix<T1, Eigen::Dynamic, 1>& parms,
+             const std::vector<double>& dat, const std::vector<int>& dat_int,
+             std::ostream* pstream__ = 0) const {
+    Eigen::Matrix<typename stan::return_type<T0, T1>::type, Eigen::Dynamic, 1>
+        z(2);
+    z(0) = 1 - exp(theta(0)) - theta(0) / (parms(0) * parms(0));
+    z(1) = 0 - exp(theta(1)) - theta(1) / (parms(1) * parms(1));
+    return z;
+  }
+};
+
+struct diagonal_kernel_functor {
+  template <typename T1, typename T2>
+  auto operator()(const T1& alpha, const T2& rho,
+                  std::ostream* msgs = nullptr) const {
+    Eigen::Matrix<T1, Eigen::Dynamic, Eigen::Dynamic> K(2, 2);
+    K(0, 0) = alpha * alpha;
+    K(1, 1) = rho * rho;
+    K(0, 1) = 0;
+    K(1, 0) = 0;
+    return K;
+  }
+};
+
+template <typename F, typename ThetaVec>
+void run_solver_grid(F&& body, ThetaVec&& theta_0) {
+  constexpr std::array solver_nums{1, 2, 3};            // [1, 3]
+  constexpr std::array hessian_block_sizes{1, 2, 3};    // [1, 2]
+  constexpr std::array max_steps_line_searches{0, 10};  // 0, 10
+  for (int solver : solver_nums) {
+    for (int hblock : hessian_block_sizes) {
+      for (int ls_steps : max_steps_line_searches) {
+        if (theta_0.size() % hblock != 0) {
+          std::cerr << "[          ] [ INFO ]"
+                    << " Skipping test for hessian of size " << theta_0.size()
+                    << " with hessian block size of " << hblock << std::endl;
+          continue;
+        }
+        try {
+          std::forward<F>(body)(solver, hblock, ls_steps, theta_0);
+        } catch (const std::exception& e) {
+          ADD_FAILURE() << "Exception: " << e.what();
+        }
+        if (::testing::Test::HasFailure()) {
+          std::cout << "----------" << std::endl;
+          std::cout << "solver_num: " << solver << std::endl;
+          std::cout << "hessian_block_size: " << hblock << std::endl;
+          std::cout << "max_steps_line_search: " << ls_steps << std::endl;
+        }
+      }
+    }
+  }
+}
+
+template <typename T1, typename T2>
+Eigen::Matrix<T1, Eigen::Dynamic, Eigen::Dynamic> laplace_covariance(
+    const Eigen::Matrix<T1, Eigen::Dynamic, 1>& theta_root,
+    const Eigen::Matrix<T2, Eigen::Dynamic, 1>& phi) {
+  Eigen::Matrix<T1, Eigen::Dynamic, Eigen::Dynamic> K(2, 2);
+  K(0, 0) = 1 / (stan::math::exp(theta_root(0)) + 1 / (phi(0) * phi(0)));
+  K(1, 1) = 1 / (stan::math::exp(theta_root(1)) + 1 / (phi(1) * phi(1)));
+  K(0, 1) = 0;
+  K(1, 0) = 0;
+  return K;
+}
+
+/**
+ * Helper function for printing out adjoints
+ */
+template <typename Output, require_t<is_any_var_scalar<Output>>* = nullptr>
+inline void print_adjoint(Output&& output) {
+  if constexpr (is_tuple_v<Output>) {
+    std::cout << "tuple adj\n";
+    return stan::math::for_each(
+        [](auto&& output_i) { return print_adjoint(output_i); }, output);
+  } else if constexpr (is_std_vector_v<Output>) {
+    if constexpr (is_var_v<value_type_t<Output>>) {
+      Eigen::Map<const Eigen::Matrix<var, -1, -1>> map_x(output.data(),
+                                                         output.size());
+      std::cout << "eigen adj: \n" << map_x.adj() << std::endl;
+    } else {
+      std::cout << "stdvec adjoint\n";
+      for (int i = 0; i < output.size(); ++i) {
+        print_adjoint(output[i]);
+      }
+    }
+  } else if constexpr (is_eigen_v<Output>) {
+    std::cout << "adj: \n" << output.adj() << std::endl;
+  } else if constexpr (is_stan_scalar_v<Output>) {
+    std::cout << "adj: " << output.adj() << std::endl;
+  } else {
+    static_assert(sizeof(Output*) == 0,
+                  "INTERNAL ERROR:(laplace_marginal_lpdf) print_adjoint was "
+                  "not able to deduce the actiopns needed for the given type.");
+  }
+}
+
+}  // namespace test
+}  // namespace math
+}  // namespace stan
+
+//////////////////////////////////////////////////////////////////////////
+
+class laplace_disease_map_test : public ::testing::Test {
+  // Based on (Vanhatalo, Pietilainen and Vethari, 2010). See
+  // https://research.cs.aalto.fi/pml/software/gpstuff/demo_spatial1.shtml
+ protected:
+  void SetUp() override {
+    dim_theta = 911;
+    n_observations = 911;
+    x1 = stan::test::laplace::disease::x1;
+    x2 = stan::test::laplace::disease::x2;
+    y = stan::test::laplace::disease::y;
+    ye = stan::test::laplace::disease::ye;
+
+    dim_x = 2;
+    x.resize(dim_theta);
+    for (int i = 0; i < dim_theta; i++) {
+      Eigen::VectorXd coordinate(dim_x);
+      coordinate << x1[i], x2[i];
+      x[i] = coordinate;
+    }
+
+    // one observation per group
+    n_samples.resize(dim_theta);
+    for (int i = 0; i < dim_theta; i++)
+      n_samples[i] = 1;
+
+    theta_0 = Eigen::VectorXd::Zero(dim_theta);
+    dim_phi = 2;
+    phi_dbl.resize(dim_phi);
+    phi_dbl << 0.3162278, 200;  // variance, length scale
+
+    delta_lk.resize(2 * n_observations);
+    y_index.resize(dim_theta);
+    for (int i = 0; i < n_observations; i++) {
+      delta_lk(i) = y[i];
+      delta_lk(n_observations + i) = ye(i);
+      y_index[i] = i;
+    }
+  }
+
+  int dim_theta;
+  int n_observations;
+  std::string data_directory;
+  std::vector<double> x1, x2;
+  std::vector<int> y;
+  Eigen::VectorXd ye;
+  int dim_x;
+  std::vector<Eigen::VectorXd> x;
+  std::vector<int> y_index;
+  std::vector<int> n_samples;
+  std::vector<double> delta;
+  std::vector<int> delta_int;
+
+  Eigen::VectorXd theta_0;
+  int dim_phi;
+  Eigen::Matrix<double, -1, 1> phi_dbl;
+  Eigen::Matrix<double, -1, 1> eta_dummy_dbl;
+
+  Eigen::VectorXd delta_lk;
+  // stan::math::poisson_log_likelihood f;
+};
+
+class laplace_count_two_dim_diag_test : public ::testing::Test {
+ protected:
+  void SetUp() override {
+    using stan::math::algebra_solver;
+    dim_theta = 2;
+    y.resize(2);
+    y = {1, 0};
+    y_index.resize(2);
+    y_index = {0, 1};
+
+    theta_root = algebra_solver(stan::math::test::stationary_point(), theta_0,
+                                phi, d0, di0);
+    K_laplace = stan::math::test::laplace_covariance(theta_root, phi);
+
+    rng.seed(1954);
+    theta_benchmark = stan::math::multi_normal_rng(theta_root, K_laplace, rng);
+
+    tol = 1e-3;
+    n_sim = 5e5;
+  }
+
+  int dim_theta;
+  Eigen::VectorXd theta_0{{1, 1}};
+  Eigen::VectorXd theta_root;
+  Eigen::VectorXd phi{{3, 2}};
+  std::vector<int> y;
+  std::vector<int> y_index;
+  Eigen::VectorXd ye{{1, 1}};
+  std::vector<double> d0;
+  std::vector<int> di0;
+  Eigen::MatrixXd K_laplace;
+  Eigen::MatrixXd theta_benchmark;
+  boost::random::mt19937 rng;
+  double tol;
+  int n_sim;
+};
+#ifdef DEBUG_LAPLACE
+static bool write_init_json = true;
+static int err_iter = 0;
+
+// Custom event listener that logs test failures
+class LoggingTestListener : public ::testing::EmptyTestEventListener {
+ public:
+  std::string current_test_name_;
+  int solver_num{0};
+  int hessian_block_size{0};
+  int max_steps_line_search{0};
+
+  // Called after an assertion results in a failure.
+  void OnTestPartResult(const ::testing::TestPartResult& result) override {
+    if (result.failed()) {
+      std::ofstream ofs;
+      // On first failure, open file in truncation mode and write header
+      if (write_init_json) {
+        ofs.open("failure_log.json", std::ios::out);
+        ofs << "{\"error\": {\n";
+        write_init_json = false;
+      } else {
+        // For subsequent failures, open in append mode and add a comma
+        // separator
+        ofs.open("failure_log.json", std::ios::app);
+        ofs << ", \n";
+      }
+      ofs << "\"" << err_iter << "\": {";
+      err_iter++;
+      std::string result_summary = result.summary();
+      boost::replace_all(result_summary, "\"", "\\\"");
+      boost::replace_all(result_summary, "\n", "\\n");
+      // Retrieve the current test information.
+      const ::testing::TestInfo* test_info
+          = ::testing::UnitTest::GetInstance()->current_test_info();
+      std::string test_name;
+      if (test_info) {
+        // For Google Test 1.10.0 or later
+        test_name = std::string(test_info->test_suite_name()) + "."
+                    + test_info->name();
+        // For older versions, use:
+        // test_name = std::string(test_info->test_case_name()) + "." +
+        // test_info->name();
+      }
+      ofs << "\"test\": \"" << test_name << "\", ";
+      ofs << "\"solver_num\": " << solver_num << ", ";
+      ofs << "\"hessian_block_size\": " << hessian_block_size << ", ";
+      ofs << "\"max_steps_line_search\": " << max_steps_line_search << ", ";
+      ofs << "\"failure\": \"" << result_summary << "\"}";
+    }
+  }
+
+  // Called after all tests have ended.
+  void OnTestProgramEnd(const ::testing::UnitTest& /*unit_test*/) override {
+    if (!write_init_json) {  // Only if at least one failure was logged
+      std::ofstream ofs("failure_log.json", std::ios::app);
+      ofs << "}}";  // Close the JSON object
+    }
+  }
+};
+
+class laplace_test_listen : public ::testing::Test {
+ public:
+  virtual void AllowSetup() {}
+  bool setup_once{true};
+  LoggingTestListener* logger{new LoggingTestListener{}};
+
+ protected:
+  virtual void AllowSetup() {
+    if (setup_once) {
+      ::testing::TestEventListeners& listeners
+          = ::testing::UnitTest::GetInstance()->listeners();
+      listeners.Append(logger);
+      setup_once = false;
+    }
+  }
+  void SetUp() override { this->AllowSetup(); }
+  virtual ~laplace_test_listen() {
+    ::testing::TestEventListeners& listeners
+        = ::testing::UnitTest::GetInstance()->listeners();
+    listeners.Release(logger);
+    delete logger;
+  }
+}
+#endif
+
+#endif
diff --git a/test/unit/math/laplace/motorcycle_gp/x_vec.hpp b/test/unit/math/laplace/motorcycle_gp/x_vec.hpp
new file mode 100644
index 00000000000..3c7fbc07da2
--- /dev/null
+++ b/test/unit/math/laplace/motorcycle_gp/x_vec.hpp
@@ -0,0 +1,40 @@
+#ifndef STAN_TEST_UNIT_MIX_LAPLACE_MOTORCYCLE_GP_HPP
+#define STAN_TEST_UNIT_MIX_LAPLACE_MOTORCYCLE_GP_HPP
+namespace stan {
+namespace test {
+namespace laplace {
+namespace moto {
+static const auto x = std::vector<double>{
+    2.4,  2.6,  3.2,  3.6,  4,    6.2,  6.6,  6.8,  7.8,  8.2,  8.8,  8.8,
+    9.6,  10,   10.2, 10.6, 11,   11.4, 13.2, 13.6, 13.8, 14.6, 14.6, 14.6,
+    14.6, 14.6, 14.6, 14.8, 15.4, 15.4, 15.4, 15.4, 15.6, 15.6, 15.8, 15.8,
+    16,   16,   16.2, 16.2, 16.2, 16.4, 16.4, 16.6, 16.8, 16.8, 16.8, 17.6,
+    17.6, 17.6, 17.6, 17.8, 17.8, 18.6, 18.6, 19.2, 19.4, 19.4, 19.6, 20.2,
+    20.4, 21.2, 21.4, 21.8, 22,   23.2, 23.4, 24,   24.2, 24.2, 24.6, 25,
+    25,   25.4, 25.4, 25.6, 26,   26.2, 26.2, 26.4, 27,   27.2, 27.2, 27.2,
+    27.6, 28.2, 28.4, 28.4, 28.6, 29.4, 30.2, 31,   31.2, 32,   32,   32.8,
+    33.4, 33.8, 34.4, 34.8, 35.2, 35.2, 35.4, 35.6, 35.6, 36.2, 36.2, 38,
+    38,   39.2, 39.4, 40,   40.4, 41.6, 41.6, 42.4, 42.8, 42.8, 43,   44,
+    44.4, 45,   46.6, 47.8, 47.8, 48.8, 50.6, 52,   53.2, 55,   55,   55.4,
+    57.6};
+static const auto y = Eigen::VectorXd{
+    {0,      -1.3,   -2.7,   0,      -2.7,   -2.7,   -2.7,   -1.3,   -2.7,
+     -2.7,   -1.3,   -2.7,   -2.7,   -2.7,   -5.4,   -2.7,   -5.4,   0,
+     -2.7,   -2.7,   0,      -13.3,  -5.4,   -5.4,   -9.3,   -16,    -22.8,
+     -2.7,   -22.8,  -32.1,  -53.5,  -54.9,  -40.2,  -21.5,  -21.5,  -50.8,
+     -42.9,  -26.8,  -21.5,  -50.8,  -61.7,  -5.4,   -80.4,  -59,    -71,
+     -91.1,  -77.7,  -37.5,  -85.6,  -123.1, -101.9, -99.1,  -104.4, -112.5,
+     -50.8,  -123.1, -85.6,  -72.3,  -127.2, -123.1, -117.9, -134,   -101.9,
+     -108.4, -123.1, -123.1, -128.5, -112.5, -95.1,  -81.8,  -53.5,  -64.4,
+     -57.6,  -72.3,  -44.3,  -26.8,  -5.4,   -107.1, -21.5,  -65.6,  -16,
+     -45.6,  -24.2,  9.5,    4,      12,     -21.5,  37.5,   46.9,   -17.4,
+     36.2,   75,     8.1,    54.9,   48.2,   46.9,   16,     45.6,   1.3,
+     75,     -16,    -54.9,  69.6,   34.8,   32.1,   -37.5,  22.8,   46.9,
+     10.7,   5.4,    -1.3,   -21.5,  -13.3,  30.8,   -10.7,  29.4,   0,
+     -10.7,  14.7,   -1.3,   0,      10.7,   10.7,   -26.8,  -14.7,  -13.3,
+     0,      10.7,   -14.7,  -2.7,   10.7,   -2.7,   10.7}};
+}  // namespace moto
+}  // namespace laplace
+}  // namespace test
+}  // namespace stan
+#endif
diff --git a/test/unit/math/mix/fun/value_of_rec_test.cpp b/test/unit/math/mix/fun/value_of_rec_test.cpp
index 4cd0e0f3e37..6c0f9010996 100644
--- a/test/unit/math/mix/fun/value_of_rec_test.cpp
+++ b/test/unit/math/mix/fun/value_of_rec_test.cpp
@@ -1,5 +1,5 @@
 #include <stan/math/mix.hpp>
-#include <test/unit/math/rev/fun/util.hpp>
+#include <test/unit/math/mix/util.hpp>
 #include <gtest/gtest.h>
 #include <vector>
 
@@ -17,7 +17,7 @@ TEST(AgradMix, value_of_rec) {
   EXPECT_FLOAT_EQ(5.0, value_of_rec(fffffv_a));
 }
 
-TEST(MathMatrixMixArr, value_of_rec) {
+TEST(AgradMix, array_value_of_rec) {
   using stan::math::fvar;
   using stan::math::value_of_rec;
   using stan::math::var;
@@ -41,7 +41,7 @@ TEST(MathMatrixMixArr, value_of_rec) {
     EXPECT_FLOAT_EQ(a[i].val_.val_.val(), d_a[i]);
 }
 
-TEST(AgradMixMatrix, value_of_rec) {
+TEST(AgradMix, matrix_value_of_rec) {
   using stan::math::fvar;
   using stan::math::value_of_rec;
   using stan::math::var;
@@ -83,3 +83,89 @@ TEST(AgradMixMatrix, value_of_rec) {
       EXPECT_FLOAT_EQ(a_vals[j * 2 + i], d_ffv_a(i, j));
     }
 }
+
+TEST(AgradMix, tuple_value_of_rec) {
+  using stan::math::fvar;
+  using stan::math::value_of;
+  using stan::math::var;
+  using std::vector;
+
+  std::vector<double> a_vals;
+
+  for (size_t i = 0; i < 10; ++i)
+    a_vals.push_back(i + 1);
+
+  std::vector<double> b_vals;
+
+  for (size_t i = 10; i < 15; ++i)
+    b_vals.push_back(i + 1);
+
+  Eigen::Matrix<double, 2, 5> a;
+  ::fill(a_vals, a);
+  Eigen::Matrix<var, 2, 5> v_a;
+  ::fill(a_vals, v_a);
+  Eigen::Matrix<fvar<var>, 2, 5> fv_a;
+  ::fill(a_vals, fv_a);
+  Eigen::Matrix<fvar<fvar<var> >, 2, 5> ffv_a;
+  ::fill(a_vals, ffv_a);
+
+  Eigen::Matrix<double, 5, 1> b;
+  ::fill(b_vals, b);
+  Eigen::Matrix<var, 5, 1> v_b;
+  ::fill(b_vals, v_b);
+  Eigen::Matrix<fvar<var>, 5, 1> fv_b;
+  ::fill(b_vals, fv_b);
+  Eigen::Matrix<fvar<fvar<var> >, 5, 1> ffv_b;
+  ::fill(b_vals, ffv_b);
+
+  std::vector<fvar<fvar<var> > > ffv_a_std_vec(10);
+  std::vector<double> a_std_vec(10);
+  for (size_t i = 0; i < 10; ++i) {
+    a_std_vec[i] = i;
+    ffv_a_std_vec[i] = fvar<fvar<var> >(i);
+  }
+  std::vector<fvar<fvar<var> > > ffv_b_std_vec(5);
+  std::vector<double> b_std_vec(5);
+  for (size_t i = 0; i < 5; ++i) {
+    b_std_vec[i] = 10 + i;
+    ffv_b_std_vec[i] = fvar<fvar<var> >(10 + i);
+  }
+  auto b_tuple_dbl = std::make_tuple(b, b, b, b_std_vec);
+  auto a_b_tuple_dbl = std::make_tuple(a, a, a, a_std_vec, b_tuple_dbl);
+  std::vector a_b_tuple_vec_dbl{a_b_tuple_dbl, a_b_tuple_dbl, a_b_tuple_dbl};
+  auto a_b_tuple_vec_tuple_dbl = std::make_tuple(a, a_b_tuple_vec_dbl, b);
+  auto b_tuple_ad = std::make_tuple(v_b, fv_b, ffv_b, ffv_b_std_vec);
+  auto a_b_tuple_ad
+      = std::make_tuple(v_a, fv_a, ffv_a, ffv_a_std_vec, b_tuple_ad);
+  std::vector a_b_tuple_vec_ad{a_b_tuple_ad, a_b_tuple_ad, a_b_tuple_ad};
+  // tuple(vector, array[tuple(vec, vec, vec, array[], tuple(mat, mat, mat,
+  // array[]))])
+  auto a_b_tuple_vec_tuple_ad = std::make_tuple(v_a, a_b_tuple_vec_ad, ffv_b);
+  stan::math::test::recursive_for_each(
+      [](auto&& x_ad, auto&& x_dbl) {
+        static_assert(std::is_same_v<std::decay_t<decltype(x_ad)>, double>,
+                      "value_of_rec() type should be double!!");
+        EXPECT_FLOAT_EQ(x_ad, x_dbl);
+      },
+      stan::math::value_of_rec(a_b_tuple_vec_tuple_ad),
+      a_b_tuple_vec_tuple_dbl);
+}
+
+TEST(AgradMix, value_of_rec_expr) {
+  using stan::math::fvar;
+  using stan::math::value_of;
+  using stan::math::var;
+  Eigen::Matrix<double, -1, -1> x_d = Eigen::MatrixXd::Random(3, 3);
+  Eigen::Matrix<var, -1, -1> x_v = x_d;
+  Eigen::Matrix<fvar<double>, -1, -1> x_fd = x_d;
+  Eigen::Matrix<fvar<var>, -1, -1> x_fv = x_d;
+
+  using stan::math::as_array_or_scalar;
+  using stan::math::to_ref;
+  using stan::math::value_of_rec;
+  auto y_d = value_of_rec(as_array_or_scalar(to_ref(x_d * x_d)));
+  auto y_v = value_of_rec(as_array_or_scalar(to_ref(x_v * x_v)));
+  auto y_fd = value_of_rec(as_array_or_scalar(to_ref(x_fd * x_fd)));
+  auto y_fv = value_of_rec(as_array_or_scalar(to_ref(x_fv * x_fv)));
+  stan::math::recover_memory();
+}
diff --git a/test/unit/math/mix/fun/value_of_test.cpp b/test/unit/math/mix/fun/value_of_test.cpp
index 7ac1f6fe360..d095d5afa25 100644
--- a/test/unit/math/mix/fun/value_of_test.cpp
+++ b/test/unit/math/mix/fun/value_of_test.cpp
@@ -1,23 +1,24 @@
-#include <stan/math/mix.hpp>
+#include <test/unit/math/test_ad.hpp>
+#include <test/unit/math/mix/util.hpp>
 #include <test/unit/math/rev/fun/util.hpp>
 #include <gtest/gtest.h>
 #include <vector>
 
-TEST(MathMatrixMixArr, value_of) {
+TEST(AgradMix, array_value_of) {
   using stan::math::fvar;
   using stan::math::value_of;
   using stan::math::var;
   using std::vector;
 
-  vector<fvar<fvar<var> > > a(10);
+  vector<fvar<fvar<var>>> a(10);
   for (size_t i = 0; i < 10; ++i)
-    a[i] = fvar<fvar<var> >(i);
-  vector<fvar<fvar<var> > > b(5);
+    a[i] = fvar<fvar<var>>(i);
+  vector<fvar<fvar<var>>> b(5);
   for (size_t i = 0; i < 5; ++i)
-    b[i] = fvar<fvar<var> >(10 + i);
+    b[i] = fvar<fvar<var>>(10 + i);
 
-  vector<fvar<var> > d_a = value_of(a);
-  vector<fvar<var> > d_b = value_of(b);
+  vector<fvar<var>> d_a = value_of(a);
+  vector<fvar<var>> d_b = value_of(b);
 
   for (int i = 0; i < 5; ++i)
     EXPECT_FLOAT_EQ(b[i].val_.val_.val(), d_b[i].val_.val());
@@ -26,7 +27,7 @@ TEST(MathMatrixMixArr, value_of) {
     EXPECT_FLOAT_EQ(a[i].val_.val_.val(), d_a[i].val_.val());
 }
 
-TEST(AgradMixMatrix, value_of) {
+TEST(AgradMix, matrix_value_of) {
   using stan::math::fvar;
   using stan::math::value_of;
   using stan::math::var;
@@ -57,9 +58,9 @@ TEST(AgradMixMatrix, value_of) {
   Eigen::Matrix<fvar<var>, 5, 1> fv_b;
   ::fill(b_vals, fv_b);
 
-  Eigen::Matrix<fvar<fvar<var> >, 2, 5> ffv_a;
+  Eigen::Matrix<fvar<fvar<var>>, 2, 5> ffv_a;
   ::fill(a_vals, ffv_a);
-  Eigen::Matrix<fvar<fvar<var> >, 5, 1> ffv_b;
+  Eigen::Matrix<fvar<fvar<var>>, 5, 1> ffv_b;
   ::fill(b_vals, ffv_b);
 
   Eigen::MatrixXd d_a = value_of(a);
@@ -86,3 +87,97 @@ TEST(AgradMixMatrix, value_of) {
       EXPECT_FLOAT_EQ(a(i, j), d_ffv_a(i, j).val_.val());
     }
 }
+
+TEST(AgradMix, tuple_value_of) {
+  using stan::math::fvar;
+  using stan::math::value_of;
+  using stan::math::var;
+  using std::vector;
+
+  vector<double> a_vals;
+
+  for (size_t i = 0; i < 10; ++i)
+    a_vals.push_back(i + 1);
+
+  vector<double> b_vals;
+
+  for (size_t i = 10; i < 15; ++i)
+    b_vals.push_back(i + 1);
+
+  Eigen::Matrix<double, 2, 5> a;
+  ::fill(a_vals, a);
+  Eigen::Matrix<var, 2, 5> v_a;
+  ::fill(a_vals, v_a);
+  Eigen::Matrix<fvar<var>, 2, 5> fv_a;
+  ::fill(a_vals, fv_a);
+  Eigen::Matrix<fvar<fvar<var>>, 2, 5> ffv_a;
+  ::fill(a_vals, ffv_a);
+
+  Eigen::Matrix<double, 5, 1> b;
+  ::fill(b_vals, b);
+  Eigen::Matrix<var, 5, 1> v_b;
+  ::fill(b_vals, v_b);
+  Eigen::Matrix<fvar<var>, 5, 1> fv_b;
+  ::fill(b_vals, fv_b);
+  Eigen::Matrix<fvar<fvar<var>>, 5, 1> ffv_b;
+  ::fill(b_vals, ffv_b);
+
+  std::vector<fvar<fvar<var>>> ffv_a_std_vec(10);
+  std::vector<double> a_std_vec(10);
+  for (size_t i = 0; i < 10; ++i) {
+    a_std_vec[i] = i;
+    ffv_a_std_vec[i] = fvar<fvar<var>>(i);
+  }
+  std::vector<fvar<fvar<var>>> ffv_b_std_vec(5);
+  std::vector<double> b_std_vec(5);
+  for (size_t i = 0; i < 5; ++i) {
+    b_std_vec[i] = 10 + i;
+    ffv_b_std_vec[i] = fvar<fvar<var>>(10 + i);
+  }
+  auto b_tuple_dbl = std::make_tuple(b, b, b, b_std_vec);
+  auto a_b_tuple_dbl = std::make_tuple(a, a, a, a_std_vec, b_tuple_dbl);
+  std::vector a_b_tuple_vec_dbl{a_b_tuple_dbl, a_b_tuple_dbl, a_b_tuple_dbl};
+  auto a_b_tuple_vec_tuple_dbl = std::make_tuple(a, a_b_tuple_vec_dbl, b);
+  auto b_tuple_ad = std::make_tuple(v_b, fv_b, ffv_b, ffv_b_std_vec);
+  auto a_b_tuple_ad
+      = std::make_tuple(v_a, fv_a, ffv_a, ffv_a_std_vec, b_tuple_ad);
+  std::vector a_b_tuple_vec_ad{a_b_tuple_ad, a_b_tuple_ad, a_b_tuple_ad};
+  // tuple(vector, array[tuple(vec, vec, vec, array[], tuple(mat, mat, mat,
+  // array[]))])
+  auto a_b_tuple_vec_tuple_ad = std::make_tuple(v_a, a_b_tuple_vec_ad, ffv_b);
+  using ffv = fvar<fvar<var>>;
+  using fv = fvar<var>;
+  using v = var;
+  stan::math::test::recursive_for_each(
+      [](auto&& x_ad, auto&& x_dbl) {
+        EXPECT_FLOAT_EQ(stan::math::test::get_val(x_ad), x_dbl);
+      },
+      value_of(a_b_tuple_vec_tuple_ad), a_b_tuple_vec_tuple_dbl);
+  stan::math::test::recursive_for_each(
+      [](auto&& x_value_of, auto&& x_ad) {
+        using value_of_t = std::decay_t<decltype(x_value_of)>;
+        using ad_t = std::decay_t<decltype(x_ad)>;
+        static_assert(std::is_same_v<value_of_t, stan::partials_type_t<ad_t>>,
+                      "value_of() type and partials type should be the same!!");
+      },
+      value_of(a_b_tuple_vec_tuple_ad), a_b_tuple_vec_tuple_ad);
+}
+
+TEST(AgradMix, value_of_expr) {
+  using stan::math::fvar;
+  using stan::math::value_of;
+  using stan::math::var;
+  Eigen::Matrix<double, -1, -1> x_d = Eigen::MatrixXd::Random(3, 3);
+  Eigen::Matrix<var, -1, -1> x_v = x_d;
+  Eigen::Matrix<fvar<double>, -1, -1> x_fd = x_d;
+  Eigen::Matrix<fvar<var>, -1, -1> x_fv = x_d;
+
+  using stan::math::as_array_or_scalar;
+  using stan::math::to_ref;
+  using stan::math::value_of;
+  auto y_d = value_of(as_array_or_scalar(to_ref(x_d * x_d)));
+  auto y_v = value_of(as_array_or_scalar(to_ref(x_v * x_v)));
+  auto y_fd = value_of(as_array_or_scalar(to_ref(x_fd * x_fd)));
+  auto y_fv = value_of(as_array_or_scalar(to_ref(x_fv * x_fv)));
+  stan::math::recover_memory();
+}
diff --git a/test/unit/math/mix/functor/hessian_block_diag_test.cpp b/test/unit/math/mix/functor/hessian_block_diag_test.cpp
new file mode 100644
index 00000000000..00ecaa98caf
--- /dev/null
+++ b/test/unit/math/mix/functor/hessian_block_diag_test.cpp
@@ -0,0 +1,169 @@
+#include <stan/math/mix.hpp>
+#include <gtest/gtest.h>
+
+using Eigen::Dynamic;
+using Eigen::Matrix;
+using Eigen::MatrixXd;
+using Eigen::VectorXd;
+
+using stan::math::hessian;
+using stan::math::hessian_block_diag;
+
+namespace hessian_block_diag_test {
+
+// fun1(x, y) = x^2 * y + 3 * y^2 (block-diagonal with full 2x2 block)
+struct fun1 {
+  template <typename T>
+  inline T operator()(const Matrix<T, Dynamic, 1>& x) const {
+    return x(0) * x(0) * x(1) + 3.0 * x(1) * x(1);
+  }
+};
+
+// fun2(x, y) = x^2 * y + 3*y^2 + 5*x*y + sin(x) (full Hessian)
+struct fun2 {
+  template <typename T>
+  inline T operator()(const Matrix<T, Dynamic, 1>& x) const {
+    using std::sin;
+    return x(0) * x(0) * x(1) + 3.0 * x(1) * x(1) + 5.0 * x(0) * x(1)
+           + sin(x(0));
+  }
+};
+
+// exp_diag(x, y) = exp(2x) + exp(y) (diagonal Hessian)
+struct exp_diag {
+  template <typename T>
+  inline T operator()(const Matrix<T, Dynamic, 1>& x) const {
+    using stan::math::exp;
+    return exp(2 * x(0)) + exp(x(1));
+  }
+};
+
+// one_arg(x) = x^3 (1x1 Hessian)
+struct one_arg {
+  template <typename T>
+  inline T operator()(const Matrix<T, Dynamic, 1>& x) const {
+    return stan::math::pow(x(0), 3);
+  }
+};
+
+// block_fun: two independent 2x2 blocks on a 4-dimensional input
+struct block_fun {
+  template <typename T>
+  inline T operator()(const Matrix<T, Dynamic, 1>& x) const {
+    using stan::math::exp;
+    using std::sin;
+    // block1: x0^2 + sin(x1)
+    // block2: exp(x2) * x3
+    return x(0) * x(0) + sin(x(1)) + exp(x(2)) * x(3);
+  }
+};
+
+TEST(MixFunctor, HessianBlockDiagFun1FullBlock) {
+  VectorXd x{{2.0, -3.0}};
+  // compute block-diagonal Hessian with block size = full dimension
+  Eigen::SparseMatrix<double> H_block = hessian_block_diag(fun1{}, x, 2);
+
+  // compute full dense Hessian
+  double fx;
+  VectorXd grad;
+  MatrixXd H_full;
+  hessian(fun1{}, x, fx, grad, H_full);
+  EXPECT_EQ(H_full.rows(), H_block.rows());
+  EXPECT_EQ(H_full.cols(), H_block.cols());
+  for (int i = 0; i < H_full.rows(); ++i) {
+    for (int j = 0; j < H_full.cols(); ++j) {
+      EXPECT_NEAR(H_full(i, j), H_block.coeff(i, j), 1e-12);
+    }
+  }
+}
+
+TEST(MixFunctor, HessianBlockDiagFun2FullBlock) {
+  VectorXd x{{13.0, -4.0}};
+  Eigen::SparseMatrix<double> H_block = hessian_block_diag(fun2{}, x, 2);
+
+  double fx;
+  VectorXd grad;
+  MatrixXd H_full;
+  hessian(fun2{}, x, fx, grad, H_full);
+
+  MatrixXd H_block_dense = MatrixXd(H_block);
+  EXPECT_EQ(2, H_block_dense.rows());
+  EXPECT_EQ(2, H_block_dense.cols());
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 2; ++j) {
+      EXPECT_NEAR(H_full(i, j), H_block_dense(i, j), 1e-12);
+    }
+  }
+}
+
+TEST(MixFunctor, HessianBlockDiagExpDiagBlock1) {
+  VectorXd x{{2.0, -1.0}};
+  Eigen::SparseMatrix<double> H_block = hessian_block_diag(exp_diag{}, x, 1);
+
+  double fx;
+  VectorXd grad;
+  MatrixXd H_full;
+  hessian(exp_diag{}, x, fx, grad, H_full);
+
+  EXPECT_EQ(H_full.rows(), H_block.rows());
+  EXPECT_EQ(H_full.cols(), H_block.cols());
+  // Only diagonal entries should be captured
+  for (int i = 0; i < H_full.rows(); ++i) {
+    for (int j = 0; j < H_full.cols(); ++j) {
+      if (i == j) {
+        EXPECT_NEAR(H_full(i, j), H_block.coeff(i, j), 1e-12);
+      } else {
+        EXPECT_FLOAT_EQ(0.0, H_block.coeff(i, j));
+      }
+    }
+  }
+}
+
+TEST(MixFunctor, HessianBlockDiagOneArg) {
+  VectorXd x{{8.0}};
+
+  Eigen::SparseMatrix<double> H_block = hessian_block_diag(one_arg{}, x, 1);
+
+  double fx;
+  VectorXd grad;
+  MatrixXd H_full;
+  hessian(one_arg{}, x, fx, grad, H_full);
+
+  EXPECT_EQ(1, H_block.rows());
+  EXPECT_EQ(1, H_block.cols());
+  EXPECT_NEAR(H_full(0, 0), H_block.coeff(0, 0), 1e-12);
+}
+
+TEST(MixFunctor, HessianBlockDiagBlockFunMultiBlock) {
+  VectorXd x{{1.5, -0.5, 0.7, 2.3}};
+  // two blocks of size 2
+  Eigen::SparseMatrix<double> H_block = hessian_block_diag(block_fun{}, x, 2);
+  double fx;
+  VectorXd grad;
+  MatrixXd H_full;
+  hessian(block_fun{}, x, fx, grad, H_full);
+
+  MatrixXd H_block_dense = MatrixXd(H_block);
+  // block 0: rows/cols [0,1]
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 2; ++j) {
+      EXPECT_NEAR(H_full(i, j), H_block_dense(i, j), 1e-12);
+    }
+  }
+  // block 1: rows/cols [2,3]
+  for (int i = 2; i < 4; ++i) {
+    for (int j = 2; j < 4; ++j) {
+      EXPECT_NEAR(H_full(i, j), H_block_dense(i, j), 1e-12);
+    }
+  }
+  // off-block entries should be zero
+  for (int i = 0; i < 4; ++i) {
+    for (int j = 0; j < 4; ++j) {
+      if (!((i < 2 && j < 2) || (i >= 2 && j >= 2))) {
+        EXPECT_FLOAT_EQ(0.0, H_block_dense(i, j));
+      }
+    }
+  }
+}
+
+}  // namespace hessian_block_diag_test
diff --git a/test/unit/math/mix/util.hpp b/test/unit/math/mix/util.hpp
new file mode 100644
index 00000000000..cb62b076e5f
--- /dev/null
+++ b/test/unit/math/mix/util.hpp
@@ -0,0 +1,60 @@
+#ifndef STAN_TEST_UNIT_MATH_MIX_UTIL_HPP
+#define STAN_TEST_UNIT_MATH_MIX_UTIL_HPP
+
+#include <test/unit/math/test_ad.hpp>
+#include <test/unit/math/rev/fun/util.hpp>
+
+namespace stan::math::test {
+/**
+ * For autodiff types, return the double value of the input's value
+ * @tparam T Type with a `auto val()` member function or a nonad scalar type
+ * @param x Scalar value
+ * @return The double value of the input's value
+ */
+template <typename T>
+inline double get_val(T&& x) {
+  if constexpr (stan::is_fvar_v<T> || stan::is_var_v<T>) {
+    return get_val(x.val());
+  } else if constexpr (stan::is_stan_scalar_v<T>) {
+    return x;
+  } else {
+    static_assert(sizeof(T*) == 0, "This function only accepts scalar types!");
+  }
+}
+/**
+ * Recurse through tuples and containers and apply a function to scalars.
+ * @tparam F A functor with operator() that takes scalar types and returns void.
+ * @tparam Types A variadic pack of types.
+ * @param f The functor to apply to scalars.
+ * @param x args to apply f to.
+ */
+template <typename F, typename... Types>
+inline void recursive_for_each(F&& f, Types&&... args) {
+  if constexpr (std::conjunction_v<stan::math::is_tuple<Types>...>) {
+    stan::math::for_each(
+        [&f](auto&&... args_i) { recursive_for_each(f, args_i...); }, args...);
+  } else {
+    if constexpr (std::conjunction_v<stan::is_std_vector<Types>...>) {
+      const auto max_size = stan::math::max_size(args...);
+      for (Eigen::Index i = 0; i < max_size; ++i) {
+        if constexpr (std::conjunction_v<
+                          stan::is_stan_scalar<value_type_t<Types>>...>) {
+          f(args[i]...);
+        } else {
+          recursive_for_each(f, args[i]...);
+        }
+      }
+    } else if constexpr (std::conjunction_v<stan::is_eigen<Types>...>) {
+      const auto max_size = stan::math::max_size(args...);
+      for (Eigen::Index i = 0; i < max_size; ++i) {
+        f(args(i)...);
+      }
+    } else if constexpr (std::conjunction_v<stan::is_stan_scalar<Types>...>) {
+      f(args...);
+    }
+  }
+}
+
+}  // namespace stan::math::test
+
+#endif
diff --git a/test/unit/math/prim/fun/to_ref_test.cpp b/test/unit/math/prim/fun/to_ref_test.cpp
new file mode 100644
index 00000000000..e4c1d2a116a
--- /dev/null
+++ b/test/unit/math/prim/fun/to_ref_test.cpp
@@ -0,0 +1,147 @@
+#include <stan/math/prim.hpp>
+#include <test/unit/util.hpp>
+#include <test/unit/math/prim/util.hpp>
+#include <gtest/gtest.h>
+#include <vector>
+#include <stdexcept>
+namespace {
+
+TEST(MathMatrix, to_ref_matrix_exprs_tuple) {
+  using stan::test::is_same_tuple_element_v;
+  Eigen::MatrixXd a = Eigen::MatrixXd::Random(3, 3);
+  auto x = std::make_tuple(a * a, a, a.array() * 3);
+  auto x_ref = stan::math::to_ref(x);
+  using x_ref_t = decltype(x_ref);
+  static_assert(is_same_tuple_element_v<0, x_ref_t, Eigen::MatrixXd>,
+                "first entry should be Eigen::MatrixXd!");
+  static_assert(is_same_tuple_element_v<1, x_ref_t, Eigen::MatrixXd>,
+                "second entry should be Eigen::MatrixXd!");
+  static_assert(
+      is_same_tuple_element_v<2, x_ref_t,
+                              Eigen::Array<double, -1, -1, 0, -1, -1>>,
+      "third entry should be Eigen::ArrayXd!");
+}
+
+TEST(MathMatrix, to_ref_matrix_views_tuple) {
+  Eigen::MatrixXd a = Eigen::MatrixXd::Random(3, 3);
+  auto x = std::make_tuple(a.block(0, 0, 1, 1),
+                           a(Eigen::placeholders::all, std::vector{2, 1, 1}),
+                           a.array());
+  auto x_ref = stan::math::to_ref(x);
+  using x_ref_t = decltype(x_ref);
+  using stan::test::is_same_tuple_element_v;
+  static_assert(!is_same_tuple_element_v<0, x_ref_t, Eigen::MatrixXd>,
+                "0th entry should be a view of an Eigen::MatrixXd!");
+  static_assert(
+      is_same_tuple_element_v<1, x_ref_t,
+                              Eigen::Matrix<double, -1, -1, 0, -1, -1>>,
+      "1st entry should be a view of an Eigen::MatrixXd!");
+  static_assert(
+      !is_same_tuple_element_v<2, x_ref_t,
+                               Eigen::Array<double, -1, -1, 0, -1, -1>>,
+      "2nd entry should be a view of an Eigen::ArrayXd!");
+}
+
+TEST(MathMatrix, to_ref_matrix_views_exprs_tuple) {
+  Eigen::MatrixXd a = Eigen::MatrixXd::Random(3, 3);
+  auto x = std::make_tuple(
+      a.block(0, 0, 1, 1),
+      std::make_tuple(a.block(0, 0, 1, 1),
+                      a(Eigen::placeholders::all, std::vector{2, 1, 1}),
+                      a.array()),
+      std::make_tuple(a * a, a, a.array() * 3),
+      a(Eigen::placeholders::all, std::vector{2, 1, 1}), a.array() * a.array());
+  auto x_ref = stan::math::to_ref(x);
+  using x_ref_t = decltype(x_ref);
+  using stan::test::is_same_tuple_element_v;
+  static_assert(!is_same_tuple_element_v<0, x_ref_t, Eigen::MatrixXd>,
+                "first entry should be a view of an Eigen::MatrixXd!");
+  {
+    using view_inner_tuple = std::tuple_element_t<1, decltype(x_ref)>;
+    static_assert(
+        !is_same_tuple_element_v<0, view_inner_tuple, Eigen::MatrixXd>,
+        "tuple<1><0> entry should be a view of an Eigen::MatrixXd!");
+    static_assert(
+        is_same_tuple_element_v<1, view_inner_tuple,
+                                Eigen::Matrix<double, -1, -1, 0, -1, -1>>,
+        "tuple<1><1> entry should be Eigen::MatrixXd!");
+    static_assert(
+        !is_same_tuple_element_v<2, view_inner_tuple,
+                                 Eigen::Array<double, -1, -1, 0, -1, -1>>,
+        "tuple<1><2> entry should be a view of an Eigen::ArrayXd!");
+
+    {
+      using expr_inner_tuple = std::tuple_element_t<2, decltype(x_ref)>;
+      static_assert(
+          is_same_tuple_element_v<0, expr_inner_tuple, Eigen::MatrixXd>,
+          "tuple<2><0> entry should be Eigen::MatrixXd!");
+      static_assert(
+          is_same_tuple_element_v<1, expr_inner_tuple, Eigen::MatrixXd>,
+          "tuple<2><1> entry should be Eigen::MatrixXd!");
+      static_assert(
+          is_same_tuple_element_v<2, expr_inner_tuple,
+                                  Eigen::Array<double, -1, -1, 0, -1, -1>>,
+          "tuple<2><2> entry should be Eigen::ArrayXd!");
+    }
+    static_assert(
+        is_same_tuple_element_v<3, x_ref_t,
+                                Eigen::Matrix<double, -1, -1, 0, -1, -1>>,
+        "tuple<3> entry should be Eigen::MatrixXd!");
+    static_assert(
+        is_same_tuple_element_v<4, x_ref_t,
+                                Eigen::Array<double, -1, -1, 0, -1, -1>>,
+        "tuple<4> entry should be Eigen::ArrayXd!");
+  }
+}
+TEST(MathMatrix, to_ref_matrix_views_exprs_moves_tuple) {
+  auto a = Eigen::MatrixXd::Random(3, 3);
+  auto x_ref = stan::math::to_ref(std::forward_as_tuple(
+      a.block(0, 0, 1, 1),
+      std::forward_as_tuple(
+          a.block(0, 0, 1, 1),
+          a(Eigen::placeholders::all,
+            std::vector{Eigen::Index{2}, Eigen::Index{1}, Eigen::Index{1}}),
+          a.array()),
+      std::forward_as_tuple(a * a, a, a.array() * 3),
+      a(Eigen::placeholders::all,
+        std::vector{Eigen::Index{2}, Eigen::Index{1}, Eigen::Index{1}}),
+      a.array() * a.array()));
+  using x_ref_t = decltype(x_ref);
+  // These should all be evaluated
+  using stan::test::is_same_tuple_element_v;
+  static_assert(is_same_tuple_element_v<0, x_ref_t, Eigen::MatrixXd>,
+                "first entry should be Eigen::MatrixXd!");
+  {
+    using view_inner_tuple = std::tuple_element_t<1, decltype(x_ref)>;
+    static_assert(is_same_tuple_element_v<0, view_inner_tuple, Eigen::MatrixXd>,
+                  "tuple<1><0> entry should be Eigen::MatrixXd!");
+    static_assert(
+        is_same_tuple_element_v<1, view_inner_tuple,
+                                Eigen::Matrix<double, -1, -1, 0, -1, -1>>,
+        "tuple<1><1> entry should be Eigen::MatrixXd!");
+    static_assert(
+        is_same_tuple_element_v<2, view_inner_tuple,
+                                Eigen::Array<double, -1, -1, 0, -1, -1>>,
+        "tuple<1><2> entry should be Eigen::ArrayXd!");
+  }
+  {
+    using expr_inner_tuple = std::tuple_element_t<2, decltype(x_ref)>;
+    static_assert(is_same_tuple_element_v<0, expr_inner_tuple, Eigen::MatrixXd>,
+                  "tuple<2><0> entry should be Eigen::MatrixXd!");
+    static_assert(is_same_tuple_element_v<1, expr_inner_tuple, Eigen::MatrixXd>,
+                  "tuple<2><1> entry should be Eigen::MatrixXd!");
+    static_assert(
+        is_same_tuple_element_v<2, expr_inner_tuple,
+                                Eigen::Array<double, -1, -1, 0, -1, -1>>,
+        "tuple<2><2> entry should be Eigen::ArrayXd!");
+  }
+  static_assert(
+      is_same_tuple_element_v<3, x_ref_t,
+                              Eigen::Matrix<double, -1, -1, 0, -1, -1>>,
+      "tuple<4> entry should be Eigen::ArrayXd!");
+  static_assert(
+      is_same_tuple_element_v<4, x_ref_t,
+                              Eigen::Array<double, -1, -1, 0, -1, -1>>,
+      "tuple<4> entry should be Eigen::ArrayXd!");
+}
+}  // namespace
diff --git a/test/unit/math/prim/fun/value_of_rec_test.cpp b/test/unit/math/prim/fun/value_of_rec_test.cpp
index 1e075bbdb8d..c5da58d4171 100644
--- a/test/unit/math/prim/fun/value_of_rec_test.cpp
+++ b/test/unit/math/prim/fun/value_of_rec_test.cpp
@@ -1,6 +1,7 @@
 #include <stan/math/prim.hpp>
 #include <test/unit/util.hpp>
 #include <gtest/gtest.h>
+#include <test/unit/pretty_print_types.hpp>
 #include <vector>
 
 TEST(MathFunctions, value_of_rec) {
@@ -72,19 +73,31 @@ TEST(MathFunctions, value_of_rec_return_type_short_circuit_std_vector) {
   std::vector<double> a(5);
   const std::vector<double> b(5);
   EXPECT_TRUE((std::is_same<decltype(stan::math::value_of_rec(a)),
-                            std::vector<double>&>::value));
+                            std::vector<double>&>::value))
+      << "stan::math::value_of_rec(a)) = "
+      << stan::math::test::type_name<decltype(stan::math::value_of_rec(a))>()
+      << ". But expected std::vector<double>&";
   EXPECT_TRUE((std::is_same<decltype(stan::math::value_of_rec(b)),
-                            const std::vector<double>&>::value));
+                            const std::vector<double>&>::value))
+      << "stan::math::value_of_rec(b)) = "
+      << stan::math::test::type_name<decltype(stan::math::value_of_rec(b))>()
+      << ". But expected const std::vector<double>&";
 }
 
 TEST(MathFunctions, value_of_rec_return_type_short_circuit_vector_xd) {
   Eigen::Matrix<double, Eigen::Dynamic, 1> a(5);
   const Eigen::Matrix<double, Eigen::Dynamic, 1> b(5);
   EXPECT_TRUE((std::is_same<decltype(stan::math::value_of_rec(a)),
-                            Eigen::Matrix<double, Eigen::Dynamic, 1>&>::value));
+                            Eigen::Matrix<double, Eigen::Dynamic, 1>&>::value))
+      << "stan::math::value_of_rec(a)) = "
+      << stan::math::test::type_name<decltype(stan::math::value_of_rec(a))>()
+      << ". But expected Eigen::Matrix<double, Eigen::Dynamic, 1>&";
   EXPECT_TRUE(
       (std::is_same<decltype(stan::math::value_of_rec(b)),
-                    const Eigen::Matrix<double, Eigen::Dynamic, 1>&>::value));
+                    const Eigen::Matrix<double, Eigen::Dynamic, 1>&>::value))
+      << "stan::math::value_of_rec(b)) = "
+      << stan::math::test::type_name<decltype(stan::math::value_of_rec(b))>()
+      << ". But expected const Eigen::Matrix<double, Eigen::Dynamic, 1>&";
 }
 
 TEST(MathFunctions, value_of_rec_return_type_short_circuit_row_vector_xd) {
@@ -110,11 +123,12 @@ TEST(MathFunctions, value_of_rec_return_type_short_circuit_matrix_xd) {
 
 TEST(MathFunctions, value_of_rec_return_type_short_circuit_expression) {
   const Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic> a(5, 4);
-
   const auto& expr = 3 * a;
-
-  EXPECT_TRUE((std::is_same<decltype(stan::math::value_of_rec(expr)),
-                            decltype(expr)>::value));
+  auto blah = stan::math::value_of_rec(expr);
+  EXPECT_TRUE((std::is_same_v<decltype(blah), std::decay_t<decltype(expr)>>))
+      << "stan::math::value_of_rec(expr) = "
+      << stan::math::test::type_name<decltype(blah)>()
+      << ". But expected an expr type";
 }
 
 TEST(MathFunctions,
diff --git a/test/unit/math/prim/fun/value_of_test.cpp b/test/unit/math/prim/fun/value_of_test.cpp
index bc2d9107940..9cd4acc8ad2 100644
--- a/test/unit/math/prim/fun/value_of_test.cpp
+++ b/test/unit/math/prim/fun/value_of_test.cpp
@@ -191,9 +191,7 @@ TEST(MathFunctions, value_of_return_type_short_circuit_matrix_xd) {
 
 TEST(MathFunctions, value_of_return_type_short_circuit_expression) {
   const Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic> a(5, 4);
-
   const auto& expr = 3 * a;
-
   EXPECT_TRUE((std::is_same<decltype(stan::math::value_of(expr)),
                             decltype(expr)>::value));
 }
diff --git a/test/unit/math/prim/functor/apply_test.cpp b/test/unit/math/prim/functor/apply_test.cpp
index 8501335c958..08e139f4690 100644
--- a/test/unit/math/prim/functor/apply_test.cpp
+++ b/test/unit/math/prim/functor/apply_test.cpp
@@ -64,7 +64,7 @@ TEST(MathFunctions, apply_temporary_function) {
 }
 
 TEST(MathFunctions, apply_temporary_function_reference) {
-  auto y = stan::math::apply([](auto& x) { return x; }, std::make_tuple(1.0));
+  auto y = stan::math::apply([](auto&& x) { return x; }, std::make_tuple(1.0));
 
   EXPECT_EQ(1.0, y);
   EXPECT_TRUE((std::is_same<double, decltype(y)>::value));
diff --git a/test/unit/math/prim/functor/filter_map_test.cpp b/test/unit/math/prim/functor/filter_map_test.cpp
new file mode 100644
index 00000000000..56cfa71d844
--- /dev/null
+++ b/test/unit/math/prim/functor/filter_map_test.cpp
@@ -0,0 +1,183 @@
+#include <stan/math/prim.hpp>
+#include <test/unit/pretty_print_types.hpp>
+#include <test/unit/math/prim/util.hpp>
+#include <gtest/gtest.h>
+#include <tuple>
+#include <type_traits>
+#include <vector>
+
+namespace {
+template <typename T>
+struct is_any_fp_scalar_impl {
+  static constexpr bool value
+      = std::is_floating_point_v<stan::scalar_type_t<T>>;
+};
+
+template <typename... Types>
+struct is_any_fp_scalar_impl<std::tuple<Types...>> {
+  static constexpr bool value
+      = (is_any_fp_scalar_impl<std::decay_t<Types>>::value || ...);
+};
+template <typename T, typename... VecArgs>
+struct is_any_fp_scalar_impl<std::vector<T, VecArgs...>> {
+  static constexpr bool value = is_any_fp_scalar_impl<std::decay_t<T>>::value;
+};
+template <typename T>
+struct is_any_fp_scalar {
+  static constexpr bool value = is_any_fp_scalar_impl<std::decay_t<T>>::value;
+};
+
+template <typename T>
+struct is_any_fp_or_vector {
+  static constexpr bool value = is_any_fp_scalar<std::decay_t<T>>::value
+                                || stan::is_std_vector_v<std::decay_t<T>>;
+};
+
+TEST(MathFunctions, filter_map_empty) {
+  auto args = stan::math::filter_map<stan::test::always_true>(
+      [](auto&& arg) { return arg; }, std::make_tuple());
+  EXPECT_EQ(std::tuple_size_v<decltype(args)>, 0);
+}
+
+TEST(MathFunctions, filter_map_all_true_filter) {
+  auto args = stan::math::filter_map<stan::test::always_true>(
+      [](auto&& arg) -> decltype(auto) {
+        return std::forward<decltype(arg)>(arg);
+      },
+      std::make_tuple(1, 2, 3));
+  static_assert(std::tuple_size_v<decltype(args)> == 3,
+                "tuple size should be 3!");
+  EXPECT_TRUE((std::is_same_v<std::tuple_element_t<0, decltype(args)>, int>));
+  EXPECT_TRUE((std::is_same_v<std::tuple_element_t<1, decltype(args)>, int>));
+  EXPECT_TRUE((std::is_same_v<std::tuple_element_t<2, decltype(args)>, int>));
+}
+
+TEST(MathFunctions, filter_map_all_false) {
+  auto args = stan::math::filter_map<stan::test::always_false>(
+      [](auto&& arg) { return arg; }, std::make_tuple(1, 2, 3));
+  static_assert(std::tuple_size_v<decltype(args)> == 0,
+                "tuple size should be 0!");
+}
+
+TEST(MathFunctions, filter_map_first_true) {
+  auto args = stan::math::filter_map<std::is_floating_point>(
+      [](auto&& arg) { return arg; },
+      std::make_tuple(1.0, 2.0, 3, 4.0, 5, 6.0));
+  static_assert(std::tuple_size_v<decltype(args)> == 4,
+                "tuple size should be 4!");
+}
+
+TEST(MathFunctions, filter_map_first_false) {
+  auto args = stan::math::filter_map<std::is_floating_point>(
+      [](auto&& arg) { return arg; }, std::make_tuple(1, 2, 3, 4.0, 5, 6.0));
+  static_assert(std::tuple_size_v<decltype(args)> == 2,
+                "tuple size should be 2!");
+}
+
+TEST(MathFunctions, filter_map_inner_tuple_rvalue) {
+  auto args = stan::math::filter_map<stan::test::contains_floating_point>(
+      [](auto&& arg) { return arg; },
+      std::forward_as_tuple(1, 2, 3, 4.0, 5, std::forward_as_tuple(1.0, 2, 3.0),
+                            6.0));
+  static_assert(std::tuple_size_v<decltype(args)> == 3,
+                "tuple size should be 3!");
+  using inner_tuple_t = std::tuple_element_t<1, decltype(args)>;
+  static_assert(!stan::test::is_ref_element_v<0, decltype(args)>,
+                "0th should not be a reference!");
+  static_assert(!stan::test::is_ref_element_v<1, decltype(args)>,
+                "1st should not be a reference!");
+  static_assert(!stan::test::is_ref_element_v<0, inner_tuple_t>,
+                "tuple<1><0> should not be a reference!");
+  static_assert(!stan::test::is_ref_element_v<1, inner_tuple_t>,
+                "tuple<1><1> should not be a reference!");
+  static_assert(!stan::test::is_ref_element_v<2, decltype(args)>,
+                "2nd should not be a reference!");
+}
+
+TEST(MathFunctions, filter_map_inner_tuple_mix_value_type) {
+  using stan::test::is_lvalue_ref_element_v;
+  using stan::test::is_same_tuple_element_v;
+  double a = 1.0;
+  std::vector<int> b{1, 2, 3};
+  auto args = stan::math::filter_map<is_any_fp_or_vector>(
+      [](auto&& arg) -> decltype(auto) {
+        return std::forward<decltype(arg)>(arg);
+      },
+      std::forward_as_tuple(
+          1, 2.0, b, 4, 5, a, std::vector<int>{0, 8, 7},
+          std::forward_as_tuple(1, std::vector<int>{3, 2, 1}, b), b, 6.0));
+  using args_t = decltype(args);
+  static_assert(is_same_tuple_element_v<0, args_t, double>,
+                "0th should be a double!");
+  static_assert(!stan::test::is_ref_element_v<0, args_t>,
+                "0th should not be a reference!");
+  static_assert(is_lvalue_ref_element_v<1, args_t>, "1st should be an lvalue!");
+  static_assert(is_same_tuple_element_v<1, args_t, std::vector<int>>,
+                "1st should be an std::vector<int>!");
+  static_assert(is_lvalue_ref_element_v<2, args_t>, "2nd should be an lvalue!");
+  static_assert(is_same_tuple_element_v<2, args_t, double>,
+                "2nd should be a double!");
+  static_assert(!stan::test::is_ref_element_v<3, args_t>,
+                "3rd should not be a reference!");
+  static_assert(is_same_tuple_element_v<3, args_t, std::vector<int>>,
+                "3rd should be an std::vector<int>!");
+  using inner_tuple_t = std::tuple_element_t<4, args_t>;
+  static_assert(!stan::test::is_ref_element_v<0, inner_tuple_t>,
+                "tuple<4><0> should not be a reference!");
+  static_assert(is_same_tuple_element_v<0, inner_tuple_t, std::vector<int>>,
+                "tuple<4><0> should be an std::vector<int>!");
+  static_assert(is_lvalue_ref_element_v<1, inner_tuple_t>,
+                "tuple<4><1> should be an lvalue!");
+  static_assert(is_same_tuple_element_v<1, inner_tuple_t, std::vector<int>>,
+                "tuple<4><1> should be an std::vector<int>!");
+  static_assert(is_lvalue_ref_element_v<5, args_t>, "5th should be an lvalue!");
+  static_assert(is_same_tuple_element_v<5, args_t, std::vector<int>>,
+                "5th should be an std::vector<int>!");
+  static_assert(!stan::test::is_ref_element_v<6, args_t>,
+                "6th should not be a reference!");
+  static_assert(is_same_tuple_element_v<6, args_t, double>,
+                "6th should be a double!");
+}
+
+TEST(MathFunctions, filter_map_array_tuple) {
+  using stan::test::is_same_tuple_element_v;
+  std::vector<std::tuple<double, int>> vec{{1.0, 2}, {4.0, 5}, {7.0, 8}};
+  std::tuple<decltype(vec), decltype(vec)> test_tup{vec, vec};
+  auto args = stan::math::filter_map<is_any_fp_scalar>(
+      [](auto&& arg) -> decltype(auto) {
+        return std::forward<decltype(arg)>(arg);
+      },
+      test_tup);
+  static_assert(std::tuple_size_v<decltype(args)> == 2,
+                "tuple size should be 2!");
+  static_assert(is_same_tuple_element_v<0, decltype(args),
+                                        std::vector<std::tuple<double&>>>,
+                "0th should be a vector of tuples!");
+  static_assert(is_same_tuple_element_v<1, decltype(args),
+                                        std::vector<std::tuple<double&>>>,
+                "0th should be a vector of tuples!");
+}
+
+TEST(MathFunctions, filter_map_array_array_tuple) {
+  using stan::test::is_same_tuple_element_v;
+  std::vector<std::tuple<double, int>> vec{{1.0, 2}, {4.0, 5}, {7.0, 8}};
+  std::tuple<decltype(vec), decltype(vec)> test_tup{vec, vec};
+  std::vector<decltype(test_tup)> test_vec_tup_vec;
+  test_vec_tup_vec.push_back(test_tup);
+  test_vec_tup_vec.push_back(test_tup);
+  auto args = stan::math::filter_map<is_any_fp_scalar>(
+      [](auto&& arg) -> decltype(auto) {
+        return std::forward<decltype(arg)>(arg);
+      },
+      // tuple(vector<tuple(vector<tuple(double, int)), vector<tuple(double,
+      // int))> * 2)
+      std::make_tuple(test_vec_tup_vec));
+  static_assert(std::tuple_size_v<decltype(args)> == 1,
+                "tuple size should be 1!");
+  auto&& inner_arg = std::get<0>(std::get<0>(args)[0])[0];
+  static_assert(
+      std::is_same_v<std::decay_t<decltype(inner_arg)>, std::tuple<double&>>,
+      "No!");
+}
+
+}  // namespace
diff --git a/test/unit/math/prim/functor/for_each_test.cpp b/test/unit/math/prim/functor/for_each_test.cpp
index 2e67a64eb2b..941baeb2e3e 100644
--- a/test/unit/math/prim/functor/for_each_test.cpp
+++ b/test/unit/math/prim/functor/for_each_test.cpp
@@ -24,7 +24,7 @@ TEST(MathFunctions, for_each_basic_unary_index) {
   std::vector<int> v = {-5, 2};
   auto x = std::make_tuple(v, v);
 
-  auto f = [](auto& y) {
+  auto f = [](auto&& y) {
     y[0] += 1;
     y[1] += 1;
     return;
diff --git a/test/unit/math/prim/functor/iter_tuple_nested_test.cpp b/test/unit/math/prim/functor/iter_tuple_nested_test.cpp
new file mode 100644
index 00000000000..928aba055f1
--- /dev/null
+++ b/test/unit/math/prim/functor/iter_tuple_nested_test.cpp
@@ -0,0 +1,57 @@
+#include <stan/math/prim.hpp>
+#include <test/unit/pretty_print_types.hpp>
+#include <test/unit/math/prim/util.hpp>
+#include <gtest/gtest.h>
+#include <tuple>
+#include <type_traits>
+#include <vector>
+
+namespace {
+
+TEST(MathFunctions, iter_tuple_nested_empty) {
+  auto x = 1;
+  stan::math::iter_tuple_nested([&x](auto&& args) { return x++; },
+                                std::make_tuple());
+  // This should never call the lambda, so x should not change.
+  EXPECT_EQ(x, 1);
+}
+
+TEST(MathFunctions, iter_tuple_nested_basic) {
+  auto output = std::make_tuple(1, 2, 3);
+  stan::math::iter_tuple_nested([](auto&& arg1, auto&& arg2) { arg1 += arg2; },
+                                output, std::make_tuple(1, 2, 3));
+  EXPECT_EQ(std::get<0>(output), 2);
+  EXPECT_EQ(std::get<1>(output), 4);
+  EXPECT_EQ(std::get<2>(output), 6);
+}
+
+TEST(MathFunctions, iter_tuple_nested_deep_tuple) {
+  using inner_vec_t = std::vector<std::tuple<int, int>>;
+  inner_vec_t inner_val{{1, 2}, {2, 3}};
+  using inner_t = std::tuple<inner_vec_t, inner_vec_t>;
+  auto output = std::make_tuple(1, inner_t{inner_val, inner_val}, 3);
+  auto input = output;
+  stan::math::iter_tuple_nested(
+      [](auto&& arg1, auto&& arg2) { return arg1 += arg2; }, output, input);
+  EXPECT_EQ(std::get<0>(output), 2);
+
+  auto&& inner_output = std::get<0>(std::get<1>(output));
+  auto&& inner_val_i = inner_output[0];
+  EXPECT_EQ(std::get<0>(inner_val_i), 2);
+  EXPECT_EQ(std::get<1>(inner_val_i), 4);
+  inner_val_i = inner_output[1];
+  EXPECT_EQ(std::get<0>(inner_val_i), 4);
+  EXPECT_EQ(std::get<1>(inner_val_i), 6);
+
+  inner_output = std::get<1>(std::get<1>(output));
+  inner_val_i = inner_output[0];
+  EXPECT_EQ(std::get<0>(inner_val_i), 2);
+  EXPECT_EQ(std::get<1>(inner_val_i), 4);
+  inner_val_i = inner_output[1];
+  EXPECT_EQ(std::get<0>(inner_val_i), 4);
+  EXPECT_EQ(std::get<1>(inner_val_i), 6);
+
+  EXPECT_EQ(std::get<2>(output), 6);
+}
+
+}  // namespace
diff --git a/test/unit/math/prim/functor/make_holder_tuple_test.cpp b/test/unit/math/prim/functor/make_holder_tuple_test.cpp
new file mode 100644
index 00000000000..3473802d447
--- /dev/null
+++ b/test/unit/math/prim/functor/make_holder_tuple_test.cpp
@@ -0,0 +1,37 @@
+#include <stan/math/prim.hpp>
+#include <test/unit/util.hpp>
+#include <test/unit/math/prim/util.hpp>
+#include <gtest/gtest.h>
+#include <vector>
+#include <stdexcept>
+namespace {
+
+TEST(MathMatrix, partial_forward_as_tuples_rvalues) {
+  using stan::test::is_const_ref_element_v;
+  using stan::test::is_lvalue_ref_element_v;
+  using stan::test::is_ref_element_v;
+  Eigen::MatrixXd a = Eigen::MatrixXd::Random(3, 3);
+  const Eigen::MatrixXd a_const = Eigen::MatrixXd::Random(3, 3);
+  auto a_expr = Eigen::MatrixXd::Random(3, 3);
+  auto x_fwd_tuple = stan::math::make_holder_tuple(
+      a * a, a, a.array() * 3, Eigen::MatrixXd::Random(3, 3), a_const,
+      a_const * a_const, a_expr, a_expr * a_expr);
+  using x_ref_t = decltype(x_fwd_tuple);
+  static_assert(!is_ref_element_v<0, x_ref_t>,
+                "0th entry should be an lvalue!");
+  static_assert(is_lvalue_ref_element_v<1, x_ref_t>,
+                "1st entry should be an lvalue reference!");
+  static_assert(!is_ref_element_v<2, x_ref_t>,
+                "2nd entry should be an lvalue!");
+  static_assert(!is_ref_element_v<3, x_ref_t>,
+                "3rd entry should be an lvalue!");
+  static_assert(is_const_ref_element_v<4, x_ref_t>,
+                "4th entry should be an const lvalue reference!");
+  static_assert(!is_ref_element_v<5, x_ref_t>,
+                "5th entry should be an lvalue!");
+  static_assert(is_lvalue_ref_element_v<6, x_ref_t>,
+                "6th entry should be an lvalue reference!");
+  static_assert(!is_ref_element_v<7, x_ref_t>,
+                "7th entry should be an lvalue!");
+}
+}  // namespace
diff --git a/test/unit/math/prim/functor/map_if_test.cpp b/test/unit/math/prim/functor/map_if_test.cpp
new file mode 100644
index 00000000000..a96640ba0f9
--- /dev/null
+++ b/test/unit/math/prim/functor/map_if_test.cpp
@@ -0,0 +1,42 @@
+#include <stan/math/prim.hpp>
+#include <test/unit/util.hpp>
+#include <test/unit/math/prim/util.hpp>
+#include <gtest/gtest.h>
+#include <vector>
+#include <stdexcept>
+namespace {
+template <typename T>
+using is_floating_point_decay = std::is_floating_point<std::decay_t<T>>;
+TEST(MathPrim, map_if_base) {
+  using stan::math::map_if;
+  auto x
+      = map_if<is_floating_point_decay>([](auto&& x) noexcept { return x + 1; },
+                                        std::forward_as_tuple(1, 2.0, 3, 4.0));
+  EXPECT_EQ(std::get<0>(x), 1);
+  EXPECT_EQ(std::get<1>(x), 3.0);
+  EXPECT_EQ(std::get<2>(x), 3);
+  EXPECT_EQ(std::get<3>(x), 5.0);
+}
+
+TEST(MathPrim, map_if_eigen) {
+  using stan::math::map_if;
+  using stan::test::is_ref_element_v;
+  using stan::test::is_same_tuple_element_v;
+  Eigen::MatrixXd a = Eigen::MatrixXd::Random(3, 3);
+  std::vector<double> b{1, 2, 3};
+  auto x = map_if<stan::is_eigen>(
+      [](auto&& x) { return (x * x).eval(); },
+      std::forward_as_tuple(a, b, a * a, std::vector<int>{1, 2, 3}));
+  EXPECT_MATRIX_EQ(std::get<0>(x), (a * a).eval());
+  static_assert(is_same_tuple_element_v<0, decltype(x), Eigen::MatrixXd>,
+                "1st should be MatrixXd!");
+  static_assert(!is_ref_element_v<0, decltype(x)>, "0th should be an lvalue!");
+  for (int i = 0; i < b.size(); i++) {
+    EXPECT_EQ(std::get<1>(x)[i], b[i]);
+  }
+  static_assert(is_ref_element_v<1, decltype(x)>,
+                "1st should be an reference!");
+  static_assert(!is_ref_element_v<2, decltype(x)>, "2nd should be an lvalue!");
+  static_assert(!is_ref_element_v<3, decltype(x)>, "3rd should be an lvalue!");
+}
+}  // namespace
diff --git a/test/unit/math/prim/functor/tuple_concat_test.cpp b/test/unit/math/prim/functor/tuple_concat_test.cpp
new file mode 100644
index 00000000000..78e2c12c74a
--- /dev/null
+++ b/test/unit/math/prim/functor/tuple_concat_test.cpp
@@ -0,0 +1,104 @@
+#include <tuple>
+#include <type_traits>
+#include <string>
+#include <utility>
+#include <gtest/gtest.h>
+#include <stan/math/prim/functor/tuple_concat.hpp>
+
+// Test that forwarding a single tuple returns the same tuple.
+TEST(TupleConcat, SingleTuple) {
+  auto t = std::make_tuple(1, 2.0, 'a');
+  auto result = stan::math::tuple_concat(t);
+  static_assert(std::tuple_size<decltype(result)>::value == 3,
+                "Result should have 3 elements");
+  EXPECT_EQ(std::get<0>(result), 1);
+  EXPECT_DOUBLE_EQ(std::get<1>(result), 2.0);
+  EXPECT_EQ(std::get<2>(result), 'a');
+}
+
+// Test concatenating two tuples.
+TEST(TupleConcat, TwoTuples) {
+  auto t1 = std::make_tuple(1, 2.0);
+  auto t2 = std::make_tuple('a', std::string("hello"));
+  auto result = stan::math::tuple_concat(t1, t2);
+  static_assert(std::tuple_size<decltype(result)>::value == 4,
+                "Resulting tuple size should be 4");
+  EXPECT_EQ(std::get<0>(result), 1);
+  EXPECT_DOUBLE_EQ(std::get<1>(result), 2.0);
+  EXPECT_EQ(std::get<2>(result), 'a');
+  EXPECT_EQ(std::get<3>(result), std::string("hello"));
+}
+
+// Test concatenating three tuples.
+TEST(TupleConcat, ThreeTuples) {
+  auto t1 = std::make_tuple(1);
+  auto t2 = std::make_tuple(2.0);
+  auto t3 = std::make_tuple('a', std::string("world"));
+  auto result = stan::math::tuple_concat(t1, t2, t3);
+  static_assert(std::tuple_size<decltype(result)>::value == 4,
+                "Resulting tuple size should be 4");
+  EXPECT_EQ(std::get<0>(result), 1);
+  EXPECT_DOUBLE_EQ(std::get<1>(result), 2.0);
+  EXPECT_EQ(std::get<2>(result), 'a');
+  EXPECT_EQ(std::get<3>(result), std::string("world"));
+}
+
+// Test concatenating more than three tuples.
+TEST(TupleConcat, MultipleTuples) {
+  auto t1 = std::make_tuple(1);
+  auto t2 = std::make_tuple(2.0);
+  auto t3 = std::make_tuple('a');
+  auto t4 = std::make_tuple(std::string("test"));
+  auto result = stan::math::tuple_concat(t1, t2, t3, t4);
+  static_assert(std::tuple_size<decltype(result)>::value == 4,
+                "Resulting tuple size should be 4");
+  EXPECT_EQ(std::get<0>(result), 1);
+  EXPECT_DOUBLE_EQ(std::get<1>(result), 2.0);
+  EXPECT_EQ(std::get<2>(result), 'a');
+  EXPECT_EQ(std::get<3>(result), std::string("test"));
+}
+
+// Test concatenation when some of the tuples are empty.
+TEST(TupleConcat, EmptyTuples) {
+  auto empty = std::make_tuple();
+  auto t = std::make_tuple(42);
+  auto result = stan::math::tuple_concat(empty, t, empty);
+  static_assert(std::tuple_size<decltype(result)>::value == 1,
+                "Resulting tuple size should be 1");
+  EXPECT_EQ(std::get<0>(result), 42);
+}
+
+// Test that rvalue and lvalue forwarding is preserved.
+TEST(TupleConcat, RvalueAndLvalueForwarding) {
+  int a = 42;
+  // Using forward_as_tuple to create a tuple with an lvalue reference.
+  auto t1 = std::forward_as_tuple(a);
+  auto t2 = std::make_tuple(3.14);
+  auto result = stan::math::tuple_concat(t1, t2);
+  // The first element should be an lvalue reference.
+  static_assert(std::is_same_v<std::tuple_element_t<0, decltype(result)>, int&>,
+                "First element should be int&");
+  static_assert(
+      std::is_same_v<std::tuple_element_t<1, decltype(result)>, double&>,
+      "Second element should be double");
+  a = 100;
+  EXPECT_EQ(std::get<0>(result), 100);
+}
+
+// Test three tuples of differing sizes to ensure that all elements are included
+// (this test may expose issues if the wrong tuple size is used for one of the
+// inputs).
+TEST(TupleConcat, ThreeTuplesDifferentSizes) {
+  auto t1 = std::make_tuple(1, 2, 3);
+  auto t2 = std::make_tuple(4);
+  auto t3 = std::make_tuple(5, 6);  // t3 has 2 elements.
+  auto result = stan::math::tuple_concat(t1, t2, t3);
+  static_assert(std::tuple_size<decltype(result)>::value == 6,
+                "Resulting tuple size should be 6");
+  EXPECT_EQ(std::get<0>(result), 1);
+  EXPECT_EQ(std::get<1>(result), 2);
+  EXPECT_EQ(std::get<2>(result), 3);
+  EXPECT_EQ(std::get<3>(result), 4);
+  EXPECT_EQ(std::get<4>(result), 5);
+  EXPECT_EQ(std::get<5>(result), 6);
+}
diff --git a/test/unit/math/prim/meta/holder_test.cpp b/test/unit/math/prim/meta/holder_test.cpp
index d0614dc7bde..7d43777b1bc 100644
--- a/test/unit/math/prim/meta/holder_test.cpp
+++ b/test/unit/math/prim/meta/holder_test.cpp
@@ -23,7 +23,7 @@ auto f3(T&& a) {
 
 template <typename T>
 auto f4(T&& a) {
-  return stan::math::make_holder([](auto& mat) { return mat.array(); },
+  return stan::math::make_holder([](auto&& mat) { return mat.array(); },
                                  std::forward<T>(a));
 }
 }  // namespace holder_test
diff --git a/test/unit/math/prim/util.hpp b/test/unit/math/prim/util.hpp
index cfb08adc869..a7ec6321093 100644
--- a/test/unit/math/prim/util.hpp
+++ b/test/unit/math/prim/util.hpp
@@ -6,6 +6,77 @@
 
 namespace stan {
 namespace test {
+template <typename T>
+struct always_true {
+  static constexpr bool value = true;
+};
+template <typename T>
+struct always_false {
+  static constexpr bool value = false;
+};
+
+namespace internal {
+
+template <typename T>
+struct contains_floating_point {
+  static constexpr bool value = std::is_floating_point_v<std::decay_t<T>>;
+};
+template <typename... Types>
+struct contains_floating_point<std::tuple<Types...>> {
+  static constexpr bool value
+      = (contains_floating_point<std::decay_t<Types>>::value || ...);
+};
+
+template <typename T>
+struct contains_std_vector {
+  static constexpr bool value = stan::is_std_vector<std::decay_t<T>>::value;
+};
+
+template <typename... Types>
+struct contains_std_vector<std::tuple<Types...>> {
+  static constexpr bool value
+      = (stan::is_std_vector<std::decay_t<Types>>::value || ...);
+};
+}  // namespace internal
+template <typename... Types>
+struct contains_floating_point {
+  static constexpr bool value
+      = (internal::contains_floating_point<std::decay_t<Types>>::value || ...);
+};
+
+template <typename... Types>
+struct contains_std_vector {
+  static constexpr bool value
+      = (internal::contains_std_vector<std::decay_t<Types>>::value || ...);
+};
+
+template <Eigen::Index Idx, typename Tuple>
+static constexpr bool is_const_ref_element_v = std::is_const_v<
+    std::remove_reference_t<std::tuple_element_t<Idx, Tuple>>>&&
+    std::is_reference_v<std::tuple_element_t<Idx, Tuple>>;
+
+template <typename T>
+struct is_fp_or_std_vector
+    : std::bool_constant<
+          internal::contains_floating_point<std::decay_t<T>>::value
+          || internal::contains_std_vector<std::decay_t<T>>::value> {};
+
+template <Eigen::Index Idx, typename Tuple>
+static constexpr bool is_lvalue_ref_element_v
+    = std::is_lvalue_reference_v<std::tuple_element_t<Idx, Tuple>>;
+
+template <Eigen::Index Idx, typename Tuple>
+static constexpr bool is_ref_element_v
+    = std::is_reference_v<std::tuple_element_t<Idx, Tuple>>;
+
+template <Eigen::Index Idx, typename Tuple>
+static constexpr bool is_rvalue_element_v
+    = std::is_rvalue_reference_v<std::tuple_element_t<Idx, Tuple>>;
+
+template <Eigen::Index Idx, typename Tuple, typename T>
+static constexpr bool is_same_tuple_element_v
+    = std::is_same<std::decay_t<std::tuple_element_t<Idx, Tuple>>, T>::value;
+
 namespace unit {
 
 /**
diff --git a/test/unit/math/relative_tolerance.hpp b/test/unit/math/relative_tolerance.hpp
index 16eaca8cc4d..481cfbd4863 100644
--- a/test/unit/math/relative_tolerance.hpp
+++ b/test/unit/math/relative_tolerance.hpp
@@ -20,13 +20,13 @@ class relative_tolerance {
   /**
    * Construct with default tolerances
    */
-  relative_tolerance() : tol_(1e-8), tol_min_(1e-14) {}
+  constexpr relative_tolerance() : tol_(1e-8), tol_min_(1e-14) {}
 
   /**
    * Construct with default tol_min (max(tol_ * tol_, 1e-14))
    * @param tol_ the relative tolerance
    */
-  relative_tolerance(const double tol)  // NOLINT
+  constexpr relative_tolerance(const double tol)  // NOLINT
       : tol_(tol), tol_min_(std::max(tol * tol, 1e-14)) {}
 
   /**
@@ -34,21 +34,21 @@ class relative_tolerance {
    * @param[in] tol_ the relative tolerance
    * @param[in] tol_min_ the minimum absolute tolerance
    */
-  relative_tolerance(const double tol, const double tol_min)
+  constexpr relative_tolerance(const double tol, const double tol_min)
       : tol_(tol), tol_min_(tol_min) {}
 
-  double tol() const { return tol_; }
-  double tol_min() const { return tol_min_; }
+  constexpr double tol() const { return tol_; }
+  constexpr double tol_min() const { return tol_min_; }
 
-  relative_tolerance change_tol(double tol) const {
+  constexpr relative_tolerance change_tol(double tol) const {
     return relative_tolerance(tol, tol_min_);
   }
 
-  relative_tolerance change_tol_min(double tol_min) const {
+  constexpr relative_tolerance change_tol_min(double tol_min) const {
     return relative_tolerance(tol_, tol_min);
   }
 
-  relative_tolerance operator*(double a) const {
+  constexpr relative_tolerance operator*(double a) const {
     return relative_tolerance(a * tol_, a * tol_min_);
   }
 
diff --git a/test/unit/math/rev/meta/is_var_test.cpp b/test/unit/math/rev/meta/is_var_test.cpp
index ec276e7ab7a..6c8148d2b2e 100644
--- a/test/unit/math/rev/meta/is_var_test.cpp
+++ b/test/unit/math/rev/meta/is_var_test.cpp
@@ -13,3 +13,32 @@ TEST(MetaTraitsRevScal, is_var) {
   EXPECT_FALSE((is_var<double>::value));
   EXPECT_FALSE((is_var<stan::math::vari_value<double>>::value));
 }
+
+TEST(MetaTraitsRevScal, is_any_var_scalar) {
+  using stan::is_any_var_scalar;
+  using stan::is_any_var_scalar_v;
+  using stan::math::var;
+  using stan::math::var_value;
+  EXPECT_TRUE(is_any_var_scalar<stan::math::var>::value);
+  EXPECT_TRUE((is_any_var_scalar<stan::math::var_value<float>>::value));
+  EXPECT_TRUE((is_any_var_scalar<stan::math::var_value<long double>>::value));
+  EXPECT_FALSE(is_any_var_scalar<stan::math::vari>::value);
+  EXPECT_FALSE((is_any_var_scalar<double>::value));
+  EXPECT_FALSE((is_any_var_scalar<stan::math::vari_value<double>>::value));
+
+  EXPECT_TRUE((is_any_var_scalar_v<
+               std::tuple<stan::math::var, double, std::vector<double>>>));
+  EXPECT_TRUE((
+      is_any_var_scalar_v<std::tuple<
+          std::vector<Eigen::Matrix<double, -1, 1, 0, -1, 1>,
+                      std::allocator<Eigen::Matrix<double, -1, 1, 0, -1, 1>>> &,
+          const double &, stan::math::var_value<double, void> &>>));
+  EXPECT_TRUE(
+      (is_any_var_scalar_v<
+          Eigen::Matrix<double, -1, 1, 0, -1, 1>,
+          Eigen::Matrix<double, 0, 0, 0, 0, 0>,
+          std::tuple<
+              std::tuple<std::vector<Eigen::Matrix<double, -1, 1, 0, -1, 1>> &,
+                         stan::math::var_value<double, void> &>,
+              const double &>>));
+}
diff --git a/test/unit/math/rev/util.hpp b/test/unit/math/rev/util.hpp
index 3725aa1da0b..53acc1f41c4 100644
--- a/test/unit/math/rev/util.hpp
+++ b/test/unit/math/rev/util.hpp
@@ -57,12 +57,12 @@ using VarMatImpls = testing::Types<stan::math::test::var_matrix_types<false>,
 
 namespace test {
 
-void check_varis_on_stack(const stan::math::var& x) {
+inline void check_varis_on_stack(const stan::math::var& x) {
   EXPECT_TRUE(stan::math::ChainableStack::instance_->memalloc_.in_stack(x.vi_))
       << "not on the stack";
 }
 
-void check_varis_on_stack(const std::vector<stan::math::var>& x) {
+inline void check_varis_on_stack(const std::vector<stan::math::var>& x) {
   for (size_t n = 0; n < x.size(); ++n)
     EXPECT_TRUE(
         stan::math::ChainableStack::instance_->memalloc_.in_stack(x[n].vi_))
@@ -70,7 +70,8 @@ void check_varis_on_stack(const std::vector<stan::math::var>& x) {
 }
 
 template <int R, int C>
-void check_varis_on_stack(const Eigen::Matrix<stan::math::var, R, C>& x) {
+inline void check_varis_on_stack(
+    const Eigen::Matrix<stan::math::var, R, C>& x) {
   for (int j = 0; j < x.cols(); ++j)
     for (int i = 0; i < x.rows(); ++i)
       EXPECT_TRUE(stan::math::ChainableStack::instance_->memalloc_.in_stack(
diff --git a/test/unit/math/test_ad.hpp b/test/unit/math/test_ad.hpp
index e98c932f855..bc6f186c901 100644
--- a/test/unit/math/test_ad.hpp
+++ b/test/unit/math/test_ad.hpp
@@ -339,17 +339,19 @@ void test_grad_hessian(const ad_tolerances& tols, const F& f,
  * @param g polymorphic functor from vectors to scalars
  * @param x argument to test
  */
-template <typename G>
+template <bool ReverseOnly = false, typename G>
 void expect_ad_derivatives(const ad_tolerances& tols, const G& g,
                            const Eigen::VectorXd& x) {
   double gx = g(x);
   test_gradient(tols, g, x, gx);
+  if constexpr (!ReverseOnly) {
 #ifndef STAN_MATH_TESTS_REV_ONLY
-  test_gradient_fvar(tols, g, x, gx);
-  test_hessian(tols, g, x, gx);
-  test_hessian_fvar(tols, g, x, gx);
-  test_grad_hessian(tols, g, x, gx);
+    test_gradient_fvar(tols, g, x, gx);
+    test_hessian(tols, g, x, gx);
+    test_hessian_fvar(tols, g, x, gx);
+    test_grad_hessian(tols, g, x, gx);
 #endif
+  }
 }
 
 /**
@@ -387,18 +389,20 @@ void expect_throw(const F& f, const Eigen::VectorXd& x,
  * @param f function to test
  * @param x argument to test
  */
-template <typename F>
+template <bool ReverseOnly = false, typename F>
 void expect_all_throw(const F& f, const Eigen::VectorXd& x) {
   using stan::math::fvar;
   using stan::math::var;
   expect_throw<double>(f, x, "double");
   expect_throw<var>(f, x, "var");
+  if constexpr (!ReverseOnly) {
 #ifndef STAN_MATH_TESTS_REV_ONLY
-  expect_throw<fvar<double>>(f, x, "fvar<double>");
-  expect_throw<fvar<fvar<double>>>(f, x, "fvar<fvar<double>>");
-  expect_throw<fvar<var>>(f, x, "fvar<var>");
-  expect_throw<fvar<fvar<var>>>(f, x, "fvar<fvar<var>>");
+    expect_throw<fvar<double>>(f, x, "fvar<double>");
+    expect_throw<fvar<fvar<double>>>(f, x, "fvar<fvar<double>>");
+    expect_throw<fvar<var>>(f, x, "fvar<var>");
+    expect_throw<fvar<fvar<var>>>(f, x, "fvar<fvar<var>>");
 #endif
+  }
 }
 
 /**
@@ -409,13 +413,13 @@ void expect_all_throw(const F& f, const Eigen::VectorXd& x) {
  * @param f function to evaluate
  * @param x argument to evaluate
  */
-template <typename F>
+template <bool ReverseOnly = false, typename F>
 void expect_all_throw(const F& f, double x1) {
   using stan::math::serialize_return;
   auto h = [&](auto v) { return serialize_return(eval(f(v(0)))); };
   Eigen::VectorXd x(1);
   x << x1;
-  expect_all_throw(h, x);
+  expect_all_throw<ReverseOnly>(h, x);
 }
 
 /**
@@ -427,13 +431,13 @@ void expect_all_throw(const F& f, double x1) {
  * @param x1 first argument
  * @param x2 second argument
  */
-template <typename F>
+template <bool ReverseOnly = false, typename F>
 void expect_all_throw(const F& f, double x1, double x2) {
   using stan::math::serialize_return;
   auto h = [&](auto v) { return serialize_return(eval(f(v(0), v(1)))); };
   Eigen::VectorXd x(2);
   x << x1, x2;
-  expect_all_throw(h, x);
+  expect_all_throw<ReverseOnly>(h, x);
 }
 
 /**
@@ -446,13 +450,13 @@ void expect_all_throw(const F& f, double x1, double x2) {
  * @param x2 second argument
  * @param x3 third argument
  */
-template <typename F>
+template <bool ReverseOnly = false, typename F>
 void expect_all_throw(const F& f, double x1, double x2, double x3) {
   using stan::math::serialize_return;
   auto h = [&](auto v) { return serialize_return(eval(f(v(0), v(1), v(2)))); };
   Eigen::VectorXd x(3);
   x << x1, x2, x3;
-  expect_all_throw(h, x);
+  expect_all_throw<ReverseOnly>(h, x);
 }
 
 /**
@@ -476,7 +480,7 @@ void expect_all_throw(const F& f, double x1, double x2, double x3) {
  * @param x serialized input
  * @param xs sequence of arguments with double-based scalars
  */
-template <typename F, typename G, typename... Ts>
+template <bool ReverseOnly = false, typename F, typename G, typename... Ts>
 void expect_ad_helper(const ad_tolerances& tols, const F& f, const G& g,
                       const Eigen::VectorXd& x, Ts... xs) {
   using stan::math::serialize;
@@ -490,11 +494,11 @@ void expect_ad_helper(const ad_tolerances& tols, const F& f, const G& g,
     expect_near_rel("expect_ad_helper", y1_serial, y2, 1e-10);
     result_size = y1_serial.size();
   } catch (...) {
-    internal::expect_all_throw(h(0), x);
+    internal::expect_all_throw<ReverseOnly>(h(0), x);
     return;
   }
   for (size_t i = 0; i < result_size; ++i) {
-    expect_ad_derivatives(tols, h(i), x);
+    expect_ad_derivatives<ReverseOnly>(tols, h(i), x);
   }
 }
 
@@ -509,7 +513,7 @@ void expect_ad_helper(const ad_tolerances& tols, const F& f, const G& g,
  * @param f functor to test
  * @param x argument to test
  */
-template <typename F, typename T>
+template <bool ReverseOnly = false, typename F, typename T>
 void expect_ad_v(const ad_tolerances& tols, const F& f, const T& x) {
   using stan::math::serialize_args;
   using stan::math::serialize_return;
@@ -519,7 +523,7 @@ void expect_ad_v(const ad_tolerances& tols, const F& f, const T& x) {
     auto xds = ds.read(x);
     return serialize_return(eval(f(xds)));
   };
-  internal::expect_ad_helper(tols, f, g, serialize_args(x), x);
+  internal::expect_ad_helper<ReverseOnly>(tols, f, g, serialize_args(x), x);
 }
 
 /**
@@ -538,7 +542,7 @@ void expect_ad_v(const ad_tolerances& tols, const F& f, const T& x) {
  * @param f functor to test
  * @param x argument to test
  */
-template <typename F>
+template <bool ReverseOnly = false, typename F>
 void expect_ad_v(const ad_tolerances& tols, const F& f, int x) {
   double x_dbl = static_cast<double>(x);
 
@@ -546,7 +550,7 @@ void expect_ad_v(const ad_tolerances& tols, const F& f, int x) {
   try {
     f(x);
   } catch (...) {
-    expect_all_throw(f, x_dbl);
+    expect_all_throw<ReverseOnly>(f, x_dbl);
     return;
   }
 
@@ -555,7 +559,7 @@ void expect_ad_v(const ad_tolerances& tols, const F& f, int x) {
                   f(x_dbl), f(x));
 
   // autodiff should work at double value
-  expect_ad_v(tols, f, x_dbl);
+  expect_ad_v<ReverseOnly>(tols, f, x_dbl);
 }
 
 /**
@@ -572,7 +576,7 @@ void expect_ad_v(const ad_tolerances& tols, const F& f, int x) {
  * @param x1 first argument
  * @param x2 second argument
  */
-template <typename F, typename T1, typename T2>
+template <bool ReverseOnly = false, typename F, typename T1, typename T2>
 void expect_ad_vv(const ad_tolerances& tols, const F& f, const T1& x1,
                   const T2& x2) {
   using stan::math::serialize_args;
@@ -584,7 +588,8 @@ void expect_ad_vv(const ad_tolerances& tols, const F& f, const T1& x1,
     auto x1ds = ds.read(x1);
     return serialize_return(eval(f(x1ds, x2)));
   };
-  internal::expect_ad_helper(tols, f, g1, serialize_args(x1), x1, x2);
+  internal::expect_ad_helper<ReverseOnly>(tols, f, g1, serialize_args(x1), x1,
+                                          x2);
 
   // d.x2
   auto g2 = [&](const auto& v) {
@@ -592,7 +597,8 @@ void expect_ad_vv(const ad_tolerances& tols, const F& f, const T1& x1,
     auto x2ds = ds.read(x2);
     return serialize_return(eval(f(x1, x2ds)));
   };
-  internal::expect_ad_helper(tols, f, g2, serialize_args(x2), x1, x2);
+  internal::expect_ad_helper<ReverseOnly>(tols, f, g2, serialize_args(x2), x1,
+                                          x2);
 
   // d.x1, d.x2
   auto g12 = [&](const auto& v) {
@@ -601,15 +607,16 @@ void expect_ad_vv(const ad_tolerances& tols, const F& f, const T1& x1,
     auto x2ds = ds.read(x2);
     return serialize_return(eval(f(x1ds, x2ds)));
   };
-  internal::expect_ad_helper(tols, f, g12, serialize_args(x1, x2), x1, x2);
+  internal::expect_ad_helper<ReverseOnly>(tols, f, g12, serialize_args(x1, x2),
+                                          x1, x2);
 }
 
-template <typename F, typename T2>
+template <bool ReverseOnly = false, typename F, typename T2>
 void expect_ad_vv(const ad_tolerances& tols, const F& f, int x1, const T2& x2) {
   try {
     f(x1, x2);
   } catch (...) {
-    expect_all_throw(f, x1, x2);
+    expect_all_throw<ReverseOnly>(f, x1, x2);
     return;
   }
 
@@ -619,19 +626,19 @@ void expect_ad_vv(const ad_tolerances& tols, const F& f, int x1, const T2& x2) {
   expect_near_rel("expect_ad_vv(int, T2)", f(x1, x2), f(x1_dbl, x2));
 
   // expect autodiff to work at double value
-  expect_ad_vv(tols, f, x1_dbl, x2);
+  expect_ad_vv<ReverseOnly>(tols, f, x1_dbl, x2);
 
   // expect autodiff to work when binding int; includes expect-all-throw test
   auto g = [&](const auto& u) { return f(x1, u); };
-  expect_ad_v(tols, g, x2);
+  expect_ad_v<ReverseOnly>(tols, g, x2);
 }
 
-template <typename F, typename T1>
+template <bool ReverseOnly = false, typename F, typename T1>
 void expect_ad_vv(const ad_tolerances& tols, const F& f, const T1& x1, int x2) {
   try {
     f(x1, x2);
   } catch (...) {
-    expect_all_throw(f, x1, x2);
+    expect_all_throw<ReverseOnly>(f, x1, x2);
     return;
   }
 
@@ -641,20 +648,20 @@ void expect_ad_vv(const ad_tolerances& tols, const F& f, const T1& x1, int x2) {
   expect_near_rel("expect_ad_vv(T1, int)", f(x1, x2), f(x1, x2_dbl));
 
   // expect autodiff to work at double value
-  expect_ad_vv(tols, f, x1, x2_dbl);
+  expect_ad_vv<ReverseOnly>(tols, f, x1, x2_dbl);
 
   // expect autodiff to work when binding int; includes expect-all-throw test
   auto g = [&](const auto& u) { return f(u, x2); };
-  expect_ad_v(tols, g, x1);
+  expect_ad_v<ReverseOnly>(tols, g, x1);
 }
 
-template <typename F>
+template <bool ReverseOnly = false, typename F>
 void expect_ad_vv(const ad_tolerances& tols, const F& f, int x1, int x2) {
   // this one needs throw test because it's not handled by recursion
   try {
     f(x1, x2);
   } catch (...) {
-    expect_all_throw(f, x1, x2);
+    expect_all_throw<ReverseOnly>(f, x1, x2);
     return;
   }
 
@@ -667,8 +674,8 @@ void expect_ad_vv(const ad_tolerances& tols, const F& f, int x1, int x2) {
   // expect autodiff to work at double values
   // these take care of x1_dbl, x2_dbl case by delegation
   // they also take care of binding int tests
-  expect_ad_vv(tols, f, x1, x2_dbl);
-  expect_ad_vv(tols, f, x1_dbl, x2);
+  expect_ad_vv<ReverseOnly>(tols, f, x1, x2_dbl);
+  expect_ad_vv<ReverseOnly>(tols, f, x1_dbl, x2);
 }
 
 /**
@@ -687,7 +694,8 @@ void expect_ad_vv(const ad_tolerances& tols, const F& f, int x1, int x2) {
  * @param x2 second argument
  * @param x3 third argument
  */
-template <typename F, typename T1, typename T2, typename T3>
+template <bool ReverseOnly = false, typename F, typename T1, typename T2,
+          typename T3>
 void expect_ad_vvv(const ad_tolerances& tols, const F& f, const T1& x1,
                    const T2& x2, const T3& x3) {
   using stan::math::serialize_args;
@@ -699,7 +707,8 @@ void expect_ad_vvv(const ad_tolerances& tols, const F& f, const T1& x1,
     auto x1ds = ds.read(x1);
     return serialize_return(eval(f(x1ds, x2, x3)));
   };
-  internal::expect_ad_helper(tols, f, g1, serialize_args(x1), x1, x2, x3);
+  internal::expect_ad_helper<ReverseOnly>(tols, f, g1, serialize_args(x1), x1,
+                                          x2, x3);
 
   // d.x2
   auto g2 = [&](const auto& v) {
@@ -707,7 +716,8 @@ void expect_ad_vvv(const ad_tolerances& tols, const F& f, const T1& x1,
     auto x2ds = ds.read(x2);
     return serialize_return(eval(f(x1, x2ds, x3)));
   };
-  internal::expect_ad_helper(tols, f, g2, serialize_args(x2), x1, x2, x3);
+  internal::expect_ad_helper<ReverseOnly>(tols, f, g2, serialize_args(x2), x1,
+                                          x2, x3);
 
   // d.x3
   auto g3 = [&](const auto& v) {
@@ -715,7 +725,8 @@ void expect_ad_vvv(const ad_tolerances& tols, const F& f, const T1& x1,
     auto x3ds = ds.read(x3);
     return serialize_return(eval(f(x1, x2, x3ds)));
   };
-  internal::expect_ad_helper(tols, f, g3, serialize_args(x3), x1, x2, x3);
+  internal::expect_ad_helper<ReverseOnly>(tols, f, g3, serialize_args(x3), x1,
+                                          x2, x3);
 
   // d.x1 d.x2
   auto g12 = [&](const auto& v) {
@@ -724,7 +735,8 @@ void expect_ad_vvv(const ad_tolerances& tols, const F& f, const T1& x1,
     auto x2ds = ds.read(x2);
     return serialize_return(eval(f(x1ds, x2ds, x3)));
   };
-  internal::expect_ad_helper(tols, f, g12, serialize_args(x1, x2), x1, x2, x3);
+  internal::expect_ad_helper<ReverseOnly>(tols, f, g12, serialize_args(x1, x2),
+                                          x1, x2, x3);
 
   // d.x1 d.x3
   auto g13 = [&](const auto& v) {
@@ -733,7 +745,8 @@ void expect_ad_vvv(const ad_tolerances& tols, const F& f, const T1& x1,
     auto x3ds = ds.read(x3);
     return serialize_return(eval(f(x1ds, x2, x3ds)));
   };
-  internal::expect_ad_helper(tols, f, g13, serialize_args(x1, x3), x1, x2, x3);
+  internal::expect_ad_helper<ReverseOnly>(tols, f, g13, serialize_args(x1, x3),
+                                          x1, x2, x3);
 
   // d.x2 d.x3
   auto g23 = [&](const auto& v) {
@@ -742,7 +755,8 @@ void expect_ad_vvv(const ad_tolerances& tols, const F& f, const T1& x1,
     auto x3ds = ds.read(x3);
     return serialize_return(eval(f(x1, x2ds, x3ds)));
   };
-  internal::expect_ad_helper(tols, f, g23, serialize_args(x2, x3), x1, x2, x3);
+  internal::expect_ad_helper<ReverseOnly>(tols, f, g23, serialize_args(x2, x3),
+                                          x1, x2, x3);
 
   // d.x1 d.x2 d.x3
   auto g123 = [&](const auto& v) {
@@ -752,17 +766,17 @@ void expect_ad_vvv(const ad_tolerances& tols, const F& f, const T1& x1,
     auto x3ds = ds.read(x3);
     return serialize_return(eval(f(x1ds, x2ds, x3ds)));
   };
-  internal::expect_ad_helper(tols, f, g123, serialize_args(x1, x2, x3), x1, x2,
-                             x3);
+  internal::expect_ad_helper<ReverseOnly>(
+      tols, f, g123, serialize_args(x1, x2, x3), x1, x2, x3);
 }
 
-template <typename F, typename T3>
+template <bool ReverseOnly = false, typename F, typename T3>
 void expect_ad_vvv(const ad_tolerances& tols, const F& f, int x1, int x2,
                    const T3& x3) {
   try {
     f(x1, x2, x3);
   } catch (...) {
-    expect_all_throw(f, x1, x2, x3);
+    expect_all_throw<ReverseOnly>(f, x1, x2, x3);
     return;
   }
 
@@ -770,8 +784,8 @@ void expect_ad_vvv(const ad_tolerances& tols, const F& f, int x1, int x2,
   double x2_dbl = static_cast<double>(x2);
 
   // test all promotion patterns;  includes x1_dbl & x2_dbl recursively
-  expect_ad_vvv(tols, f, x1_dbl, x2, x3);
-  expect_ad_vvv(tols, f, x1, x2_dbl, x3);
+  expect_ad_vvv<ReverseOnly>(tols, f, x1_dbl, x2, x3);
+  expect_ad_vvv<ReverseOnly>(tols, f, x1, x2_dbl, x3);
 
   // test value
   expect_near_rel("expect_ad_vvv(int, int, T3)", f(x1, x2, x3),
@@ -779,26 +793,26 @@ void expect_ad_vvv(const ad_tolerances& tols, const F& f, int x1, int x2,
 
   // bind ints and test autodiff
   auto g23 = [=](const auto& u2, const auto& u3) { return f(x1, u2, u3); };
-  expect_ad_vv(tols, g23, x2, x3);
+  expect_ad_vv<ReverseOnly>(tols, g23, x2, x3);
 
   auto g13 = [=](const auto& u1, const auto& u3) { return f(u1, x2, u3); };
-  expect_ad_vv(tols, g13, x1, x3);
+  expect_ad_vv<ReverseOnly>(tols, g13, x1, x3);
 }
 
-template <typename F, typename T2, typename T3>
+template <bool ReverseOnly = false, typename F, typename T2, typename T3>
 void expect_ad_vvv(const ad_tolerances& tols, const F& f, int x1, const T2& x2,
                    const T3& x3) {
   try {
     f(x1, x2, x3);
   } catch (...) {
-    expect_all_throw(f, x1, x2, x3);
+    expect_all_throw<ReverseOnly>(f, x1, x2, x3);
     return;
   }
 
   double x1_dbl = static_cast<double>(x1);
 
   // test all promotion patterns
-  expect_ad_vvv(tols, f, x1_dbl, x2, x3);
+  expect_ad_vvv<ReverseOnly>(tols, f, x1_dbl, x2, x3);
 
   // test value
   expect_near_rel("expect_ad_vvv(int, int, T3)", f(x1, x2, x3),
@@ -806,23 +820,23 @@ void expect_ad_vvv(const ad_tolerances& tols, const F& f, int x1, const T2& x2,
 
   // bind ints and test autodiff
   auto g23 = [=](const auto& u2, const auto& u3) { return f(x1, u2, u3); };
-  expect_ad_vv(tols, g23, x2, x3);
+  expect_ad_vv<ReverseOnly>(tols, g23, x2, x3);
 }
 
-template <typename F, typename T1, typename T3>
+template <bool ReverseOnly = false, typename F, typename T1, typename T3>
 void expect_ad_vvv(const ad_tolerances& tols, const F& f, const T1& x1, int x2,
                    const T3& x3) {
   try {
     f(x1, x2, x3);
   } catch (...) {
-    expect_all_throw(f, x1, x2, x3);
+    expect_all_throw<ReverseOnly>(f, x1, x2, x3);
     return;
   }
 
   double x2_dbl = static_cast<double>(x2);
 
   // test promotion
-  expect_ad_vvv(tols, f, x1, x2_dbl, x3);
+  expect_ad_vvv<ReverseOnly>(tols, f, x1, x2_dbl, x3);
 
   // test value
   expect_near_rel("expect_ad_vvv(int, int, T3)", f(x1, x2, x3),
@@ -830,23 +844,23 @@ void expect_ad_vvv(const ad_tolerances& tols, const F& f, const T1& x1, int x2,
 
   // bind ints and test autodiff
   auto g13 = [=](const auto& u1, const auto& u3) { return f(u1, x2, u3); };
-  expect_ad_vv(tols, g13, x1, x3);
+  expect_ad_vv<ReverseOnly>(tols, g13, x1, x3);
 }
 
-template <typename F, typename T1, typename T2>
+template <bool ReverseOnly = false, typename F, typename T1, typename T2>
 void expect_ad_vvv(const ad_tolerances& tols, const F& f, const T1& x1,
                    const T2& x2, int x3) {
   try {
     f(x1, x2, x3);
   } catch (...) {
-    expect_all_throw(f, x1, x2, x3);
+    expect_all_throw<ReverseOnly>(f, x1, x2, x3);
     return;
   }
 
   double x3_dbl = static_cast<double>(x3);
 
   // test promotion
-  expect_ad_vvv(tols, f, x1, x2, x3_dbl);
+  expect_ad_vvv<ReverseOnly>(tols, f, x1, x2, x3_dbl);
 
   // test value
   expect_near_rel("expect_ad_vvv(int, int, T3)", f(x1, x2, x3),
@@ -854,16 +868,16 @@ void expect_ad_vvv(const ad_tolerances& tols, const F& f, const T1& x1,
 
   // bind ints and test autodiff
   auto g12 = [=](const auto& u1, const auto& u2) { return f(u1, u2, x3); };
-  expect_ad_vv(tols, g12, x1, x2);
+  expect_ad_vv<ReverseOnly>(tols, g12, x1, x2);
 }
 
-template <typename F, typename T2>
+template <bool ReverseOnly = false, typename F, typename T2>
 void expect_ad_vvv(const ad_tolerances& tols, const F& f, int x1, const T2& x2,
                    int x3) {
   try {
     f(x1, x2, x3);
   } catch (...) {
-    expect_all_throw(f, x1, x2, x3);
+    expect_all_throw<ReverseOnly>(f, x1, x2, x3);
     return;
   }
 
@@ -871,8 +885,8 @@ void expect_ad_vvv(const ad_tolerances& tols, const F& f, int x1, const T2& x2,
   double x3_dbl = static_cast<double>(x3);
 
   // test promotion recursively
-  expect_ad_vvv(tols, f, x1_dbl, x2, x3);
-  expect_ad_vvv(tols, f, x1, x2, x3_dbl);
+  expect_ad_vvv<ReverseOnly>(tols, f, x1_dbl, x2, x3);
+  expect_ad_vvv<ReverseOnly>(tols, f, x1, x2, x3_dbl);
 
   // test value
   expect_near_rel("expect_ad_vvv(int, int, T3)", f(x1, x2, x3),
@@ -880,19 +894,19 @@ void expect_ad_vvv(const ad_tolerances& tols, const F& f, int x1, const T2& x2,
 
   // bind ints and test autodiff
   auto g23 = [=](const auto& u2, const auto& u3) { return f(x1, u2, u3); };
-  expect_ad_vv(tols, g23, x2, x3);
+  expect_ad_vv<ReverseOnly>(tols, g23, x2, x3);
 
   auto g12 = [=](const auto& u1, const auto& u2) { return f(u1, u2, x3); };
-  expect_ad_vv(tols, g12, x1, x2);
+  expect_ad_vv<ReverseOnly>(tols, g12, x1, x2);
 }
 
-template <typename F, typename T1>
+template <bool ReverseOnly = false, typename F, typename T1>
 void expect_ad_vvv(const ad_tolerances& tols, const F& f, const T1& x1, int x2,
                    int x3) {
   try {
     f(x1, x2, x3);
   } catch (...) {
-    expect_all_throw(f, x1, x2, x3);
+    expect_all_throw<ReverseOnly>(f, x1, x2, x3);
     return;
   }
 
@@ -900,8 +914,8 @@ void expect_ad_vvv(const ad_tolerances& tols, const F& f, const T1& x1, int x2,
   double x3_dbl = static_cast<double>(x3);
 
   // test promotion recursively
-  expect_ad_vvv(tols, f, x1, x2_dbl, x3);
-  expect_ad_vvv(tols, f, x1, x2, x3_dbl);
+  expect_ad_vvv<ReverseOnly>(tols, f, x1, x2_dbl, x3);
+  expect_ad_vvv<ReverseOnly>(tols, f, x1, x2, x3_dbl);
 
   // test value
   expect_near_rel("expect_ad_vvv(int, int, T3)", f(x1, x2, x3),
@@ -909,20 +923,20 @@ void expect_ad_vvv(const ad_tolerances& tols, const F& f, const T1& x1, int x2,
 
   // bind ints and test autodiff
   auto g13 = [=](const auto& u1, const auto& u3) { return f(u1, x2, u3); };
-  expect_ad_vv(tols, g13, x1, x3);
+  expect_ad_vv<ReverseOnly>(tols, g13, x1, x3);
 
   auto g12 = [=](const auto& u1, const auto& u2) { return f(u1, u2, x3); };
-  expect_ad_vv(tols, g12, x1, x2);
+  expect_ad_vv<ReverseOnly>(tols, g12, x1, x2);
 }
 
-template <typename F>
+template <bool ReverseOnly = false, typename F>
 void expect_ad_vvv(const ad_tolerances& tols, const F& f, int x1, int x2,
                    int x3) {
   // test exception behavior; other exception cases tested recursively
   try {
     f(x1, x2, x3);
   } catch (...) {
-    expect_all_throw(f, x1, x2, x3);
+    expect_all_throw<ReverseOnly>(f, x1, x2, x3);
     return;
   }
 
@@ -935,19 +949,19 @@ void expect_ad_vvv(const ad_tolerances& tols, const F& f, int x1, int x2,
                   f(x1_dbl, x2_dbl, x3_dbl));
 
   // test all promotion patterns;  includes all combos recursively
-  expect_ad_vvv(tols, f, x1_dbl, x2, x3);
-  expect_ad_vvv(tols, f, x1, x2_dbl, x3);
-  expect_ad_vvv(tols, f, x1, x2, x3_dbl);
+  expect_ad_vvv<ReverseOnly>(tols, f, x1_dbl, x2, x3);
+  expect_ad_vvv<ReverseOnly>(tols, f, x1, x2_dbl, x3);
+  expect_ad_vvv<ReverseOnly>(tols, f, x1, x2, x3_dbl);
 
   // bind ints and test recursively
   auto g12 = [=](const auto& u1, const auto& u2) { return f(u1, u2, x3); };
-  expect_ad_vv(tols, g12, x1, x2);
+  expect_ad_vv<ReverseOnly>(tols, g12, x1, x2);
 
   auto g13 = [=](const auto& u1, const auto& u3) { return f(u1, x2, u3); };
-  expect_ad_vv(tols, g13, x1, x3);
+  expect_ad_vv<ReverseOnly>(tols, g13, x1, x3);
 
   auto g23 = [=](const auto& u2, const auto& u3) { return f(x1, u2, u3); };
-  expect_ad_vv(tols, g23, x2, x3);
+  expect_ad_vv<ReverseOnly>(tols, g23, x2, x3);
 }
 
 /**
@@ -1049,19 +1063,19 @@ void expect_comparison(const F& f, const T1& x1, const T2& x2) {
 
 }  // namespace internal
 
-template <typename F>
+template <bool ReverseOnly = false, typename F>
 void expect_all_throw(const F& f, double x) {
-  internal::expect_all_throw(f, x);
+  internal::expect_all_throw<ReverseOnly>(f, x);
 }
 
-template <typename F>
+template <bool ReverseOnly = false, typename F>
 void expect_all_throw(const F& f, double x1, double x2) {
-  internal::expect_all_throw(f, x1, x2);
+  internal::expect_all_throw<ReverseOnly>(f, x1, x2);
 }
 
-template <typename F>
+template <bool ReverseOnly = false, typename F>
 void expect_all_throw(const F& f, double x1, double x2, double x3) {
-  internal::expect_all_throw(f, x1, x2, x3);
+  internal::expect_all_throw<ReverseOnly>(f, x1, x2, x3);
 }
 
 /**
@@ -1151,9 +1165,9 @@ void expect_value(const F& f, const T1& x1, const T2& x2) {
  * @param f function to test
  * @param x argument to test
  */
-template <typename F, typename T>
+template <bool ReverseOnly = false, typename F, typename T>
 void expect_ad(const ad_tolerances& tols, const F& f, const T& x) {
-  internal::expect_ad_v(tols, f, x);
+  internal::expect_ad_v<ReverseOnly>(tols, f, x);
 }
 
 /**
@@ -1167,10 +1181,10 @@ void expect_ad(const ad_tolerances& tols, const F& f, const T& x) {
  * @param f function to test
  * @param x argument to test
  */
-template <typename F, typename T>
+template <bool ReverseOnly = false, typename F, typename T>
 void expect_ad(const F& f, const T& x) {
-  ad_tolerances tols;
-  expect_ad(tols, f, x);
+  constexpr ad_tolerances tols;
+  expect_ad<ReverseOnly>(tols, f, x);
 }
 
 /**
@@ -1187,10 +1201,10 @@ void expect_ad(const F& f, const T& x) {
  * @param x1 first argument to test
  * @param x2 second argument to test
  */
-template <typename F, typename T1, typename T2>
+template <bool ReverseOnly = false, typename F, typename T1, typename T2>
 void expect_ad(const ad_tolerances& tols, const F& f, const T1& x1,
                const T2& x2) {
-  internal::expect_ad_vv(tols, f, x1, x2);
+  internal::expect_ad_vv<ReverseOnly>(tols, f, x1, x2);
 }
 
 /**
@@ -1205,10 +1219,10 @@ void expect_ad(const ad_tolerances& tols, const F& f, const T1& x1,
  * @param x1 first argument to test
  * @param x2 second argument to test
  */
-template <typename F, typename T1, typename T2>
+template <bool ReverseOnly = false, typename F, typename T1, typename T2>
 void expect_ad(const F& f, const T1& x1, const T2& x2) {
-  ad_tolerances tols;
-  expect_ad(tols, f, x1, x2);
+  constexpr ad_tolerances tols;
+  expect_ad<ReverseOnly>(tols, f, x1, x2);
 }
 
 /**
@@ -1227,10 +1241,11 @@ void expect_ad(const F& f, const T1& x1, const T2& x2) {
  * @param x2 second argument to test
  * @param x3 third argument to test
  */
-template <typename F, typename T1, typename T2, typename T3>
+template <bool ReverseOnly = false, typename F, typename T1, typename T2,
+          typename T3>
 void expect_ad(const ad_tolerances& tols, const F& f, const T1& x1,
                const T2& x2, const T3& x3) {
-  internal::expect_ad_vvv(tols, f, x1, x2, x3);
+  internal::expect_ad_vvv<ReverseOnly>(tols, f, x1, x2, x3);
 }
 
 /**
@@ -1247,10 +1262,11 @@ void expect_ad(const ad_tolerances& tols, const F& f, const T1& x1,
  * @param x2 second argument to test
  * @param x3 third argument to test
  */
-template <typename F, typename T1, typename T2, typename T3>
+template <bool ReverseOnly = false, typename F, typename T1, typename T2,
+          typename T3>
 void expect_ad(const F& f, const T1& x1, const T2& x2, const T3& x3) {
-  ad_tolerances tols;
-  expect_ad(tols, f, x1, x2, x3);
+  constexpr ad_tolerances tols;
+  expect_ad<ReverseOnly>(tols, f, x1, x2, x3);
 }
 
 /**
@@ -1480,7 +1496,7 @@ void expect_ad_vectorized(const ad_tolerances& tols, const F& f, const T1& x1) {
 template <ScalarSupport ComplexSupport = ScalarSupport::Real, typename F,
           typename T>
 void expect_ad_vectorized(const F& f, const T& x) {
-  ad_tolerances tols;
+  constexpr ad_tolerances tols;
   expect_ad_vectorized<ComplexSupport>(tols, f, x);
 }
 
@@ -1713,7 +1729,7 @@ void expect_ad_vectorized_ternary(const ad_tolerances& tols, const F& f,
  */
 template <typename F, typename T1, typename T2>
 void expect_ad_vectorized_binary(const F& f, const T1& x, const T2& y) {
-  ad_tolerances tols;
+  constexpr ad_tolerances tols;
   expect_ad_vectorized_binary(tols, f, x, y);
 }
 
@@ -1734,7 +1750,7 @@ void expect_ad_vectorized_binary(const F& f, const T1& x, const T2& y) {
 template <typename F, typename T1, typename T2, typename T3>
 void expect_ad_vectorized_ternary(const F& f, const T1& x, const T2& y,
                                   const T3& z) {
-  ad_tolerances tols;
+  constexpr ad_tolerances tols;
   expect_ad_vectorized_ternary(tols, f, x, y, z);
 }
 
@@ -1987,7 +2003,7 @@ template <
     ScalarSupport ComplexSupport = ScalarSupport::Real, typename F,
     require_t<bool_constant<ComplexSupport == ScalarSupport::Real>>* = nullptr>
 void expect_common_unary_vectorized(const F& f) {
-  ad_tolerances tols;
+  constexpr ad_tolerances tols;
   auto args = internal::common_args();
   for (double x1 : args)
     stan::test::expect_ad_vectorized<ComplexSupport>(tols, f, x1);
@@ -2018,7 +2034,7 @@ template <ScalarSupport ComplexSupport, typename F,
           require_t<bool_constant<ComplexSupport
                                   == ScalarSupport::RealAndComplex>>* = nullptr>
 void expect_common_unary_vectorized(const F& f) {
-  ad_tolerances tols;
+  constexpr ad_tolerances tols;
   auto args = internal::common_args();
   for (double x1 : args)
     stan::test::expect_ad_vectorized<ComplexSupport>(tols, f, x1);
@@ -2051,7 +2067,7 @@ template <ScalarSupport ComplexSupport, typename F,
           require_t<bool_constant<ComplexSupport
                                   == ScalarSupport::ComplexOnly>>* = nullptr>
 void expect_common_unary_vectorized(const F& f) {
-  ad_tolerances tols;
+  constexpr ad_tolerances tols;
   for (auto x1 : common_complex())
     stan::test::expect_ad_vectorized<ComplexSupport>(tols, f, x1);
 }
@@ -2096,7 +2112,7 @@ void expect_unary_vectorized(const ad_tolerances& tols, const F& f, T x,
 template <ScalarSupport ComplexSupport = ScalarSupport::Real, typename F,
           require_not_same_t<F, ad_tolerances>* = nullptr, typename... Ts>
 void expect_unary_vectorized(const F& f, Ts... xs) {
-  ad_tolerances tols;  // default tolerances
+  constexpr ad_tolerances tols;  // default tolerances
   expect_unary_vectorized<ComplexSupport>(tols, f, xs...);
 }
 
@@ -2117,7 +2133,7 @@ template <ScalarSupport ComplexSupport = ScalarSupport::Real, typename F,
           stan::require_t<stan::bool_constant<
               ComplexSupport == ScalarSupport::Real>>* = nullptr>
 void expect_common_nonzero_unary_vectorized(const F& f) {
-  ad_tolerances tols;
+  constexpr ad_tolerances tols;
   for (double x : internal::common_nonzero_args())
     stan::test::expect_unary_vectorized<ComplexSupport>(tols, f, x);
   for (auto x : internal::common_nonzero_int_args())
@@ -2141,7 +2157,7 @@ template <ScalarSupport ComplexSupport, typename F,
           stan::require_t<stan::bool_constant<
               ComplexSupport == ScalarSupport::RealAndComplex>>* = nullptr>
 void expect_common_nonzero_unary_vectorized(const F& f) {
-  ad_tolerances tols;
+  constexpr ad_tolerances tols;
   for (double x : internal::common_nonzero_args())
     stan::test::expect_unary_vectorized<ComplexSupport>(tols, f, x);
   for (int x : internal::common_nonzero_int_args())
@@ -2167,7 +2183,7 @@ template <ScalarSupport ComplexSupport, typename F,
           stan::require_t<stan::bool_constant<
               ComplexSupport == ScalarSupport::ComplexOnly>>* = nullptr>
 void expect_common_nonzero_unary_vectorized(const F& f) {
-  ad_tolerances tols;
+  constexpr ad_tolerances tols;
   for (auto x1 : common_complex())
     stan::test::expect_ad_vectorized<ComplexSupport>(tols, f, x1);
 }
diff --git a/test/unit/pretty_print_types.hpp b/test/unit/pretty_print_types.hpp
index 893e92b59a5..0b59f45d186 100644
--- a/test/unit/pretty_print_types.hpp
+++ b/test/unit/pretty_print_types.hpp
@@ -70,26 +70,32 @@ inline std::ostream& operator<<(std::ostream& os, static_string const& s) {
   return os.write(s.data(), s.size());
 }
 
+template <typename... Types>
+struct pack;
 /**
  * Prints out an input type.
  * @tparam T The type to print out.
  */
-template <class Arg>
-CONSTEXPR14_TN static_string type_name() {
+template <typename... Arg>
+inline CONSTEXPR14_TN static_string type_name() {
+  if constexpr (sizeof...(Arg) > 1) {
+    return type_name<pack<Arg...>>();
+  } else {
 #ifdef __clang__
-  static_string p = __PRETTY_FUNCTION__;
-  return static_string(p.data() + 31, p.size() - 31 - 1);
+    static_string p = __PRETTY_FUNCTION__;
+    return static_string(p.data() + 31, p.size() - 31 - 1);
 #elif defined(__GNUC__)
-  static_string p = __PRETTY_FUNCTION__;
+    static_string p = __PRETTY_FUNCTION__;
 #if __cplusplus < 201402
-  return static_string(p.data() + 36, p.size() - 36 - 1);
+    return static_string(p.data() + 36, p.size() - 36 - 1);
 #else
-  return static_string(p.data() + 83, p.size() - 83 - 1);
+    return static_string(p.data() + 83, p.size() - 83 - 1);
 #endif
 #elif defined(_MSC_VER)
-  static_string p = __FUNCSIG__;
-  return static_string(p.data() + 38, p.size() - 38 - 7);
+    static_string p = __FUNCSIG__;
+    return static_string(p.data() + 38, p.size() - 38 - 7);
 #endif
+  }
 }
 
 }  // namespace test